@somehiddenkey/discord-command-utils 1.0.1

package/README.md

@@ -0,0 +1,157 @@
+# DiscordUtilsLibrary
+The purpose of this Library is to hide and abstract many of the common aspects that comes with coding discord bots in javascript. The main focus is configurations as well as registering all types of commands and interactions between different guilds.
+## Installation
+### SSH Installation
+Use this if your GitHub account already has SSH access -> requires SSH key set up
+```bash
+npm install git+ssh://git@github.com/studytogether-discord/DiscordUtilsLibrary.git
+```
+
+### HTTPS Installation
+If you want to use HTTPS instead, you must use a GitHub Personal Access Token (classic) with repo permissions (replace "TOKEN" with your PAT)
+```bash
+npm install "https://TOKEN@github.com/studytogether-discord/DiscordUtilsLibrary.git"
+```
+
+### Libary Import
+Then import it in your code
+```c#
+import { Something } from "DiscordUtilsLibrary";
+// or
+const { Something } = require("DiscordUtilsLibrary");
+```
+
+## Configurations
+We will use 3 different kinds of configurations:
+- local : settings specific to this specific bot like it's prefix etc
+- global : information used by all bot instances
+- secret : environment variables that contain all the secrets of your bot instance
+### Local configuration
+Loads the local configuration of that specific bot. It only contains public configs, no secrets, and may thus be included in the git tracing. Load a new instance of your local config through the following code:
+```js
+export const localConfig = LocalConfig.load("./configs/local_config.json", Environments.DEV);
+```
+
+Your local configuration JSON file should look like this:
+```json
+{
+	"production": {
+		"prefix": "!",
+		"client_id": "123456789123456789",
+		"local": {
+            "any_local_configuration": "any values"
+		},
+		"rest_options" : {
+			"version": "10",
+			"rejectOnRateLimit": ["/channels"]
+		}
+	},
+	"development": {
+		"prefix": "!",
+    	"client_id": "123456789123456789",
+		"local": {
+			"any_local_configuration": "any values"
+		},
+    	"rest_options" : {
+			"version": "10",
+			"rejectOnRateLimit": ["/channels"]
+		}
+	},
+	"activity": {
+		"name": "the communities",
+		"type": 0
+	}
+}
+```
+- `client_id` : ID of your bot user
+- `rest_options` : Must be of type [Partial<RESTOptions>](https://discord.js.org/docs/packages/rest/2.6.0/RESTOptions:Interface)
+- `activity` : Must be of type [ActivitiesOptions](https://discord.js.org/docs/packages/discord.js/14.25.1/ActivitiesOptions:Interface)
+
+### Global configuration
+Loads the global configuration that contains information related to all bot instances, like snowflake IDs of channels, categories, guild, etc. Load a new instance of your global config through the following code:
+```js
+export const globalConfig = GlobalConfig.load("../global_config.json", Environments.DEV);
+```
+It contains the IDs of the following sections: guilds, categories, channels, log channels and roles. These can be used as constant values throughout your code, making sure that if an ID ever changes, that all bot instances would take the new updated value by simply updating the json once.
+
+### Secrets configuration
+Loads the environment variables that contain all secrets for that bot, like your bot token and database credentials. It goes without saying that these actual values may never be git traced. Load new instance of your secret config through the following code: 
+```js
+import { config } from 'dotenv';
+
+config();
+export const secretConfig = new SecretConfig(process.env);
+```
+Your .env file should look like this:
+```bash
+NODE_ENV="production"
+
+TOKEN="someDiscordBotToken"
+
+DATABASE__0__HOST="localhost"
+DATABASE__0__USER="userName"
+DATABASE__0__NAME="databaseName"
+DATABASE__0__PASSWORD="passwordValue"
+```
+Please take the following into account:
+- `NODE_ENV` must be of one of the following values:
+  - `"development"` : Uses your development configurations for local testing
+  - `"production"` : Uses your production configurations for PRD env. Do not use for local tests, it won't work
+- If you use multiple databases, prefix each one with another index, starting at `0`
+
+You can retrieve the various database configurations with the following code: 
+```js
+export const db_connection_0 = knex(secretConfig.DatabaseConfig[0]);
+```
+You can initiate the bot with the following code:
+```js
+bot.login(secretConfig.Token);
+```
+## Interactions
+### Register Interaction
+You can register new interaction callbacks based on a set of factors:
+- the scope : type `InteractionScope` -- in which server is this interaction called (main, tutor, communities, dm, etc)
+- the type : type `InteractionType` -- is it a button, a modal, a slash command, a message, etc
+- the unique id: custom unique ID per interaction of this type
+
+An example for a slash command called in the main server:
+```js
+Interaction.OnSlashCommand(
+    "ping", 
+    InteractionScope.Main, 
+    async (interaction) => await interaction.reply("pong")
+);
+```
+The same exists for:
+- Button : `OnButton`
+- Selection menu : `OnSelectMenu`
+- Message : `OnMessageCommand`
+- Modal submission : `OnModal`
+### Call Interaction
+All interactions get stored in a so-called `InteractionContainer` that still needs to be called:
+```js
+const interactionContainer = new InteractionContainer(localConfig, globalConfig);
+
+bot.on(Events.MessageCreate, async (message) => {
+  await interactionContainer.call_message_interaction(message, e => consola.error(e))
+});
+
+bot.on(Events.InteractionCreate, async (interaction) => 
+  await interactionContainer.call_interaction(message, e => consola.error(e))
+);
+```
+### Register slash commands to REST
+For slash commands to work, you need to register them to a bot. There are two kinds:
+- Guild commands : a slash command that will only be registered in one specific guild
+- Public commands : a slash command available in all guilds that have this bot
+
+You can add a set of slash commands through the following abstraction:
+```js
+const rest = interactionContainer.Rest
+	.add([firstSlashCommand, secondSlashCommand], localConfig.guilds.tutor)
+	.add([firstSlashCommand, secondSlashCommand], localConfig.guilds.community)
+	.add([somePublicSlashCommand])
+	.register(secretConfig.token);
+```
+## Utils
+Contains various check functions to verify the access level of a user as well as useful enums for scoping, community modlevels, etc

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@somehiddenkey/discord-command-utils",
+  "version": "1.0.1",
+  "description": "A utility library for building Discord bot commands using discord.js",
+  "author": {
+    "email": "k3y.throwaway@gmail.com",
+    "name": "Key"
+  },
+  "license": "ISC",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "private": false,
+  "keywords": [],
+  "dependencies": {
+    "consola": "^3.4.2",
+    "discord.js": "^14.25.1"
+  }
+}

package/src/Configs/ConfigError.js

@@ -0,0 +1,8 @@
+class ConfigError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+}
+
+export default ConfigError;

