@somehiddenkey/discord-command-utils 2.5.0 → 2.6.0

package/README.md

@@ -144,6 +144,30 @@ The same exists for:
 - Selection menu : `OnSelectMenu`
 - Message : `OnMessageCommand`
 - Modal submission : `OnModal`
+
+A slash command with a specific subcommand can be defined as follows:
+```js
+Interaction.OnSlashCommand(
+    {name: "ping", subcommand: "webping"}, 
+    InteractionScope.Main, 
+    async (interaction) => await interaction.reply("pong")
+);
+```
+### Callback arguments
+#### Message arguments
+Message commands start with a prefix, after which the proceeding arguments are the arguments. E.g. the message `!ping "google.com"` would trigger `async (interaction, website) => //...`
+
+#### Interaction IDs
+You can burry hidden information in the custom ID of a selection menu, button and modal submission by concatting them to them to the custom ID. The helper function `Interaction.makeCustomId()` exists for this. This is handy to e.g. hide session IDs as not to have to recompute them. Example:
+```js
+new ButtonBuilder().setCustomId(Interaction.makeCustomId("ping", session_id))
+
+Interaction.OnButton(
+    "ping", InteractionScope.Main, 
+    async (interaction, session_id) => await interaction.reply(`pong from ${session_id}`)
+);
+```
+
 ### Call Interaction
 All interactions get stored in a so-called `InteractionContainer` that still needs to be called:
 ```js
@@ -164,7 +188,7 @@ For slash commands to work, you need to register them to a bot. There are two ki
 
 You can add a set of slash commands through the following abstraction:
 ```js
-const rest = interactionContainer.Rest
+const rest = await interactionContainer.Rest
 	.add([firstSlashCommand, secondSlashCommand], localConfig.guilds.tutor)
 	.add([firstSlashCommand, secondSlashCommand], localConfig.guilds.community)
 	.add([somePublicSlashCommand])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@somehiddenkey/discord-command-utils",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "A utility library for building Discord bot commands using discord.js",
   "author": {
     "email": "k3y.throwaway@gmail.com",

package/src/Configs/Fetchable.js

@@ -35,7 +35,7 @@ export default class Fetchable {
                         };
                     }
 
