types(ApplicationCommandManager): Deprecate old *Data type usages and allow camel cased dapi types to be used (#6959)

2026-03-13 01:53:30 +01:00 · 2021-11-29 05:17:57 -05:00
parent 54f937d82c
commit 2c91c488e8
5 changed files with 129 additions and 82 deletions
--- a/typings/index.d.ts
+++ b/typings/index.d.ts
@@ -45,6 +45,7 @@ import {
  APIUser,
  GatewayVoiceServerUpdateDispatchData,
  GatewayVoiceStateUpdateDispatchData,
+  RESTPatchAPIApplicationCommandJSONBody,
  RESTPostAPIApplicationCommandsJSONBody,
  Snowflake,
 } from 'discord-api-types/v9';
@@ -137,6 +138,7 @@ import {
  RawWidgetData,
  RawWidgetMemberData,
 } from './rawDataTypes';
+import type { CamelCasedPropertiesDeep } from 'type-fest';

 //#region Classes

@@ -213,7 +215,7 @@ export class ApplicationCommand<PermissionsFetchType = {}> extends Base {
  public readonly manager: ApplicationCommandManager;
  public id: Snowflake;
  public name: string;
-  public options: ApplicationCommandOption[];
+  public options: Camelize<APIApplicationCommandOption>[];
  public permissions: ApplicationCommandPermissionsManager<
    PermissionsFetchType,
    PermissionsFetchType,
@@ -224,23 +226,29 @@ export class ApplicationCommand<PermissionsFetchType = {}> extends Base {
  public type: ApplicationCommandType;
  public version: Snowflake;
  public delete(): Promise<ApplicationCommand<PermissionsFetchType>>;
+  /** @deprecated use `edit(Camelize<RESTPatchAPIApplicationCommandJSONBody>)` instead */
  public edit(data: ApplicationCommandData): Promise<ApplicationCommand<PermissionsFetchType>>;
+  public edit(
+    data: Camelize<RESTPatchAPIApplicationCommandJSONBody>,
+  ): Promise<ApplicationCommand<PermissionsFetchType>>;
  public equals(
-    command: ApplicationCommand | ApplicationCommandData | RawApplicationCommandData,
+    command: ApplicationCommand | Camelize<RESTPatchAPIApplicationCommandJSONBody> | RawApplicationCommandData,
    enforceOptionorder?: boolean,
  ): boolean;
  public static optionsEqual(
-    existing: ApplicationCommandOption[],
-    options: ApplicationCommandOption[] | ApplicationCommandOptionData[] | APIApplicationCommandOption[],
+    existing: Camelize<APIApplicationCommandOption>[],
+    options: Camelize<APIApplicationCommandOption>[] | APIApplicationCommandOption[],
    enforceOptionorder?: boolean,
  ): boolean;
  private static _optionEquals(
-    existing: ApplicationCommandOption,
-    options: ApplicationCommandOption | ApplicationCommandOptionData | APIApplicationCommandOption,
+    existing: Camelize<APIApplicationCommandOption>[],
+    options: Camelize<APIApplicationCommandOption>[] | APIApplicationCommandOption,
    enforceOptionorder?: boolean,
  ): boolean;
-  private static transformOption(option: ApplicationCommandOptionData, received?: boolean): unknown;
-  private static transformCommand(command: ApplicationCommandData): RESTPostAPIApplicationCommandsJSONBody;
+  private static transformOption(option: Camelize<APIApplicationCommandOption>, received?: boolean): unknown;
+  private static transformCommand(
+    command: Camelize<RESTPostAPIApplicationCommandsJSONBody>,
+  ): RESTPostAPIApplicationCommandsJSONBody;
  private static isAPICommandData(command: object): command is RESTPostAPIApplicationCommandsJSONBody;
 }

@@ -2336,10 +2344,8 @@ export class WebhookClient extends WebhookMixin(BaseClient) {
    options: string | MessagePayload | WebhookEditMessageOptions,
  ): Promise<APIMessage>;
  public fetchMessage(message: Snowflake, options?: WebhookFetchMessageOptions): Promise<APIMessage>;
-  /* tslint:disable:unified-signatures */
  /** @deprecated */
  public fetchMessage(message: Snowflake, cache?: boolean): Promise<APIMessage>;
-  /* tslint:enable:unified-signatures */
  public send(options: string | MessagePayload | WebhookMessageOptions): Promise<APIMessage>;
 }

@@ -2640,7 +2646,9 @@ export abstract class CachedManager<K, Holds, R> extends DataManager<K, Holds, R
  private _add(data: unknown, cache?: boolean, { id, extras }?: { id: K; extras: unknown[] }): Holds;
 }

