commandkit 0.0.8 → 0.0.9

package/.github/workflows/publish.yaml

@@ -0,0 +1,26 @@
+name: 'publish'
+
+on:
+    push:
+        branches: [master]
+
+jobs:
+    release:
+        name: 🚀 publish
+        runs-on: ubuntu-latest
+        steps:
+            - name: 📚 checkout
+              uses: actions/checkout@v3
+            - name: 🟢 node
+              uses: actions/setup-node@v2
+              with:
+                  node-version: 16
+                  registry-url: https://registry.npmjs.org
+            - name: 🍳 prepare
+              run: |
+                  npm install
+                  npm run build
+            - name: 🚚 publish
+              run: npm publish
+              env:
+                  NODE_AUTH_TOKEN: ${{secrets.NPM_AUTH_TOKEN}}

package/CHANGELOG.md

@@ -4,35 +4,46 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 
+## [0.0.9] - 2023-08-09
+
+### Added
+
+-   Support for developer role IDs
+-   Ability to skip built-in validations by setting `skipBuiltInValidations` to true inside the `CommandKit` constructor
+
+### Changed
+
+-   Change validations to run custom user validations first, then CommandKit's built-in validations.
+
 ## [0.0.8] - 2023-07-03
 
 ### Added
 
-- Support for nested files inside of each event folder.
+-   Support for nested files inside of each event folder.
 
 ## [0.0.7] - 2023-07-02
 
 ### Changed
 
-- Give validation functions access to the full command object (commandObj) excluding the run function (as that is handled by the command handler), as opposed to just the `data` and `options` properties.
+-   Give validation functions access to the full command object (commandObj) excluding the run function (as that is handled by the command handler), as opposed to just the `data` and `options` properties.
 
 ## [0.0.6] - 2023-07-02
 
 ### Fixed
 
-- Fixed a bug where wrong event names were being registered on Windows.
+-   Fixed a bug where wrong event names were being registered on Windows.
 
 ## [0.0.5] - 2023-07-02
 
 ### Added
 
-- Ability to automatically update application commands (guilds and global) when there's changes to the description or number of options (slash commands only).
+-   Ability to automatically update application commands (guilds and global) when there's changes to the description or number of options (slash commands only).
 
 ## [0.0.4] - 2023-07-01
 
 ### Updated
 
-- Update package.json with new URLs, scripts, and version
+-   Update package.json with new URLs, scripts, and version
 
 ## [0.0.3] - 2023-07-01
 

package/README.md

@@ -1,17 +1,17 @@
 # CommandKit
 
-CommandKit is a library that makes it easy to handle commands (+validations), and events in your Discord.js projects.
+CommandKit is a library that makes it easy to handle commands (+ validations), and events in your Discord.js projects.
 
-_Tested with Discord.js version `v14.11.0`_
+**Supports Discord.js version 14**
 
 # Features
 
-- Very beginner friendly 🚀
-- Support for slash and context menu commands ✅
-- Automatic command registration, edits, and deletion 🤖
-- Supports multiple development servers 🤝
-- Supports multiple users as bot developers 👥
-- Object oriented 💻
+-   Very beginner friendly 🚀
+-   Support for slash and context menu commands ✅
+-   Automatic command registration, edits, and deletion 🤖
+-   Supports multiple development servers 🤝
+-   Supports multiple users as bot developers 👥
+-   Object oriented 💻
 
 # Documentation
 
@@ -37,38 +37,46 @@ yarn add commandkit
 
 # Usage
 