-                    if (prop === "fetch") {
+                    if (prop === "fetchFromBot") {
                         return async () => {
                             if (!cachedObject){
                                 cachedObject = await fetcher(id);

package/src/Configs/GlobalConfig/GlobalConfig.js

@@ -60,13 +60,13 @@ export default class GlobalConfig {
      */
     get_scope(guild_id) {
         switch(guild_id) {
-            case this.main:
+            case this.main.guild.id:
                 return InteractionScope.Main;
-            case this.community:
+            case this.community.guild.id:
                 return InteractionScope.Community;
-            case this.tutor:
+            case this.tutor.guild.id:
                 return InteractionScope.Tutor;
-            case this.staff:
+            case this.staff.guild.id:
                 return InteractionScope.Staff;
             default:
                 return InteractionScope.OtherGuild;

package/src/Interactions/Interaction.js

@@ -15,11 +15,11 @@ const {
 /**
  * @typedef { (interaction: DiscordBaseInteraction<CacheType>) => Promise<any> } InteractionFunction
  * @typedef { (message: OmitPartialGroupDMChannel<Message<boolean>>) => Promise<any> } InteractionMsgFunction
- * @typedef { string } InteractionID
+ * @typedef { {name: string, subcommand: string | null} | string } InteractionID
  */
 
 export default class Interaction {
-    /** @type {string} */
+    /** @type {InteractionID} */
     id;
     /** @type {InteractionType} */
     type;
@@ -94,4 +94,13 @@ export default class Interaction {
     static OnModal(custom_id, scope, target) {
         return Interaction.On(custom_id, InteractionType.Modal, scope, target)
     }
+
+    /**
+     * Hides arbitrary number of arguments in the custom ID
+     * @param  {...any} args
+     * @returns {string}
+     */
+    static makeCustomId(...args) {
+        return args.map(arg => String(arg)).join("?");
+    }
 } 

package/src/Interactions/InteractionContainer.js

@@ -5,22 +5,20 @@ import LocalConfig  from "../Configs/LocalConfig.js";
 import consola from "consola";
 import CommandError from "./CommandError.js";
 import RestCommands from './RestCommands.js';
-import pkg, { ChannelType } from 'discord.js';
-const { 
-    Interaction: DiscordBaseInteraction,
-    OmitPartialGroupDMChannel,
-    Message,
-    CacheType
-} = pkg;
+import { ChannelType } from 'discord.js';
 
 /**
+ * @typedef { import("discord.js").Interaction } DiscordBaseInteraction
+ * @typedef { import("discord.js").OmitPartialGroupDMChannel } OmitPartialGroupDMChannel
+ * @typedef { import("discord.js").Message } Message
+ * @typedef { import("discord.js").CacheType } CacheType
  * @typedef { (interaction: DiscordBaseInteraction<CacheType>) => Promise<any> } InteractionFunction
  * @typedef { (message: OmitPartialGroupDMChannel<Message<boolean>>) => Promise<any> } InteractionMsgFunction
- * @typedef { string } InteractionID
+ * @typedef { import("./Interaction.js").InteractionID } InteractionID
  */
 
 export default class InteractionContainer {
-    /** @type {Map<InteractionID, Interaction>} */
+    /** @type {Map<string, Interaction>} */
     static #interaction_container = new Map();
 
     /** @type {GlobalConfig} */
@@ -29,42 +27,55 @@ export default class InteractionContainer {
     #local_config;
 
     /** @type {RestCommands} */
-    Rest = new RestCommands(this.#global_config, this.#local_config);
+    Rest;
 
     /**
      * @param {InteractionType} type 
      * @param {InteractionScope} scope 
-     * @param {string} id 
-     * @returns {InteractionID}
+     * @param {InteractionID} id 
+     * @returns {string} interction ID
      */
     static #make_key(type, scope, id) {
-        return `${type}__${scope}__${id}`;
+        return `${type}__${scope}__${id.subcommand ? `${id.name}>${id.subcommand}` : (id.name || id)}`;
     }
 
     /**
-     * @param {InteractionType} type 
-     * @param {InteractionScope} scope 
-     * @param {string} id 
      * @param {Interaction} base_interaction
      */ 
     static add(base_interaction) { 
         const key = InteractionContainer.#make_key(base_interaction.type, base_interaction.scope, base_interaction.id);
+        consola.debug(`Registered interaction with key ${key}`);
         InteractionContainer.#interaction_container.set(key, base_interaction);
     }
 
     /**
      * @param {InteractionType} type 
      * @param {InteractionScope} scope 
-     * @param {string} id 
+     * @param {InteractionID} id 
      * @returns {Interaction?}
      */
     static get(type, scope, id) {
-        return InteractionContainer.#interaction_container.get(InteractionContainer.#make_key(type, scope, id));
+        const key = InteractionContainer.#make_key(type, scope, id);
+        consola.debug(`Fetching interaction with key ${key}`);
+        return InteractionContainer.#interaction_container.get(key);
+    }
+
+    static dump() {
+        return Array.from(InteractionContainer.#interaction_container.entries()).map(([key, interaction]) => {
+            return {
+                key,
+                type: interaction.type,
+                scope: interaction.scope,
+                id: interaction.id,
+                function: interaction.interaction_command_function.name
+            }
+        });
     }
 
     constructor(local_config, global_config) {
         this.#local_config = local_config;
         this.#global_config = global_config;
+        this.Rest = new RestCommands(global_config, local_config);
     }
 
     /**
@@ -82,10 +93,10 @@ export default class InteractionContainer {
             (interaction.channel.type === ChannelType.DM) ? 
             InteractionScope.DM : this.#global_config.get_scope(interaction.guild.id); 
 
-        const customId = interaction.content.slice(this.#local_config.prefix?.length)
+        const [customId, ...command_arguments] = interaction.content.slice(this.#local_config.prefix?.length)?.split("?")
 
         return InteractionContainer
-            .#call(InteractionType.Message, scope, [customId], interaction)
+            .#call(interaction, InteractionType.Message, scope, customId, command_arguments)
             .catch(error => {
                 if (error instanceof CommandError)
                     return error.error_as_message(interaction)
@@ -107,8 +118,10 @@ export default class InteractionContainer {
         const scope = 
             (interaction.channel.type === ChannelType.DM) ? 
             InteractionScope.DM : this.#global_config.get_scope(interaction.guild.id);
-
-        const customId = (interaction.commandName || interaction.customId)?.split(/\?(.+)/, 2)
+        console.log(scope)
+        
+        const [customId, ...command_arguments] = (interaction.commandName || interaction.customId)?.split("?")
+        console.log(customId)
 
         var type;
         if (interaction.isChatInputCommand())
@@ -121,9 +134,10 @@ export default class InteractionContainer {
             type = InteractionType.Modal; 
         else 
             return;
+        console.log(type)
         
         return InteractionContainer
-            .#call(type, scope, customId, interaction)
+            .#call(interaction, type, scope, {name: customId, subcommand: interaction.options?.getSubcommand()}, command_arguments)
             .catch(error => {
                 if (error instanceof CommandError)
                     return error.error_as_command(interaction)
@@ -138,18 +152,19 @@ export default class InteractionContainer {
 
     /**
      * 
+     * @param {DiscordBaseInteraction} interaction 
      * @param {InteractionType} type 
      * @param {InteractionScope} scope 
-     * @param {InteractionID[]} customId 
-     * @param {DiscordBaseInteraction} interaction 
+     * @param {InteractionID} customId 
+     * @param {string[]} command_arguments
      * @returns {Promise<any>}
      * @throws {CommandError}
      */
-    static async #call(type, scope, customId, interaction) {
-        const interaction_command = InteractionContainer.get(type, scope, customId?.[0]);
+    static async #call(interaction, type, scope, customId, command_arguments = []) {
+        const interaction_command = InteractionContainer.get(type, scope, customId);
         if(!interaction_command) 
-            return consola.error(`No interaction found for id ${customId.join('?')} with type ${type} and scope ${scope}`);
+            return consola.error(`No interaction found:\n${JSON.stringify({customId, type, scope, command_arguments: command_arguments.join(',')}, null, 2)}`);
 
-        return await interaction_command.interaction_command_function.apply(null, [interaction, ...customId.slice(1)]);
+        return await interaction_command.interaction_command_function.apply(null, [interaction, ...command_arguments]);
     }
 }

package/src/Interactions/RestCommands.js

@@ -1,6 +1,11 @@
 import GlobalConfig from "../Configs/GlobalConfig/GlobalConfig.js";
 import LocalConfig  from "../Configs/LocalConfig.js";
 import { REST, Routes } from "discord.js";
+import { InteractionScope } from "../Utils/enums.js";
+
+/**
+ * @typedef {import("discord.js").SlashCommandSubcommandsOnlyBuilder} SlashCommandSubcommandsOnlyBuilder
+ */
 
 export default class RestCommands {
     #commands = new Map();
@@ -20,6 +25,12 @@ export default class RestCommands {
         this.#local_config = local_config;
     }
 
+    /**
+     * 
+     * @param {SlashCommandSubcommandsOnlyBuilder[]} commands 
+     * @param {InteractionScope} scope 
+     * @returns {RestCommands}
+     */
     add(commands, scope) {
         if(!!scope)
             this.#commands.set(scope, commands);
@@ -29,6 +40,10 @@ export default class RestCommands {
         return this;
     }
 
+    /**
+     * @param {string} secret_token 
+     * @returns {Promise<REST>}
+     */
     async register(secret_token){
         const rest = new REST(this.#local_config.restOptions).setToken(secret_token);