-export type ApplicationCommandDataResolvable = ApplicationCommandData | RESTPostAPIApplicationCommandsJSONBody;
+export type ApplicationCommandDataResolvable =
+  | Camelize<RESTPostAPIApplicationCommandsJSONBody>
+  | RESTPostAPIApplicationCommandsJSONBody;

 export class ApplicationCommandManager<
  ApplicationCommandScope = ApplicationCommand<{ guild: GuildResolvable }>,
@@ -2656,7 +2664,18 @@ export class ApplicationCommandManager<
    null
  >;
  private commandPath({ id, guildId }: { id?: Snowflake; guildId?: Snowflake }): unknown;
+  /** @deprecated use `create(ApplicationCommandDataResolvable)` instead */
+  public create(
+    command: ApplicationCommandData | RESTPostAPIApplicationCommandsJSONBody,
+  ): Promise<ApplicationCommandScope>;
+  /** @deprecated use `create(ApplicationCommandDataResolvable, Snowflake)` instead */
+  public create(
+    command: ApplicationCommandData | RESTPostAPIApplicationCommandsJSONBody,
+    guildId: Snowflake,
+  ): Promise<ApplicationCommand>;
  public create(command: ApplicationCommandDataResolvable, guildId?: Snowflake): Promise<ApplicationCommandScope>;
+  /** @deprecated use `delete(ApplicationCommandDataResolvable, Snowflake?)` instead */
+  public delete(command: ApplicationCommandData, guildId?: Snowflake): Promise<ApplicationCommandScope | null>;
  public delete(command: ApplicationCommandResolvable, guildId?: Snowflake): Promise<ApplicationCommandScope | null>;
  public edit(
    command: ApplicationCommandResolvable,
@@ -2677,13 +2696,20 @@ export class ApplicationCommandManager<
    id?: Snowflake,
    options?: FetchApplicationCommandOptions,
  ): Promise<Collection<Snowflake, ApplicationCommandScope>>;
+  /** @deprecated Use `set(ApplicationCommandResolvable)` instead */
+  public set(commands: ApplicationCommandData[]): Promise<Collection<Snowflake, ApplicationCommandScope>>;
+  /** @deprecated Use `set(ApplicationCommandResolvable, Snowflake)` instead */
+  public set(
+    commands: ApplicationCommandData[],
+    guildId: Snowflake,
+  ): Promise<Collection<Snowflake, ApplicationCommand>>;
  public set(commands: ApplicationCommandDataResolvable[]): Promise<Collection<Snowflake, ApplicationCommandScope>>;
  public set(
    commands: ApplicationCommandDataResolvable[],
    guildId: Snowflake,
  ): Promise<Collection<Snowflake, ApplicationCommand>>;
  private static transformCommand(
-    command: ApplicationCommandData,
+    command: Camelize<RESTPostAPIApplicationCommandsJSONBody>,
  ): Omit<APIApplicationCommand, 'id' | 'application_id' | 'guild_id'>;
 }

@@ -2748,7 +2774,9 @@ export class GuildApplicationCommandManager extends ApplicationCommandManager<Ap
  private constructor(guild: Guild, iterable?: Iterable<RawApplicationCommandData>);
  public guild: Guild;
  public create(command: ApplicationCommandDataResolvable): Promise<ApplicationCommand>;