-This is a simple overview of how to set up this library with all the options.
-
-**It's highly recommended you check out the [documentation](https://commandkit.underctrl.io) to fully understand how to work with this library.**
+This is a simple overview of how to set up this library with all the options. You can read more in the [full documentation](https://commandkit.underctrl.io)
 
 ```js
 // index.js
-const { Client, IntentsBitField } = require('discord.js');
+const { Client, GatewayIntentBits } = require('discord.js');
 const { CommandKit } = require('commandkit');
 const path = require('path');
 
 const client = new Client({
-  intents: [IntentsBitField.Flags.Guilds],
+    intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+    ],
 });
 
 new CommandKit({
-  // Your discord.js client object
-  client,
+    // Your discord.js client object
+    client,
+
+    // Path to the commands folder
+    commandsPath: path.join(__dirname, 'commands'),
+
+    // Path to the events folder
+    eventsPath: path.join(__dirname, 'events'),
 
-  // Path to the commands folder
-  commandsPath: path.join(__dirname, 'commands'),
+    // Path to the validations folder (only valid if "commandsPath" was provided)
+    validationsPath: path.join(__dirname, 'validations'),
 
-  // Path to the events folder
-  eventsPath: path.join(__dirname, 'events'),
+    // Array of development server IDs (used to register and run devOnly commands)
+    devGuildIds: ['DEV_SERVER_ID_1', 'DEV_SERVER_ID_2'],
 
-  // Path to the validations folder (only valid if "commandsPath" was provided)
-  validationsPath: path.join(__dirname, 'validations'),
+    // Array of developer user IDs (used for devOnly commands)
+    devUserIds: ['DEV_USER_ID_1', 'DEV_USER_ID_2'],
 
-  // Array of development server IDs (used to register and run devOnly commands)
-  devGuildIds: ['DEV_SERVER_ID_1', 'DEV_SERVER_ID_2'],
+    // Array of developer role IDs (used for devOnly commands)
+    devRoleIds: ['DEV_ROLE_ID_1', 'DEV_ROLE_ID_2'],
 
-  // Array of developer user IDs (used for devOnly commands)
-  devUserIds: ['DEV_USER_ID_1', 'DEV_USER_ID_2'],
+    // A property that disables CommandKit's built-in validations
+    skipBuiltInValidations: true,
 });
 
 client.login('YOUR_TOKEN_HERE');

package/dist/CommandKit.js

@@ -31,7 +31,7 @@ class CommandKit {
             const validationHandler = new handlers_1.ValidationHandler({
                 validationsPath: this._data.validationsPath,
             });
-            validationFunctions = validationHandler.getValidations();
+            validationHandler.getValidations().forEach((v) => validationFunctions.push(v));
         }
         // Command handler
         if (this._data.commandsPath) {
@@ -40,7 +40,9 @@ class CommandKit {
                 commandsPath: this._data.commandsPath,
                 devGuildIds: this._data.devGuildIds || [],
                 devUserIds: this._data.devUserIds || [],
-                validations: validationFunctions,
+                devRoleIds: this._data.devRoleIds || [],
+                customValidations: validationFunctions,
+                skipBuiltInValidations: this._data.skipBuiltInValidations || false,
             });
             this._data.commands = commandHandler.getCommands();
         }

package/dist/handlers/command-handler/CommandHandler.d.ts

@@ -5,8 +5,8 @@ export declare class CommandHandler {
     constructor({ ...options }: CommandHandlerOptions);
     _init(): void;
     _buildCommands(): void;
+    _buildValidations(): void;
     _registerCommands(): void;
     _handleCommands(): void;
-    _areSlashCommandsDifferent(appCommand: any, localCommand: any): true | undefined;
     getCommands(): (SlashCommandObject | ContextCommandObject)[];
 }

package/dist/handlers/command-handler/CommandHandler.js

@@ -1,18 +1,26 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandHandler = void 0;
 const get_paths_1 = require("../../utils/get-paths");
+const registerCommands_1 = __importDefault(require("./functions/registerCommands"));
+const handleCommands_1 = __importDefault(require("./functions/handleCommands"));
+const path_1 = __importDefault(require("path"));
 class CommandHandler {
     _data;
     constructor({ ...options }) {
         this._data = {
             ...options,
+            builtInValidations: [],
             commands: [],
         };
         this._init();
     }
     _init() {
         this._buildCommands();
+        this._buildValidations();
         this._registerCommands();
         this._handleCommands();
     }
@@ -31,225 +39,21 @@ class CommandHandler {
             this._data.commands.push(commandObj);
         }
     }
-    _registerCommands() {
-        const client = this._data.client;
-        const commands = this._data.commands;
-        client.once('ready', async () => {
-            const devGuilds = [];
-            for (const devGuildId of this._data.devGuildIds) {
-                const guild = client.guilds.cache.get(devGuildId);
-                if (!guild) {
-                    console.log(`⏩ Ignoring: Guild ${devGuildId} does not exist or client isn't in this guild.`);
-                    continue;
-                }
-                devGuilds.push(guild);
-            }
-            const appCommands = client.application?.commands;
-            await appCommands?.fetch();
-            const devGuildCommands = [];
-            for (const guild of devGuilds) {
-                const guildCommands = guild.commands;
-                await guildCommands?.fetch();
-                devGuildCommands.push(guildCommands);
-            }
-            for (const command of commands) {
-                // <!-- Delete command if options.deleted -->
-                if (command.options?.deleted) {
-                    const targetCommand = appCommands?.cache.find((cmd) => cmd.name === command.data.name);
-                    if (!targetCommand) {
-                        console.log(`⏩ Ignoring: Command "${command.data.name}" is globally marked as deleted.`);
-                    }
-                    else {
-                        targetCommand.delete().then(() => {
-                            console.log(`🚮 Deleted command "${command.data.name}" globally.`);
-                        });
-                    }
-                    for (const guildCommands of devGuildCommands) {
-                        const targetCommand = guildCommands.cache.find((cmd) => cmd.name === command.data.name);
-                        if (!targetCommand) {
-                            console.log(`⏩ Ignoring: Command "${command.data.name}" is marked as deleted for ${guildCommands.guild.name}.`);
-                        }
-                        else {
-                            targetCommand.delete().then(() => {
-                                console.log(`🚮 Deleted command "${command.data.name}" in ${guildCommands.guild.name}.`);
-                            });
-                        }
-                    }
-                    continue;
-                }
-                // <!-- Edit command if there's any changes -->
-                let commandData = command.data;
-                let editedCommand = false;
-                (() => {
-                    // global
-                    const appGlobalCommand = appCommands?.cache.find((cmd) => cmd.name === command.data.name);
-                    if (appGlobalCommand) {
-                        const commandsAreDifferent = this._areSlashCommandsDifferent(appGlobalCommand, commandData);
-                        if (commandsAreDifferent) {
-                            appGlobalCommand
-                                .edit(commandData)
-                                .then(() => {
-                                console.log(`✅ Edited command "${commandData.name}" globally.`);
-                            })
-                                .catch((error) => {
-                                console.log(`❌ Failed to edit command "${commandData.name}" globally.`);
-                                console.error(error);
-                            });
-                            editedCommand = true;
-                        }
-                    }
-                    // guilds
-                    for (const guildCommands of devGuildCommands) {
-                        const appGuildCommand = guildCommands.cache.find((cmd) => cmd.name === commandData.name);
-                        if (appGuildCommand) {
-                            const commandsAreDifferent = this._areSlashCommandsDifferent(appGuildCommand, commandData);
-                            if (commandsAreDifferent) {
-                                appGuildCommand
-                                    .edit(commandData)
-                                    .then(() => {
-                                    console.log(`✅ Edited command "${commandData.name}" in ${guildCommands.guild.name}.`);
-                                })
-                                    .catch((error) => {
-                                    console.log(`❌ Failed to edit command "${commandData.name}" in ${guildCommands.guild.name}.`);
-                                    console.error(error);
-                                });
-                                editedCommand = true;
-                            }
-                        }
-                    }
-                })();
-                if (editedCommand)
-                    continue;
-                // <!-- Registration -->
-                // guild-based command registration
-                if (command.options?.devOnly) {
-                    if (!devGuilds.length) {
-                        console.log(`⏩ Ignoring: Cannot register command "${command.data.name}" as no valid "devGuildIds" were provided.`);
-                        continue;
-                    }
-                    for (const guild of devGuilds) {
-                        const cmdExists = guild.commands.cache.some((cmd) => cmd.name === command.data.name);
-                        if (cmdExists)
-                            continue;
-                        guild?.commands
-                            .create(command.data)
-                            .then(() => {
-                            console.log(`✅ Registered command "${command.data.name}" in ${guild.name}.`);
-                        })
-                            .catch((error) => {
-                            console.log(`❌ Failed to register command "${command.data.name}" in ${guild.name}.`);
-                            console.error(error);
-                        });
-                    }
-                }
-                // global command registration
-                else {
-                    const cmdExists = appCommands?.cache.some((cmd) => cmd.name === command.data.name);
-                    if (cmdExists)
-                        continue;
-                    appCommands
-                        ?.create(command.data)
-                        .then(() => {
-                        console.log(`✅ Registered command "${command.data.name}" globally.`);
-                    })
-                        .catch((error) => {
-                        console.log(`❌ Failed to register command "${command.data.name}" globally.`);
-                        console.error(error);
-                    });
-                }
+    _buildValidations() {
+        const validationFilePaths = (0, get_paths_1.getFilePaths)(path_1.default.join(__dirname, 'validations'), true).filter((path) => path.endsWith('.js'));
+        for (const validationFilePath of validationFilePaths) {
+            const validationFunction = require(validationFilePath);
+            if (typeof validationFunction !== 'function') {
+                continue;
             }
-        });
+            this._data.builtInValidations.push(validationFunction);
+        }
     }