package/src/Configs/GlobalConfig.js

@@ -0,0 +1,265 @@
+/**
+ * @typedef {string} Snowflake
+ */
+
+import fs from 'fs';
+import ConfigError from "./ConfigError";
+import consola from 'consola';
+import { InteractionScope } from "../Utils/enums";
+
+export default class GlobalConfig {
+    /** @type {Guilds} */
+    guilds;
+
+    /** @type {Categories} */
+    categories;
+
+    /** @type {Channels} */
+    channels;
+
+    /** @type {Logs} */
+    logs;
+
+    /** @type {Roles} */
+    roles;
+
+    constructor(data) {
+        if (!data) 
+            throw new ConfigError('No data initialized for GlobalConfig');
+
+        this.guilds = new Guilds(data.guilds);
+        this.categories = new Categories(data.categories);
+        this.channels = new Channels(data.channels);
+        this.logs = new Logs(data.logs);
+        this.roles = new Roles(data.roles);
+    }
+
+    /**
+     * Loads the JSON file and returns a GlobalConfig instance.
+     * @param {string} path
+     * @param {string} environment
+     * @returns {GlobalConfig}
+     */
+    static async load(path, environment) {
+        var json
+        try {
+            const raw = fs.readFileSync(path, { encoding: 'utf8', flag: 'r' });
+            json = JSON.parse(raw);
+        } catch (error) {
+            consola.error(`Failed to load GlobalConfig from path: ${path}`, error);
+            throw error;
+        }
+        if (environment == "production") 
+            return new GlobalConfig(json.production);
+        else 
+            return new GlobalConfig(json.development);
+    }
+}
+
+
+/* -----------------------
+ * Nested Classes
+ * ----------------------- */
+
+class Guilds {
+    /** @type {Snowflake} */
+    main;
+    /** @type {Snowflake} */
+    community;
+    /** @type {Snowflake} */
+    tutor;
+    /** @type {Snowflake} */
+    staff;
+
+    constructor(data) {
+        Object.assign(this, data);
+    }
+
+    /**
+     * @param {Snowflake} guild_id 
+     * @returns {InteractionScope} scope
+     */
+    get_scope(guild_id) {
+        switch(guild_id) {
+            case this.main:
+                return InteractionScope.Main;
+            case this.community:
+                return InteractionScope.Community;
+            case this.tutor:
+                return InteractionScope.Tutor;
+            case this.staff:
+                return InteractionScope.Staff;
+            default:
+                return InteractionScope.OtherGuild;
+        }
+    }
+
+    /**
+     * @param {InteractionScope} scope
+     * @returns {Snowflake} guild_id 
+     */
+    get_guild_id(scope) {
+        switch(scope) {
+            case InteractionScope.Main:
+                return this.main;
+            case InteractionScope.Community:
+                return this.community;
+            case InteractionScope.Tutor:
+                return this.tutor;
+            case InteractionScope.Staff:
+                return this.staff;
+            default:
+                return null;
+        }
+    }
+}
+
+class Categories {
+    /** @type {Snowflake} */
+    chat;
+    /** @type {[Snowflake]} */
+    custom_rooms;       
+    /** @type {[Snowflake]} */
+    verified_com;
+    /** @type {Snowflake} */
+    chill;
+    /** @type {Snowflake} */    
+    events;
+    /** @type {Snowflake} */
+    music;
+    /** @type {Snowflake} */
+    timer_25;
+    /** @type {Snowflake} */
+    timer_50;
+    /** @type {Snowflake} */
+    screen_cam;
+    /** @type {Snowflake} */
+    staff;
+    /** @type {Snowflake} */
+    subjects;
+    /** @type {Snowflake} */
+    subjects_col;
+    /** @type {Snowflake} */
+    subjects_uni;
+    /** @type {Snowflake} */
+    to_do;
+
+    /** @type {[Snowflake]} */
+    custom_study_rooms;
+    /** @type {[Snowflake]} */
+    study_rooms;
+
+    constructor(data) {
+        Object.assign(this, data);
+        this.custom_study_rooms = data.custom_rooms.concat(data.verified_com);
+        this.study_rooms = this.custom_study_rooms.concat([data.music, data.timer_25, data.timer_50, data.screen_cam]);
+    }
+}
+
+class Channels {
+    /** @type {Snowflake} */
+    timer_control;
+    /** @type {Snowflake} */
+    accountability;
+    /** @type {Snowflake} */
+    break_afk;
+    /** @type {Snowflake} */
+    create_room;
+    /** @type {Snowflake} */
+    commands;
+    /** @type {Snowflake} */
+    general;
+    /** @type {Snowflake} */
+    international;
+    /** @type {Snowflake} */
+    introductions;
+    /** @type {Snowflake} */
+    mod_commands;
+    /** @type {Snowflake} */
+    support_commands;
+    /** @type {Snowflake} */
+    session_goals;
+    /** @type {Snowflake} */
+    silent_study;
+    /** @type {Snowflake} */
+    welcome;
+    
+    constructor(data) {
+        Object.assign(this, data);
+    }
+}
+
+class Logs {
+    /** @type {Snowflake} */
+    error;
+    /** @type {Snowflake} */
+    votekick;
+    /** @type {Snowflake} */
+    room_commands;
+    /** @type {Snowflake} */
+    room_admin;
+    /** @type {Snowflake} */
+    invites;
+    /** @type {Snowflake} */
+    command;    
+    /** @type {Snowflake} */
+    communities;
+    
+    constructor(data) {
+        Object.assign(this, data);
+    }
+}
+
+class Roles {
+    /** @type {Snowflake} */
+    cuckoo_ping;
+    /** @type {Snowflake} */
+    developer
+    /** @type {Snowflake} */
+    forest_ping;
+    /** @type {Snowflake} */
+    helper;
+    /** @type {Snowflake} */
+    member;
+    /** @type {Snowflake} */
+    music;
+    /** @type {Snowflake} */
+    muted;
+    /** @type {Snowflake} */
+    no_pc;
+    /** @type {Snowflake} */
+    screen_cam;
+    /** @type {Snowflake} */
+    studying;
+    /** @type {Snowflake} */
+    timer_25;
+    /** @type {Snowflake} */
+    timer_50;
+    /** @type {Snowflake} */
+    tutor;
+    /** @type {Snowflake} */
+    verified_com;
+    /** @type {Snowflake} */
+    water_ping;
+    /** @type {Snowflake} */
+    deepfocus;
+    /** @type {Snowflake} */
+    sr_staff;
+    /** @type {Snowflake} */
+    staff;
+    /** @type {Snowflake} */
+    jr_staff;
+    /** @type {Snowflake} */
+    st_team;
+    /** @type {Snowflake} */
+    coordinator;
+
+    /** @type {[Snowflake]} */
+    all_staff;
+
+
+    constructor(data) {
+        Object.assign(this, data);
+        this.all_staff = [this.jr_staff, this.sr_staff, this.st_team, this.coordinator];
+    }
+}