-  public delete(command: ApplicationCommandResolvable): Promise<ApplicationCommand | null>;
+  /** @deprecated use `delete(ApplicationCommandDataResolvable, Snowflake?)` instead */
+  public delete(command: ApplicationCommandData, guildId?: Snowflake): Promise<ApplicationCommand | null>;
+  public delete(command: ApplicationCommandResolvable, guildId?: Snowflake): Promise<ApplicationCommand | null>;
  public edit(
    command: ApplicationCommandResolvable,
    data: ApplicationCommandDataResolvable,
@@ -2756,6 +2784,8 @@ export class GuildApplicationCommandManager extends ApplicationCommandManager<Ap
  public fetch(id: Snowflake, options?: BaseFetchOptions): Promise<ApplicationCommand>;
  public fetch(options: BaseFetchOptions): Promise<Collection<Snowflake, ApplicationCommand>>;
  public fetch(id?: undefined, options?: BaseFetchOptions): Promise<Collection<Snowflake, ApplicationCommand>>;
+  /** @deprecated Use `set(ApplicationCommandResolvable)` instead */
+  public set(commands: ApplicationCommandData[]): Promise<Collection<Snowflake, ApplicationCommand>>;
  public set(commands: ApplicationCommandDataResolvable[]): Promise<Collection<Snowflake, ApplicationCommand>>;
 }

@@ -3074,10 +3104,8 @@ export interface PartialWebhookFields {
    options: string | MessagePayload | WebhookEditMessageOptions,
  ): Promise<Message | APIMessage>;
  fetchMessage(message: Snowflake | '@original', options?: WebhookFetchMessageOptions): Promise<Message | APIMessage>;
-  /* tslint:disable:unified-signatures */
  /** @deprecated */
  fetchMessage(message: Snowflake | '@original', cache?: boolean): Promise<Message | APIMessage>;
-  /* tslint:enable:unified-signatures */
  send(options: string | MessagePayload | WebhookMessageOptions): Promise<Message | APIMessage>;
 }

@@ -3343,6 +3371,7 @@ export interface ChatInputApplicationCommandData extends BaseApplicationCommandD
  options?: ApplicationCommandOptionData[];
 }

+/** @deprecated use `Camelize<RESTPostApplicationCommandBody>` instead */
 export type ApplicationCommandData =
  | UserApplicationCommandData
  | MessageApplicationCommandData
@@ -3430,6 +3459,10 @@ export interface ApplicationCommandNonOptions extends BaseApplicationCommandOpti
  type: Exclude<CommandOptionNonChoiceResolvableType, ApplicationCommandOptionTypes>;
 }

+// Type alias since the lib name is very long.
+export type Camelize<T> = CamelCasedPropertiesDeep<T>;
+
+/** @deprecated Use `Camelize<APIApplicationCommandsOption>` instead. */
 export type ApplicationCommandOptionData =
  | ApplicationCommandSubGroupData
  | ApplicationCommandNonOptionsData
@@ -3439,6 +3472,7 @@ export type ApplicationCommandOptionData =
  | ApplicationCommandNumericOptionData
  | ApplicationCommandSubCommandData;

+/** @deprecated use `Camelize<APIApplicationCommandOption>` instead */
 export type ApplicationCommandOption =
  | ApplicationCommandSubGroup
  | ApplicationCommandNonOptions
