refactor(TextBasedChannel): sendSlash

src/errors/Messages.js

@@ -165,6 +165,9 @@ const Messages = {
 
   INVALID_BOT_METHOD: 'Bot accounts cannot use this method',
   INVALID_USER_METHOD: 'User accounts cannot use this method',
+
+  INTERACTION_SEND_FAILURE: msg => `${msg}`,
+
   INVALID_LOCALE: 'Unable to select this location',
   FOLDER_NOT_FOUND: 'Server directory not found',
   FOLDER_POSITION_INVALID: 'The server index in the directory is invalid',

src/structures/Message.js

@@ -1041,8 +1041,8 @@ class Message extends Base {
   }
   /**
    * Select specific menu or First Menu
-   * @param {string<MessageSelectMenu.customID>|Array<MenuOptions>} menuID Select Menu specific id or auto select first Menu
+   * @param {string|Array<string>} menuID Select Menu specific id or auto select first Menu
-   * @param {Array<MenuOptions>} options Menu Options
+   * @param {Array<string>} options Menu Options
    */
   async selectMenu(menuID, options = []) {
     if (!this.components[0]) throw new TypeError('MESSAGE_NO_COMPONENTS');
@@ -1074,37 +1074,54 @@ class Message extends Base {
   //
   /**
    * Send context Menu v2
-   * @param {DiscordBotID} botID Bot id
+   * @param {Snowflake} botId Bot id
-   * @param {string<ApplicationCommand.name>} commandName Command name in Context Menu
+   * @param {string} commandName Command name in Context Menu
-   * @returns {Promise<pending>}
+   * @param {boolean} [search=true] Search for command
+   * @returns {Promise<void>}
    */
-  async contextMenu(botID, commandName) {
+  async contextMenu(botId, commandName, search = true) {
-    if (!botID) throw new Error('Bot ID is required');
+    if (!botId) throw new Error('Bot ID is required');
-    const user = await this.client.users.fetch(botID).catch(() => {});
+    const user = await this.client.users.fetch(botId).catch(() => {});
     if (!user || !user.bot || !user.applications) {
       throw new Error('BotID is not a bot or does not have an application slash command');
     }
     if (!commandName || typeof commandName !== 'string') {
       throw new Error('Command name is required');
     }
-    const listApplication =
+    // https://discord.com/api/v9/channels/817671035813888030/application-commands/search?type=3&application_id=817229550684471297
-      user.applications.cache.size == 0 ? await user.applications.fetch() : user.applications.cache;
+    let contextCMD = user.applications.cache.find(c => c.name == commandName && c.type === 'MESSAGE');
-    let contextCMD;
+    if (!contextCMD && !search) {
-    await Promise.all(
-      listApplication.map(application => {
-        if (commandName == application.name && application.type !== 'CHAT_INPUT') {
-          contextCMD = application;
-        }
-        return true;
-      }),
-    );
-    if (!contextCMD) {
       throw new Error(
-        `Command ${commandName} is not found\nList command avalible: ${listApplication
+        'INTERACTION_SEND_FAILURE',
-          .filter(a => a.type !== 'CHAT_INPUT')
+        `Command ${commandName} is not found (without search)\nList command avalible: ${user.applications.cache
+          .filter(a => a.type == 'MESSAGE')
           .map(a => a.name)
           .join(', ')}`,
       );
+    } else {
+      const data = await this.client.api.channels[this.channelId]['application-commands'].search.get({
+        query: {
+          type: 3, // MESSAGE,
+          // include_applications: false,
+          // query: commandName,
+          limit: 25,
+          // Shet
+          application_id: botId,
+        },
+      });
+      for (const command of data.application_commands) {
+        user.applications._add(command, true);
+      }
+      contextCMD = user.applications.cache.find(c => c.name == commandName && c.type === 'MESSAGE');
+      if (!contextCMD) {
+        throw new Error(
+          'INTERACTION_SEND_FAILURE',
+          `Command ${commandName} is not found (with search)\nList command avalible: ${user.applications.cache
+            .filter(a => a.type == 'MESSAGE')
+            .map(a => a.name)
+            .join(', ')}`,
+        );
+      }
     }
     return contextCMD.sendContextMenu(this, true);
   }

src/structures/interfaces/TextBasedChannel.js

@@ -391,22 +391,56 @@ class TextBasedChannel {
 
   /**
    * Send Slash to this channel
-   * @param {Snowflake} botId Bot Id
+   * @param {Snowflake} botId Bot Id (Supports application ID - not bot)
    * @param {string} commandName Command name
+   * @param {boolean} [search=true] Whether to search for the command
    * @param {...?string} args Command arguments
    * @returns {Promise<pending>}
    */
-  async sendSlash(botId, commandName, ...args) {
+  async sendSlash(botId, commandName, search = true, ...args) {
-    // If (!this.isText()) throw new Error('This channel is not text-based.');
     if (!botId) throw new Error('Bot ID is required');
+    // ? maybe ...
     const user = await this.client.users.fetch(botId).catch(() => {});
     if (!user || !user.bot || !user.applications) {
       throw new Error('botId is not a bot or does not have an application slash command');
     }
     if (!commandName || typeof commandName !== 'string') throw new Error('Command name is required');
-    const commandTarget = user.applications.cache.find(c => c.name === commandName && c.type === 'CHAT_INPUT');
+    let commandTarget = user.applications.cache.find(c => c.name === commandName && c.type === 'CHAT_INPUT');
-    if (!commandTarget) {
+    if (!commandTarget && !search) {
-      throw new Error(`Command ${commandName} is not found\nDebug:\n+ botId: ${botId}\n+ args: ${args.join(' | ')}`);
+      throw new Error(
+        'INTERACTION_SEND_FAILURE',
+        `SlashCommand ${commandName} is not found (Without search)\nDebug:\n+ botId: ${botId}\n+ args: ${args.join(
+          ' | ',
+        )}`,
+      );
+    } else {
+      // Using API to search (without opcode ~ehehe)
+      // https://discord.com/api/v9/channels/id/application-commands/search?type=1&query=aiko&limit=7&include_applications=false&application_id=id
+      const data = await this.client.api.channels[this.id]['application-commands'].search.get({
+        query: {
+          type: 1, // CHAT_INPUT,
+          include_applications: false,
+          query: commandName,
+          limit: 25,
+          // Shet
+          // application_id: botId,
+        },
+      });
+      for (const command of data.application_commands) {
+        if (user.id == command.application_id) {
+          commandTarget = user.applications._add(command, true);
+        }
+      }
+      // Remove
+      // commandTarget = user.applications.cache.find(c => c.name === commandName && c.type === 'CHAT_INPUT');
+      if (!commandTarget) {
+        throw new Error(
+          'INTERACTION_SEND_FAILURE',
+          `SlashCommand ${commandName} is not found (With search)\nDebug:\n+ botId: ${botId}\n+ args: ${args.join(
+            ' | ',
+          )}`,
+        );
+      }
     }
     return commandTarget.sendSlashCommand(
       new Message(this.client, {

typings/index.d.ts

@@ -1672,7 +1672,7 @@ export class Message<Cached extends boolean = boolean> extends Base {
   public clickButton(buttonID: string): Promise<void>;
   public selectMenu(menuID: string, options: string[]): Promise<void>;
   public selectMenu(options: string[]): Promise<void>;
-  public contextMenu(botID: Snowflake, commandName: string): Promise<void>;
+  public contextMenu(botID: Snowflake, commandName: string, search?: boolean): Promise<void>;
 }
 
 export class MessageActionRow<
@@ -2555,7 +2555,6 @@ export class TextChannel extends BaseGuildTextChannel {
   public rateLimitPerUser: number;
   public threads: ThreadManager<AllowedThreadTypeForTextChannel>;
   public type: 'GUILD_TEXT';
-  public sendSlash(botID: Snowflake, commandName: string, args?: Options[]): Promise<undefined>;
 }
 
 export class TextInputComponent extends BaseMessageComponent {
@@ -3720,6 +3719,7 @@ export interface TextBasedChannelFields extends PartialTextBasedChannelFields {
   setNSFW(nsfw?: boolean, reason?: string): Promise<this>;
   fetchWebhooks(): Promise<Collection<Snowflake, Webhook>>;
   sendTyping(): Promise<void>;
+  sendSlash(botId: Snowflake, commandName: string, search?: boolean, ...args: any): Promise<undefined>;
 }
 
 export function PartialWebhookMixin<T>(Base?: Constructable<T>): Constructable<T & PartialWebhookFields>;