@somehiddenkey/discord-command-utils 2.5.1 → 2.7.0

package/README.md

@@ -144,8 +144,32 @@ 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:
+All interactions get stored in a so-called `InteractionContainer` that still needs to be called. If someone goes wrong in an unexpected way, the interaction will be replied to with "something went wrong" and a consola error will be displayed. Optionally, you can provide an extra error handler as second argument to the interaction caller.
 ```js
 const interactionContainer = new InteractionContainer(localConfig, globalConfig);
 
@@ -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.1",
+  "version": "2.7.0",
   "description": "A utility library for building Discord bot commands using discord.js",
   "author": {
     "email": "k3y.throwaway@gmail.com",

package/src/Configs/Fetchable.js

@@ -2,8 +2,8 @@
  * @typedef {string} Snowflake
  */
 
-import consola from 'consola';
 import { Client } from 'discord.js';
+import { consolaConfig } from '../Utils/consola.js';
 
 export default class Fetchable {
     /** @type {string[]} */
@@ -30,7 +30,7 @@ export default class Fetchable {
                     if (prop === "refreshFromBot") {
                         return async () => {
                             cachedObject = await fetcher(id);
-                            consola.debug(`Fetched config object with ID ${id}`);
+                            consolaConfig.debug(`Fetched config object with ID ${id}`);
                             return cachedObject;
                         };
                     }
@@ -41,7 +41,7 @@ export default class Fetchable {
                                 cachedObject = await fetcher(id);
                                 if (!cachedObject) 
                                     throw new Error(`Cannot fetch config object for ID "${id}"`);
-                                consola.debug(`Fetched config object with ID ${id}`);
+                                consolaConfig.debug(`Fetched config object with ID ${id}`);
                             }
                             return cachedObject;
                         };

package/src/Configs/GlobalConfig/GlobalConfig.js

@@ -23,7 +23,7 @@ import GuildStaff from './GlobalConfigStaff.js';
 import { GuildBased } from '../NestedGlobalConfig.js';
 import { Client } from 'discord.js';
 import ConfigError from '../ConfigError.js';
-import consola from 'consola';
+import { consolaConfig } from '../../Utils/consola.js';
 
 export default class GlobalConfig {
     /** @type {GuildMain} */
@@ -47,7 +47,7 @@ export default class GlobalConfig {
             const raw = fs.readFileSync(path, { encoding: 'utf8', flag: 'r' });
             json = JSON.parse(raw);
             const g = new GlobalConfig(json.guilds, bot);
-            consola.start(`Loaded GlobalConfig from path: ${path}`);
+            consolaConfig.start(`Loaded GlobalConfig from path: ${path}`);
             return g;
         } catch (error) {
             throw new ConfigError(`Failed to load GlobalConfig from path: ${path}`, error);
@@ -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/Configs/LocalConfig.js

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import ConfigError from "./ConfigError.js";
-import consola from 'consola';
+import { consolaConfig } from '../Utils/consola.js';
 
 /**
  * @typedef {string} Snowflake
@@ -10,26 +10,29 @@ export default class LocalConfig {
     /** @type {string?} */
     prefix;
     /** @type {Snowflake} */
-    clientId;
+    #client_id;
 
     /** @type {object} */
     local;
     /** @type {object} */
-    restOptions;
+    #rest_options;
     /** @type {object} */
     activity;
 
     constructor(data) {
         this.prefix = data.prefix;
-        this.clientId = data.client_id;
+        this.#client_id = data.client_id;
         this.local = data.local || {};
-        this.restOptions = data.rest_options || {};
+        this.#rest_options = data.rest_options || {};
         this.activity = data.activity || {};
 
-        if(!this.clientId)
+        if(!this.#client_id)
             throw new ConfigError('No client_id initialized for LocalConfig');
     }
 
+    get clientId() { return this.#client_id; }
+    get restOptions() { return this.#rest_options; }
+
     /**
      * Loads the JSON file and returns a GlobalConfig instance.
      * @param {string} path
@@ -40,9 +43,48 @@ export default class LocalConfig {
         try {
             const raw = fs.readFileSync(path, { encoding: 'utf8', flag: 'r' });
             json = JSON.parse(raw);
-            return new LocalConfig(json);
+            const localConfig =new LocalConfig(json);
+            localConfig.#reloadable(path, "localConfig");
+            consolaConfig.start(`Loaded LocalConfig from path: ${path}`);
+            return localConfig;
         } catch (error) {
             throw new ConfigError(`Failed to load LocalConfig from path: ${path}`, error);
         }
     }
+
+    #reloadable(filepath, root=""){
+        fs.watch(filepath, { encoding: 'utf8' }, (eventType, _) => {
+            if (eventType !== 'change') return;
+            fs.readFile(filepath, 'utf8', (err, data) => {
+                if (err)
+                    return consolaConfig.error(err);
+                else
+                    LocalConfig.#compareObjects(JSON.parse(data), this, root+".");
+            })
+        });
+    }
+
+    static #compareObjects(data, currentObject, tree="") {
+        Object.entries(data).forEach(([key, newValue]) => {
+            const oldValue = currentObject[key]
+            const newValueIsObject = typeof newValue === 'object' && !Array.isArray(newValue) && newValue !== null
+            const oldValueIsObject = typeof oldValue === 'object' && !Array.isArray(oldValue) && oldValue !== null
+            
+            if(newValueIsObject && oldValueIsObject)
+                LocalConfig.#compareObjects(newValue, oldValue, tree+"."+key);
+            else {
+                if(Array.isArray(newValue) || Array.isArray(oldValue)) {
+                    const newValueString = JSON.stringify(newValue);
+                    const oldValueString = JSON.stringify(oldValue);
+                    if(newValueString != oldValueString) {
+                        currentObject[key] = newValue
+                        consolaConfig.warn(`Updated ${tree}${key}\n - Old: ${oldValueString}\n - New: ${newValueString}`);
+                    }
+                } else if (newValue !== oldValue){
+                    currentObject[key] = newValue
+                    consolaConfig.warn(`Updated ${tree}${key}\n - Old: ${JSON.stringify(oldValue)}\n - New: ${JSON.stringify(newValue)}`);
+                }
+            }
+        });
+    }
 }

package/src/Configs/SecretConfig.js

@@ -1,21 +1,10 @@
-import consola from "consola";
 import ConfigError from "./ConfigError.js";
+import { consolaConfig } from "../Utils/consola.js";
 
 /**
  * @typedef {{client: string, connection: {host: string, user: string, password: string, database: string}}} DatabaseConfig
  */
 
-const levels = {
-  silent: -1,
-  fatal: 0,
-  error: 1,
-  warn: 2,
-  info: 3,
-  debug: 4,
-  trace: 5,
-};
-consola.level = levels[process.env.LOG_LEVEL?.toLowerCase() || "info"] ?? 3;
-
 export default class SecretConfig {
     /** @type {string} */
     token;
@@ -52,11 +41,11 @@ export default class SecretConfig {
 
                 databaseConfigs.push(db_config);
             } catch (error) {
-                consola.error(`Failed to load database config for section: ${section}`, error);
+                consolaConfig.error(`Failed to load database config for section: ${section}`, error);
                 throw error;
             }
         }
         this.databaseConfig = databaseConfigs;
-        consola.start(`Loaded SecretConfig for environment: ${this.environment}`);
+        consolaConfig.start(`Loaded SecretConfig for environment: ${this.environment}`);
     }
 }

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

@@ -2,25 +2,23 @@ import Interaction from "./Interaction.js";
 import { InteractionScope, InteractionType } from "../Utils/enums.js";
 import GlobalConfig from "../Configs/GlobalConfig/GlobalConfig.js";
 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';
+import { consolaInteraction } from "../Utils/consola.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);
+        consolaInteraction.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);
+        consolaInteraction.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,8 @@ 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)
+        
+        const [customId, ...command_arguments] = (interaction.commandName || interaction.customId)?.split("?")
 
         var type;
         if (interaction.isChatInputCommand())
@@ -123,7 +134,7 @@ export default class InteractionContainer {
             return;
         
         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)
@@ -131,25 +142,30 @@ export default class InteractionContainer {
                     return interaction
                         .editReply("something went wrong")
                         .catch(() => interaction.reply("something went wrong"))
-                        .then(() => on_error(error))
-                        .then();
+                        .then(
+                            () => {consolaInteraction.error(e); return on_error(error)}, 
+                            () => {consolaInteraction.error(e); return on_error(error)}
+                        )
+                        .then()
+                        .catch(consolaInteraction.error);
             });
     }
 
     /**
      * 
+     * @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 consolaInteraction.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);
         

package/src/Utils/consola.js

@@ -0,0 +1,25 @@
+import { createConsola } from "consola";
+
+const levels = {
+  silent: -1,
+  fatal: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4,
+  trace: 5,
+};
+const level = levels[process.env.LOG_LEVEL?.toLowerCase() || "info"] ?? 3;
+
+const consolaInstance = createConsola({
+    level,
+    fancy: true,
+    formatOptions: {
+        date: true,
+        columns: 20
+    }
+});
+
+export const consolaConfig = consolaInstance.withTag("Config");
+export const consolaInteraction = consolaInstance.withTag("Interaction");
+export default consolaInstance;