package/src/Configs/LocalConfig.js

@@ -0,0 +1,52 @@
+/**
+ * @typedef {string} Snowflake
+ */
+
+import { RESTOptions } from '@discordjs/rest';
+import { ActivitiesOptions } from 'discord.js';
+
+export default class LocalConfig {
+    /** @type {string?} */
+    prefix;
+    /** @type {Snowflake} */
+    clientId;
+
+    /** @type {object} */
+    local;
+    /** @type {Partial<RESTOptions>} */
+    restOptions;
+    /** @type {ActivitiesOptions} */
+    activity;
+
+    constructor(data) {
+        this.prefix = data.prefix;
+        this.clientId = data.client_id;
+        this.local = data.local || {};
+        this.restOptions = data.rest_options || {};
+        this.activity = data.activity || {};
+
+        if(!this.client_id)
+            throw new ConfigError('No client_id initialized for LocalConfig');
+    }
+
+    /**
+     * Loads the JSON file and returns a GlobalConfig instance.
+     * @param {string} path
+     * @param {string} environment
+     * @returns {GlobalConfig}
+     */
+    static async load(path, environment) {
+        var json
+        try {
+            const raw = fs.readFileSync(path, { encoding: 'utf8', flag: 'r' });
+            json = JSON.parse(raw);
+        } catch (error) {
+            consola.error(`Failed to load GlobalConfig from path: ${path}`, error);
+            throw error;
+        }
+        if (environment == "production") 
+            return new GlobalConfig({...json.production || json.activity});
+        else 
+            return new GlobalConfig({...json.development || json.activity});
+    }
+}