-    _handleCommands() {
-        const client = this._data.client;
-        client.on('interactionCreate', async (interaction) => {
-            if (!interaction.isChatInputCommand() && !interaction.isContextMenuCommand())
-                return;
-            const targetCommand = this._data.commands.find((cmd) => cmd.data.name === interaction.commandName);
-            if (!targetCommand)
-                return;
-            // Options validation
-            // options.guildOnly
-            if (targetCommand.options?.guildOnly && !interaction.inGuild()) {
-                interaction.reply({
-                    content: '❌ This command can only be used inside a server.',
-                    ephemeral: true,
-                });
-                return;
-            }
-            // options.devOnly
-            if (targetCommand.options?.devOnly) {
-                const isDevUser = this._data.devUserIds.includes(interaction.user.id);
-                if (!isDevUser) {
-                    interaction.reply({
-                        content: '❌ This command can only be used by developers.',
-                        ephemeral: true,
-                    });
-                    return;
-                }
-            }
-            // options.userPermissions
-            const memberPermissions = interaction.memberPermissions;
-            if (targetCommand.options?.userPermissions && memberPermissions) {
-                for (const permission of targetCommand.options.userPermissions) {
-                    const hasPermission = memberPermissions.has(permission);
-                    if (!hasPermission) {
-                        interaction.reply({
-                            content: `❌ You do not have enough permission to run this command. Required permission: \`${permission}\``,
-                            ephemeral: true,
-                        });
-                        return;
-                    }
-                }
-            }
-            // options.botPermissions
-            const botMember = interaction.guild?.members.me;
-            if (targetCommand.options?.botPermissions && botMember) {
-                for (const permission of targetCommand.options.botPermissions) {
-                    const hasPermission = botMember.permissions.has(permission);
-                    if (!hasPermission) {
-                        interaction.reply({
-                            content: `❌ I do not have enough permission to execute this command. Required permission: \`${permission}\``,
-                            ephemeral: true,
-                        });
-                        return;
-                    }
-                }
-            }
-            // Run user validation functions
-            const validationFunctions = this._data.validations;
-            const { data, options, run, ...rest } = targetCommand;
-            const commandObj = {
-                data: targetCommand.data,
-                options: targetCommand.options,
-                ...rest,
-            };
-            let canRun = true;
-            for (const validationFunction of validationFunctions) {
-                const stopValidationLoop = await validationFunction({ interaction, client, commandObj });
-                if (stopValidationLoop) {
-                    canRun = false;
-                    break;
-                }
-            }
-            if (canRun) {
-                targetCommand.run({ interaction, client });
-            }
-        });
+    _registerCommands() {
+        (0, registerCommands_1.default)(this);
     }
-    _areSlashCommandsDifferent(appCommand, localCommand) {
-        if (!appCommand.options)
-            appCommand.options = [];
-        if (!localCommand.options)
-            localCommand.options = [];
-        if (!appCommand.description)
-            appCommand.description = '';
-        if (!localCommand.description)
-            localCommand.description = '';
-        if (localCommand.description !== appCommand.description ||
-            localCommand.options.length !== appCommand.options.length) {
-            return true;
-        }
+    _handleCommands() {
+        (0, handleCommands_1.default)(this);
     }
     getCommands() {
         return this._data.commands;

package/dist/handlers/command-handler/functions/handleCommands.d.ts

@@ -0,0 +1,2 @@
+import { CommandHandler } from '../CommandHandler';
+export default function handleCommands(commandHandler: CommandHandler): void;

package/dist/handlers/command-handler/functions/handleCommands.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function handleCommands(commandHandler) {
+    const client = commandHandler._data.client;
+    client.on('interactionCreate', async (interaction) => {
+        if (!interaction.isChatInputCommand() && !interaction.isContextMenuCommand())
+            return;
+        const targetCommand = commandHandler._data.commands.find((cmd) => cmd.data.name === interaction.commandName);
+        if (!targetCommand)
+            return;
+        const { data, options, run, ...rest } = targetCommand;
+        const commandObj = {
+            data: targetCommand.data,
+            options: targetCommand.options,
+            ...rest,
+        };
+        let canRun = true;
+        for (const validationFunction of commandHandler._data.customValidations) {
+            const stopValidationLoop = await validationFunction({
+                interaction,
+                client,
+                commandObj,
+            });
+            if (stopValidationLoop) {
+                canRun = false;
+                break;
+            }
+        }
+        if (!canRun)
+            return;
+        // If custom validations pass and !skipBuiltInValidations, run built-in CommandKit validation functions
+        if (!commandHandler._data.skipBuiltInValidations) {
+            for (const validation of commandHandler._data.builtInValidations) {
+                const stopValidationLoop = validation({
+                    targetCommand,
+                    interaction,
+                    handlerData: commandHandler._data,
+                });
+                if (stopValidationLoop) {
+                    canRun = false;
+                    break;
+                }
+            }
+        }
+        if (!canRun)
+            return;
+        targetCommand.run({ interaction, client });
+    });
+}
+exports.default = handleCommands;

package/dist/handlers/command-handler/functions/registerCommands.d.ts

@@ -0,0 +1,2 @@
+import { CommandHandler } from '../CommandHandler';
+export default function registerCommands(commandHandler: CommandHandler): void;

package/dist/handlers/command-handler/functions/registerCommands.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const areSlashCommandsDifferent_1 = __importDefault(require("../utils/areSlashCommandsDifferent"));
+function registerCommands(commandHandler) {
+    const client = commandHandler._data.client;
+    const devGuildIds = commandHandler._data.devGuildIds;
+    const commands = commandHandler._data.commands;
+    client.once('ready', async () => {
+        const devGuilds = [];
+        for (const devGuildId of devGuildIds) {
+            const guild = client.guilds.cache.get(devGuildId);
+            if (!guild) {
+                console.log(`⏩ Ignoring: Guild ${devGuildId} does not exist or client isn't in this guild.`);
+                continue;
+            }
+            devGuilds.push(guild);
+        }
+        const appCommands = client.application?.commands;
+        await appCommands?.fetch();
+        const devGuildCommands = [];
+        for (const guild of devGuilds) {
+            const guildCommands = guild.commands;
+            await guildCommands?.fetch();
+            devGuildCommands.push(guildCommands);
+        }
+        for (const command of commands) {
+            // <!-- Delete command if options.deleted -->
+            if (command.options?.deleted) {
+                const targetCommand = appCommands?.cache.find((cmd) => cmd.name === command.data.name);
+                if (!targetCommand) {
+                    console.log(`⏩ Ignoring: Command "${command.data.name}" is globally marked as deleted.`);
+                }
+                else {
+                    targetCommand.delete().then(() => {
+                        console.log(`🚮 Deleted command "${command.data.name}" globally.`);
+                    });
+                }
+                for (const guildCommands of devGuildCommands) {
+                    const targetCommand = guildCommands.cache.find((cmd) => cmd.name === command.data.name);
+                    if (!targetCommand) {
+                        console.log(`⏩ Ignoring: Command "${command.data.name}" is marked as deleted for ${guildCommands.guild.name}.`);
+                    }
+                    else {
+                        targetCommand.delete().then(() => {
+                            console.log(`🚮 Deleted command "${command.data.name}" in ${guildCommands.guild.name}.`);
+                        });
+                    }
+                }
+                continue;
+            }
+            // <!-- Edit command -->
+            let commandData = command.data;
+            let editedCommand = false;
+            // Edit command globally
+            const appGlobalCommand = appCommands?.cache.find((cmd) => cmd.name === command.data.name);
+            if (appGlobalCommand) {
+                const commandsAreDifferent = (0, areSlashCommandsDifferent_1.default)(appGlobalCommand, commandData);
+                if (commandsAreDifferent) {
+                    appGlobalCommand
+                        .edit(commandData)
+                        .then(() => {
+                        console.log(`✅ Edited command "${commandData.name}" globally.`);
+                    })
+                        .catch((error) => {
+                        console.log(`❌ Failed to edit command "${commandData.name}" globally.`);
+                        console.error(error);
+                    });
+                    editedCommand = true;
+                }
+            }
+            // Edit command in a specific guild
+            for (const guildCommands of devGuildCommands) {
+                const appGuildCommand = guildCommands.cache.find((cmd) => cmd.name === commandData.name);
+                if (appGuildCommand) {
+                    const commandsAreDifferent = (0, areSlashCommandsDifferent_1.default)(appGuildCommand, commandData);
+                    if (commandsAreDifferent) {
+                        appGuildCommand
+                            .edit(commandData)
+                            .then(() => {
+                            console.log(`✅ Edited command "${commandData.name}" in ${guildCommands.guild.name}.`);
+                        })
+                            .catch((error) => {
+                            console.log(`❌ Failed to edit command "${commandData.name}" in ${guildCommands.guild.name}.`);
+                            console.error(error);
+                        });
+                        editedCommand = true;
+                    }
+                }
+            }
+            if (editedCommand)
+                continue;
+            // <!-- Register command -->
+            // Register command in a specific guild
+            if (command.options?.devOnly) {
+                if (!devGuilds.length) {
+                    console.log(`⏩ Ignoring: Cannot register command "${command.data.name}" as no valid "devGuildIds" were provided.`);
+                    continue;
+                }
+                for (const guild of devGuilds) {
+                    const cmdExists = guild.commands.cache.some((cmd) => cmd.name === command.data.name);
+                    if (cmdExists)
+                        continue;
+                    guild?.commands
+                        .create(command.data)
+                        .then(() => {
+                        console.log(`✅ Registered command "${command.data.name}" in ${guild.name}.`);
+                    })
+                        .catch((error) => {
+                        console.log(`❌ Failed to register command "${command.data.name}" in ${guild.name}.`);
+                        console.error(error);
+                    });
+                }
+            }
+            // Register command globally
+            else {
+                const cmdExists = appCommands?.cache.some((cmd) => cmd.name === command.data.name);
+                if (cmdExists)
+                    continue;
+                appCommands
+                    ?.create(command.data)
+                    .then(() => {
+                    console.log(`✅ Registered command "${command.data.name}" globally.`);
+                })
+                    .catch((error) => {
+                    console.log(`❌ Failed to register command "${command.data.name}" globally.`);
+                    console.error(error);
+                });
+            }
+        }
+    });
+}
+exports.default = registerCommands;

package/dist/handlers/command-handler/utils/areSlashCommandsDifferent.d.ts

@@ -0,0 +1 @@
+export default function areSlashCommandsDifferent(appCommand: any, localCommand: any): true | undefined;

package/dist/handlers/command-handler/utils/areSlashCommandsDifferent.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function areSlashCommandsDifferent(appCommand, localCommand) {
+    if (!appCommand.options)
+        appCommand.options = [];
+    if (!localCommand.options)
+        localCommand.options = [];
+    if (!appCommand.description)
+        appCommand.description = '';
+    if (!localCommand.description)
+        localCommand.description = '';
+    if (localCommand.description !== appCommand.description ||
+        localCommand.options.length !== appCommand.options.length) {
+        return true;
+    }
+}
+exports.default = areSlashCommandsDifferent;

package/dist/handlers/command-handler/validations/botPermissions.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/handlers/command-handler/validations/botPermissions.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+module.exports = ({ interaction, targetCommand }) => {
+    const botMember = interaction.guild?.members.me;
+    if (targetCommand.options?.botPermissions && botMember) {
+        for (const permission of targetCommand.options.botPermissions) {
+            const hasPermission = botMember.permissions.has(permission);
+            if (!hasPermission) {
+                interaction.reply({
+                    content: `❌ I do not have enough permission to execute this command. Required permission: \`${permission}\``,
+                    ephemeral: true,
+                });
+                return true;
+            }
+        }
+    }
+};

package/dist/handlers/command-handler/validations/devOnly.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/handlers/command-handler/validations/devOnly.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+module.exports = ({ interaction, targetCommand, handlerData }) => {
+    if (targetCommand.options?.devOnly) {
+        if (interaction.inGuild() && !handlerData.devGuildIds.includes(interaction.guildId)) {
+            interaction.reply({
+                content: '❌ This command can only be used inside development servers.',
+                ephemeral: true,
+            });
+            return true;
+        }
+        const guildMember = interaction.guild?.members.cache.get(interaction.user.id);
+        const memberRoles = guildMember?.roles.cache;
+        let hasDevRole = false;
+        memberRoles?.forEach((role) => {
+            if (handlerData.devRoleIds?.includes(role.id)) {
+                hasDevRole = true;
+            }
+        });
+        const isDevUser = handlerData.devUserIds.includes(interaction.user.id) || hasDevRole;
+        if (!isDevUser) {
+            interaction.reply({
+                content: '❌ This command can only be used by developers.',
+                ephemeral: true,
+            });
+            return true;
+        }
+    }
+};

package/dist/handlers/command-handler/validations/guildOnly.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/handlers/command-handler/validations/guildOnly.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+module.exports = ({ interaction, targetCommand }) => {
+    if (targetCommand.options?.guildOnly && !interaction.inGuild()) {
+        interaction.reply({
+            content: '❌ This command can only be used inside a server.',
+            ephemeral: true,
+        });
+        return true;
+    }
+};

package/dist/handlers/command-handler/validations/userPermissions.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/handlers/command-handler/validations/userPermissions.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+module.exports = ({ interaction, targetCommand }) => {
+    const memberPermissions = interaction.memberPermissions;
+    if (targetCommand.options?.userPermissions && memberPermissions) {
+        for (const permission of targetCommand.options.userPermissions) {
+            const hasPermission = memberPermissions.has(permission);
+            if (!hasPermission) {
+                interaction.reply({
+                    content: `❌ You do not have enough permission to run this command. Required permission: \`${permission}\``,
+                    ephemeral: true,
+                });
+                return true;
+            }
+        }
+    }
+};

package/package.json

@@ -1,25 +1,24 @@
 {
-  "name": "commandkit",
-  "version": "0.0.8",
-  "main": "dist/index.js",
-  "license": "MIT",
-  "scripts": {
-    "build": "tsc"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/notunderctrl/commandkit"
-  },
-  "homepage": "https://commandkit.underctrl.io",
-  "keywords": [
-    "discord.js",
-    "command handler",
-    "event handler",
-    "command validations"
-  ],
-  "dependencies": {},
-  "devDependencies": {
-    "discord.js": "^14.11.0",
-    "tsc": "^2.0.4"
-  }
+    "name": "commandkit",
+    "version": "0.0.9",
+    "main": "dist/index.js",
+    "license": "MIT",
+    "scripts": {
+        "build": "tsc"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/notunderctrl/commandkit"
+    },
+    "homepage": "https://commandkit.underctrl.io",
+    "keywords": [
+        "discord.js",
+        "command handler",
+        "event handler",
+        "command validations"
+    ],
+    "devDependencies": {
+        "discord.js": "^14.12.1",
+        "typescript": "^5.1.6"
+    }
 }

package/tsconfig.json

@@ -1,14 +1,14 @@
 {
-  "compilerOptions": {
-    "outDir": "dist",
-    "strict": true,
-    "noImplicitAny": true,
-    "esModuleInterop": true,
-    "strictNullChecks": true,
-    "target": "ES2022",
-    "moduleResolution": "Node",
-    "module": "CommonJS",
-    "declaration": true
-  },
-  "include": ["src/**/*"]
+    "compilerOptions": {
+        "outDir": "dist",
+        "strict": true,
+        "noImplicitAny": true,
+        "esModuleInterop": true,
+        "strictNullChecks": true,
+        "target": "ES2022",
+        "moduleResolution": "Node",
+        "module": "CommonJS",
+        "declaration": true
+    },
+    "include": ["src/**/*"]
 }

package/typings.d.ts

@@ -1,61 +1,63 @@
 import {
-  Client,
-  APIApplicationCommandOption,
-  ContextMenuCommandType,
-  Interaction,
-  PermissionResolvable,
-  SlashCommandBuilder,
-  ContextMenuCommandBuilder,
+    Client,
+    APIApplicationCommandOption,
+    ContextMenuCommandType,
+    Interaction,
+    PermissionResolvable,
+    SlashCommandBuilder,
+    ContextMenuCommandBuilder,
 } from 'discord.js';
 
 export interface CommandKitOptions {
-  client: Client;
-  commandsPath?: string;
-  eventsPath?: string;
-  validationsPath?: string;
-  devGuildIds?: string[];
-  devUserIds?: string[];
+    client: Client;
+    commandsPath?: string;
+    eventsPath?: string;
+    validationsPath?: string;
+    devGuildIds?: string[];
+    devUserIds?: string[];
+    devRoleIds?: string[];
+    skipBuiltInValidations?: boolean;
 }
 
 export interface CommandKitData extends CommandKitOptions {
-  commands: Array<SlashCommandObject | ContextCommandObject>;
+    commands: Array<SlashCommandObject | ContextCommandObject>;
 }
 
 export interface SlashCommandObject {
-  data:
-    | SlashCommandBuilder
-    | {
-        name: string;
-        name_localizations?: any;
-        description: string;
-        dm_permission?: boolean;
-        options?: APIApplicationCommandOption[];
-      };
-  options?: {
-    guildOnly?: boolean;
-    devOnly?: boolean;
-    deleted?: boolean;
-    userPermissions?: PermissionResolvable[];
-    botPermissions?: PermissionResolvable[];
-  };
-  run: ({}: { interaction: Interaction; client: Client }) => void;
+    data:
+        | SlashCommandBuilder
+        | {
+              name: string;
+              name_localizations?: any;
+              description: string;
+              dm_permission?: boolean;
+              options?: APIApplicationCommandOption[];
+          };
+    options?: {
+        guildOnly?: boolean;
+        devOnly?: boolean;
+        deleted?: boolean;
+        userPermissions?: PermissionResolvable[];
+        botPermissions?: PermissionResolvable[];
+    };
+    run: ({}: { interaction: Interaction; client: Client }) => void;
 }
 
 export interface ContextCommandObject {
-  data:
-    | ContextMenuCommandBuilder
-    | {
-        name: string;
-        name_localizations?: any;
-        type: ContextMenuCommandType;
-        dm_permission?: boolean;
-      };
-  options?: {
-    guildOnly?: boolean;
-    devOnly?: boolean;
-    deleted?: boolean;
-    userPermissions?: PermissionResolvable[];
-    botPermissions?: PermissionResolvable[];
-  };
-  run: ({}: { interaction: Interaction; client: Client }) => void;
+    data:
+        | ContextMenuCommandBuilder
+        | {
+              name: string;
+              name_localizations?: any;
+              type: ContextMenuCommandType;
+              dm_permission?: boolean;
+          };
+    options?: {
+        guildOnly?: boolean;
+        devOnly?: boolean;
+        deleted?: boolean;
+        userPermissions?: PermissionResolvable[];
+        botPermissions?: PermissionResolvable[];
+    };
+    run: ({}: { interaction: Interaction; client: Client }) => void;
 }