--- a/typings/index.test-d.ts
+++ b/typings/index.test-d.ts
@@ -1,5 +1,4 @@
-import type { ChildProcess } from 'child_process';
-import type {
+import {
  APIInteractionGuildMember,
  APIMessage,
  APIPartialChannel,
@@ -7,15 +6,21 @@ import type {
  APIInteractionDataResolvedGuildMember,
  APIInteractionDataResolvedChannel,
  APIRole,
+  ChannelType,
+  ApplicationCommandOptionType,
+  APIApplicationCommand,
+  APIApplicationCommandOption,
+  APIApplicationCommandSubCommandOptions,
 } from 'discord-api-types/v9';
+import type { ChildProcess } from 'node:child_process';
 import {
  ApplicationCommand,
-  ApplicationCommandData,
+  ApplicationCommandChannelOptionData,
+  ApplicationCommandChoicesData,
  ApplicationCommandManager,
-  ApplicationCommandOptionData,
+  ApplicationCommandNonOptionsData,
  ApplicationCommandResolvable,
  ApplicationCommandSubCommandData,
-  ApplicationCommandSubGroupData,
  BaseCommandInteraction,
  ButtonInteraction,
  CacheType,
@@ -28,7 +33,6 @@ import {
  CommandInteraction,
  CommandInteractionOption,
  CommandInteractionOptionResolver,
-  CommandOptionNonChoiceResolvableType,
  Constants,
  ContextMenuInteraction,
  DMChannel,
@@ -77,6 +81,9 @@ import {
  User,
  VoiceChannel,
  Shard,
+  Camelize,
+  ApplicationCommandAutocompleteOption,
+  ApplicationCommandNumericOptionData,
  WebSocketShard,
  Collector,
 } from '.';
@@ -686,6 +693,20 @@ client.login('absolutely-valid-token');
 // Test client conditional types
 client.on('ready', client => {
  expectType<Client<true>>(client);
+
+  // Test camelized post command data.
+  client.application.commands.create({
+    name: 'Foo',
+    description: 'Bar',
+    options: [
+      {
+        name: 'test',
+        description: 'test',
+        type: ApplicationCommandOptionType.Channel,
+        channelTypes: [ChannelType.GuildCategory],
+      },
+    ],
+  });
 });

 declare const loggedInClient: Client<true>;
@@ -783,7 +804,7 @@ expectType<1>(Constants.Status.CONNECTING);
 expectType<0>(Constants.Opcodes.DISPATCH);
 expectType<2>(Constants.ClientApplicationAssetTypes.BIG);

-declare const applicationCommandData: ApplicationCommandData;
+declare const applicationCommandData: Camelize<APIApplicationCommand>;
 declare const applicationCommandResolvable: ApplicationCommandResolvable;
 declare const applicationCommandManager: ApplicationCommandManager;
 {
@@ -805,22 +826,29 @@ declare const applicationCommandManager: ApplicationCommandManager;
  );
 }

-declare const applicationNonChoiceOptionData: ApplicationCommandOptionData & {
-  type: CommandOptionNonChoiceResolvableType;
-};
+declare const applicationSubGroupCommandData: Camelize<APIApplicationCommandSubCommandOptions>;
 {
-  // Options aren't allowed on this command type.
-
-  // @ts-expect-error
-  applicationNonChoiceOptionData.choices;
-}
-
-declare const applicationSubGroupCommandData: ApplicationCommandSubGroupData;
-{
-  expectType<'SUB_COMMAND_GROUP' | ApplicationCommandOptionTypes.SUB_COMMAND_GROUP>(
+  expectType<ApplicationCommandOptionType.Subcommand | ApplicationCommandOptionType.SubcommandGroup>(
    applicationSubGroupCommandData.type,
  );
-  expectType<ApplicationCommandSubCommandData[] | undefined>(applicationSubGroupCommandData.options);
+  expectAssignable<APIApplicationCommandOption[] | undefined>(applicationSubGroupCommandData.options);
+}
+
+declare const applicationSubCommandData: ApplicationCommandSubCommandData;
+{
+  expectType<'SUB_COMMAND' | ApplicationCommandOptionTypes.SUB_COMMAND>(applicationSubCommandData.type);
+
+  // Check that only subcommands can have no subcommand or subcommand group sub-options.
+  expectType<
+    | (
+        | ApplicationCommandChoicesData
+        | ApplicationCommandNonOptionsData
+        | ApplicationCommandChannelOptionData
+        | ApplicationCommandAutocompleteOption
+        | ApplicationCommandNumericOptionData
+      )[]
+    | undefined
+  >(applicationSubCommandData.options);
 }

 declare const guildApplicationCommandManager: GuildApplicationCommandManager;