package/src/Configs/SecretConfig.js

@@ -0,0 +1,51 @@
+import consola from "consola";
+import ConfigError from "./ConfigError";
+
+/**
+ * @typedef {{client: string, connection: {host: string, user: string, password: string, database: string}}} DatabaseConfig
+ */
+
+export default class SecretConfig {
+    /** @type {string} */
+    token;
+
+    /** @type {string} */
+    environment;
+    
+    /** @type {[DatabaseConfig]} */
+    databaseConfig;
+
+    constructor(env) {
+        if (!env) 
+            throw new ConfigError('env is required to initialize SecretConfig');
+        
+        this.environment = env.NODE_ENV;
+        if (!this.environment) 
+            throw new ConfigError('NODE_ENV is required to initialize SecretConfig');
+        if (!['production', 'development', 'testing'].includes(this.environment)) 
+            throw new ConfigError('Unrecognized NODE_ENV: '+this.environment);
+        this.token = env.TOKEN;
+
+        var databaseConfigs = [];
+        for (let index = 0, section = "DATABASE__"+index; !!env[section+"__NAME"]; index++) {
+            try {
+                let db_config = {
+                    client: 'mysql',
+                    connection: {
+                        host: env[section+"__HOST"],
+                        user: env[section+"__USER"],
+                        password: env[section+"__PASSWORD"],
+                        database: env[section+"__NAME"],
+                    }
+                }
+
+                databaseConfigs.push(db_config);
+                consola.start(`Loaded database config for section: ${section}`);
+            } catch (error) {
+                consola.error(`Failed to load database config for section: ${section}`, error);
+                throw error;
+            }
+        }
+        this.databaseConfig = databaseConfigs;
+    }
+}

package/src/Interactions/CommandError.js

@@ -0,0 +1,34 @@
+import { Interaction as DiscordBaseInteraction, MessageFlags } from "discord.js";
+
+export default class CommandError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DiscordCommandError";
+  }
+
+  /**
+   * @param {DiscordBaseInteraction} interaction 
+   * @returns {Promise<any>}
+   */
+  error_as_message(interaction){
+    return interaction.reply(this.message).then(msg => setTimeout(() => msg.delete(), 5000)).catch(() => {});
+  }
+
+  /**
+   * @param {DiscordBaseInteraction} interaction 
+   * @returns {Promise<any>}
+   */
+  error_as_command(interaction){
+    return interaction
+      .editReply({
+        content: this.message,
+        flags: MessageFlags.Ephemeral,
+      })
+      .catch(() => 
+        interaction.reply({
+        content: this.message,
+        flags: MessageFlags.Ephemeral,
+      }))
+      .catch(() => {});
+  }
+}

package/src/Interactions/Interaction.js

@@ -0,0 +1,96 @@
+import { 
+    Interaction as DiscordBaseInteraction,
+    OmitPartialGroupDMChannel,
+    Message,
+    ModalSubmitInteraction,
+    ButtonInteraction,
+    AnySelectMenuInteraction,
+    ChatInputCommandInteraction,
+    CacheType
+} from 'discord.js';
+import InteractionContainer from "./InteractionContainer";
+import { InteractionType, InteractionScope } from "../Utils/enums";
+
+/**
+ * @typedef { (interaction: DiscordBaseInteraction<CacheType>) => Promise<any> } InteractionFunction
+ * @typedef { (message: OmitPartialGroupDMChannel<Message<boolean>>) => Promise<any> } InteractionMsgFunction
+ * @typedef { string } InteractionID
+ */
+
+export default class Interaction {
+    /** @type {string} */
+    id;
+    /** @type {InteractionType} */
+    type;
+    /** @type {InteractionScope} */
+    scope;
+    /** @type {InteractionFunction} */
+    interaction_command_function;
+    
+    constructor(custom_id, type, scope, interaction_command_function) {
+        this.id = custom_id;
+        this.scope = scope;
+        this.type = type;
+        this.interaction_command_function = interaction_command_function;
+    }
+
+    /**
+     * Command wrapper
+     * @param {InteractionID} custom_id 
+     * @param {InteractionType} type
+     * @param {InteractionScope|[InteractionScope]} scope 
+     * @param {InteractionFunction} target
+     */
+    static On(custom_id, type, scope, target) {
+        if(Array.isArray(scope))
+            scope.forEach(s => InteractionContainer.add(new Interaction(custom_id, s, type, target)));
+        else;
+            InteractionContainer.add(new Interaction(custom_id, scope, type, target));
+        return custom_id;
+    }
+
+    /**
+     * @param {InteractionID} custom_id  
+     * @param {InteractionScope|[InteractionScope]} scope 
+     * @param {(interaction: ChatInputCommandInteraction) => Promise<any>} target
+     */
+    static OnSlashCommand(custom_id, scope, target) {
+        return Interaction.On(custom_id, InteractionType.Command, scope, target)
+    }
+
+    /**
+     * @param {InteractionID} custom_id  
+     * @param {InteractionScope|[InteractionScope]} scope 
+     * @param {(interaction: ButtonInteraction) => Promise<any>} target
+     */
+    static OnButton(custom_id, scope, target) {
+        return Interaction.On(custom_id, InteractionType.Button, scope, target)
+    }
+
+    /**
+     * @param {InteractionID} custom_id  
+     * @param {(interaction: AnySelectMenuInteraction) => Promise<any>} target
+     * @param {InteractionScope|[InteractionScope]} scope 
+     */
+    static OnSelectMenu(custom_id, scope, target) {
+        return Interaction.On(custom_id, InteractionType.SelectMenu, scope, target)
+    }
+
+    /**
+     * @param {InteractionID} custom_id  
+     * @param {InteractionMsgFunction} target
+     * @param {InteractionScope|[InteractionScope]} scope 
+     */
+    static OnMessageCommand(custom_id, scope, target) {
+        return Interaction.On(custom_id, InteractionType.Message, scope, target)
+    }
+
+    /**
+     * @param {InteractionID} custom_id  
+     * @param {(interaction: ModalSubmitInteraction) => Promise<any>} target
+     * @param {InteractionScope|[InteractionScope]} scope 
+     */
+    static OnModal(custom_id, scope, target) {
+        return Interaction.On(custom_id, InteractionType.Modal, scope, target)
+    }
+} 

package/src/Interactions/InteractionContainer.js

@@ -0,0 +1,151 @@
+import { 
+    Interaction as DiscordBaseInteraction,
+    OmitPartialGroupDMChannel,
+    Message,
+    CacheType
+} from 'discord.js';
+import Interaction from "./Interaction";
+import { InteractionScope, InteractionType } from "../Utils/enums";
+import GlobalConfig from "../Configs/GlobalConfig";
+import LocalConfig  from "../Configs/LocalConfig";
+import consola from "consola";
+import CommandError from "./CommandError";
+import RestCommands from './RestCommands';
+
+/**
+ * @typedef { (interaction: DiscordBaseInteraction<CacheType>) => Promise<any> } InteractionFunction
+ * @typedef { (message: OmitPartialGroupDMChannel<Message<boolean>>) => Promise<any> } InteractionMsgFunction
+ * @typedef { string } InteractionID
+ */
+
+export default class InteractionContainer {
+    /** @type {Map<InteractionID, Interaction>} */
+    static #interaction_container = new Map();
+
+    /** @type {GlobalConfig} */
+    #global_config; 
+    /** @type {LocalConfig} */
+    #local_config;
+
+    /** @type {RestCommands} */
+    Rest = new RestCommands(this.#global_config, this.#local_config);
+
+    /**
+     * @param {InteractionType} type 
+     * @param {InteractionScope} scope 
+     * @param {string} id 
+     * @returns {InteractionID}
+     */
+    static #make_key(type, scope, id) {
+        return `${type}__${scope}__${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);
+        InteractionContainer.#interaction_container.set(key, base_interaction);
+    }
+
+    /**
+     * @param {InteractionType} type 
+     * @param {InteractionScope} scope 
+     * @param {string} id 
+     * @returns {Interaction?}
+     */
+    static get(type, scope, id) {
+        return InteractionContainer.#interaction_container.get(InteractionContainer.#make_key(type, scope, id));
+    }
+
+    constructor(local_config, global_config) {
+        this.#local_config = local_config;
+        this.#global_config = global_config;
+    }
+
+    /**
+     * @param {DiscordBaseInteraction} interaction 
+     * @param { (error: Error) => Promise<any> } on_error
+     * @returns {Promise<any>}
+     */
+    call_message_interaction(interaction, on_error = async () => {}) {
+        if (interaction.author.bot) return;
+        
+        const scope = 
+            (interaction.channel.type === ChannelType.DM) ? 
+            InteractionScope.DM : this.#global_config.guilds.get_scope(interaction.guild.id); 
+
+        const customId = interaction.content.slice(this.#local_config.prefix?.length)
+
+        return InteractionContainer
+            .#call(InteractionType.Message, scope, customId, interaction)
+            .catch(error => {
+                if (error instanceof CommandError)
+                    return error.error_as_message()
+                else
+                    return interaction
+                        .reply("something went wrong")
+                        .then(msg => setTimeout(() => msg.delete(), 5000))
+                        .catch(() => {})
+                        .then(() => on_error(error));
+            });
+    }
+
+    /**
+     * @param {DiscordBaseInteraction} interaction 
+     * @param { (error: Error) => Promise<any> } on_error
+     * @returns {Promise<any>}
+     */
+    call_interaction(interaction, on_error = async () => {}) {
+        const scope = 
+            (interaction.channel.type === ChannelType.DM) ? 
+            InteractionScope.DM : this.#global_config.guilds.get_scope(interaction.guild.id);
+
+        const customId = (interaction.commandName || interaction.customId)?.split(/\?(.+)/, 2)
+
+        var type;
+        if (interaction.isChatInputCommand())
+            type = InteractionType.Command; 
+        else if (interaction.isButton())
+            type = InteractionType.Button; 
+        else if (interaction.isAnySelectMenu())
+            type = InteractionType.SelectMenu; 
+        else if (interaction.isModalSubmit())
+            type = InteractionType.Modal; 
+        else 
+            return;
+        
+        return InteractionContainer
+            .#call(type, scope, customId, interaction)
+            .catch(error => {
+                if (error instanceof CommandError)
+                    return error.error_as_command(interaction)
+                else 
+                    return interaction
+                        .editReply("something went wrong")
+                        .catch(() => interaction.reply("something went wrong"))
+                        .then(() => on_error(error))
+                        .then();
+            });
+    }
+
+    /**
+     * 
+     * @param {InteractionType} type 
+     * @param {InteractionScope} scope 
+     * @param {InteractionID} customId 
+     * @param {DiscordBaseInteraction} interaction 
+     * @returns {Promise<any>}
+     * @throws {CommandError}
+     */
+    static #call(type, scope, customId, interaction) {
+        const interaction_command = InteractionContainer.get(type, scope, customId?.[0]);
+        if(!interaction_command) 
+            return consola.error(`No interaction found for id ${customId}`);
+
+        return interaction_command.interaction_command_function.apply(null, [interaction, ...customId.slice(1)]);
+    }
+}

package/src/Interactions/RestCommands.js

@@ -0,0 +1,45 @@
+import { InteractionScope } from "../Utils/enums";
+import GlobalConfig from "../Configs/GlobalConfig";
+import LocalConfig  from "../Configs/LocalConfig";
+import { REST } from "discord.js";
+
+export default class RestCommands {
+    #commands = new Map();
+    #global_commands = [];
+    /** @type {GlobalConfig} */
+    #global_config;
+    /** @type {LocalConfig} */
+    #local_config;
+
+    constructor(global_config, local_config) {
+        this.#global_config = global_config;
+        this.#local_config = local_config;
+    }
+
+    add(commands, scope) {
+        if(!!scope)
+            this.#commands.set(scope, commands);
+        else
+            this.#global_commands = commands;
+
+        return this;
+    }
+
+    async register(secret_token){
+        const rest = new REST(this.#local_config.restOptions).setToken(secret_token);
+        
+        for(const [scope, commands] of this.#commands.entries()) {
+            await rest.put(Routes.applicationGuildCommands(this.#local_config.clientId, this.#global_config.guilds.get_guild_id(scope)), {
+                body: commands,
+            });
+        }
+
+        if(this.#global_commands.length > 0) {
+            await rest.put(Routes.applicationCommands(this.#local_config.clientId), {
+                body: this.#global_commands,
+            });
+        }
+
+        return rest;
+    }
+}

package/src/Utils/checks.js

@@ -0,0 +1,44 @@
+import { BaseInteraction } from "discord.js";
+import { Modlevel } from "./enums";
+
+
+/** 
+ * @param {BaseInteraction} interaction
+ * @returns {Boolean} 
+*/
+export function check_is_staff(interaction) {
+  return interaction.member.permissions.has(PermissionsBitField.Flags.ModerateMembers)
+}
+
+/** 
+ * @param {BaseInteraction} interaction
+ * @returns {Boolean} 
+*/
+export function check_can_ban(interaction) {
+  return interaction.member.permissions.has(PermissionsBitField.Flags.BanMembers)
+}
+
+/**
+ * @param {Modlevel} mod_level 
+ * @param {Modlevel} required_mod_level 
+ * @returns {Boolean}
+ */
+export function check_required_mod_level(mod_level, required_mod_level){
+  switch(required_mod_level){
+    case null: 
+      return true;
+    case undefined: 
+      return true;
+    case Modlevel.Member: 
+      if(mod_level == Modlevel.Member)
+        return true;
+    case Modlevel.Admin: 
+      if(mod_level == Modlevel.Admin)
+        return true; 
+    case Modlevel.Owner: 
+      if(mod_level == Modlevel.Owner)
+        return true; 
+    default: 
+      return false
+  }
+}

package/src/Utils/enums.js

@@ -0,0 +1,32 @@
+/** @enum { String } */
+export const Modlevel = {
+    Owner: "owner",
+    Admin: "admin",
+    Member: "member"
+};
+
+/** @enum { String } */
+export const InteractionScope = {
+    Main: "main",
+    Community: "comms",
+    Tutor: "tutor",
+    Staff: "staff",
+    OtherGuild: "guild",
+    DM: "dm"
+};
+
+/** @enum { String } */
+export const InteractionType = {
+    Command: "CIP",
+    Button: "BTN",
+    SelectMenu: "ASM",
+    Message: "MSG",
+    Modal: "MDL"
+};
+
+/** @enum { String } */
+export const Environments = {
+    DEV: "development",
+    TST: "testing",
+    PRD: "production"
+};

package/src/index.js

@@ -0,0 +1,10 @@
+export {default as LocalConfig} from "./Configs/LocalConfig.js";
+export {default as GlobalConfig} from "./Configs/GlobalConfig.js";
+export {default as SecretConfig} from "./Configs/SecretConfig.js";
+
+export {default as InteractionContainer} from "./Interactions/InteractionContainer.js";
+export {default as Interaction} from "./Interactions/Interaction.js";
+export {default as CommandError} from "./Interactions/CommandError.js";
+
+export * from "./Utils/checks.js";
+export * from "./Utils/enums.js";