commandkit 0.0.1 → 0.0.2

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Change Log
+
+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.2] - 2023-07-01
+
+## [0.0.1] - N/A

package/README.md

@@ -1 +1,76 @@
-# Command Kit
+# CommandKit
+
+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`_
+
+# Features
+
+- Very beginner friendly 🚀
+- Support for slash and context menu commands ✅
+- Automatic command registrations and deletion 🤖
+- Supports multiple development servers 🤝
+- Supports multiple users as bot developers 👥
+- Object oriented 💻
+
+# Documentation
+
+_Coming soon_
+~~You can find the full documentation [here](https://commandkit.underctrl.io)~~
+
+# Installation
+
+[![npm](https://nodei.co/npm/commandkit.png)](https://nodei.co/npm/commandkit/)
+
+To install CommandKit, simply run the following command:
+
+For npm:
+
+```bash
+npm install commandkit
+```
+
+For yarn:
+
+```bash
+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 to fully understand how to work with this library.**~~
+
+```js
+// index.js
+const { Client, IntentsBitField } = require('discord.js');
+const { CommandKit } = require('commandkit');
+const path = require('path');
+
+const client = new Client({
+  intents: [IntentsBitField.Flags.Guilds],
+});
+
+new CommandKit({
+  // 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 validations folder (only valid if "commandsPath" was provided)
+  validationsPath: path.join(__dirname, 'validations'),
+
+  // Array of development server IDs (used to register and run devOnly commands)
+  devGuildIds: ['DEV_SERVER_ID_1', 'DEV_SERVER_ID_2'],
+
+  // Array of developer user IDs (used for devOnly commands)
+  devUserIds: ['DEV_USER_ID_1', 'DEV_USER_ID_2'],
+});
+
+client.login('YOUR_TOKEN_HERE');
+```

package/dist/CommandKit.d.ts

@@ -0,0 +1,36 @@
+import { CommandKitOptions } from '../typings';
+export declare class CommandKit {
+    private _data;
+    constructor({ ...options }: CommandKitOptions);
+    private _init;
+    get commands(): ({
+        data: import("@discordjs/builders").SlashCommandBuilder | {
+            name: string;
+            name_localizations?: any;
+            description: string;
+            dm_permission?: boolean | undefined;
+            options: import("discord.js").APIApplicationCommandOption[];
+        };
+        options?: {
+            guildOnly?: boolean | undefined;
+            devOnly?: boolean | undefined;
+            deleted?: boolean | undefined;
+            userPermissions?: import("discord.js").PermissionResolvable[] | undefined;
+            botPermissions?: import("discord.js").PermissionResolvable[] | undefined;
+        } | undefined;
+    } | {
+        data: import("@discordjs/builders").ContextMenuCommandBuilder | {
+            name: string;
+            name_localizations?: any;
+            type: import("@discordjs/builders").ContextMenuCommandType;
+            dm_permission?: boolean | undefined;
+        };
+        options?: {
+            guildOnly?: boolean | undefined;
+            devOnly?: boolean | undefined;
+            deleted?: boolean | undefined;
+            userPermissions?: import("discord.js").PermissionResolvable[] | undefined;
+            botPermissions?: import("discord.js").PermissionResolvable[] | undefined;
+        } | undefined;
+    })[];
+}

package/dist/CommandKit.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandKit = void 0;
+const handlers_1 = require("./handlers");
+class CommandKit {
+    _data;
+    constructor({ ...options }) {
+        if (!options.client) {
+            throw new Error('"client" is required when instantiating CommandKit.');
+        }
+        if (options.validationsPath && !options.commandsPath) {
+            throw new Error('"commandsPath" is required when "validationsPath" is set.');
+        }
+        this._data = {
+            ...options,
+            commands: [],
+        };
+        this._init();
+    }
+    _init() {
+        // Event handler
+        if (this._data.eventsPath) {
+            new handlers_1.EventHandler({
+                client: this._data.client,
+                eventsPath: this._data.eventsPath,
+            });
+        }
+        // Validation handler
+        let validationFunctions = [];
+        if (this._data.validationsPath) {
+            const validationHandler = new handlers_1.ValidationHandler({
+                validationsPath: this._data.validationsPath,
+            });
+            validationFunctions = validationHandler.getValidations();
+        }
+        // Command handler
+        if (this._data.commandsPath) {
+            const commandHandler = new handlers_1.CommandHandler({
+                client: this._data.client,
+                commandsPath: this._data.commandsPath,
+                devGuildIds: this._data.devGuildIds || [],
+                devUserIds: this._data.devUserIds || [],
+                validations: validationFunctions,
+            });
+            this._data.commands = commandHandler.getCommands();
+        }
+    }
+    get commands() {
+        return this._data.commands.map((cmd) => {
+            const { run, ...command } = cmd;
+            return command;
+        });
+    }
+}
+exports.CommandKit = CommandKit;

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

@@ -0,0 +1,11 @@
+import { CommandHandlerData, CommandHandlerOptions } from './typings';
+import { ContextCommandObject, SlashCommandObject } from '../../../typings';
+export declare class CommandHandler {
+    _data: CommandHandlerData;
+    constructor({ ...options }: CommandHandlerOptions);
+    _init(): void;
+    _buildCommands(): void;
+    _registerCommands(): void;
+    _handleCommands(): void;
+    getCommands(): (SlashCommandObject | ContextCommandObject)[];
+}

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

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandHandler = void 0;
+const discord_js_1 = require("discord.js");
+const get_paths_1 = require("../../utils/get-paths");
+class CommandHandler {
+    _data;
+    constructor({ ...options }) {
+        this._data = {
+            ...options,
+            commands: [],
+        };
+        this._init();
+    }
+    _init() {
+        this._buildCommands();
+        this._registerCommands();
+        this._handleCommands();
+    }
+    _buildCommands() {
+        const commandFilePaths = (0, get_paths_1.getFilePaths)(this._data.commandsPath, true).filter((path) => path.endsWith('.js') || path.endsWith('.ts'));
+        for (const commandFilePath of commandFilePaths) {
+            const commandObj = require(commandFilePath);
+            if (!commandObj.data) {
+                console.log(`⏩ Ignoring: Command ${commandFilePath} does not export "data".`);
+                continue;
+            }
+            if (!commandObj.run) {
+                console.log(`⏩ Ignoring: Command ${commandFilePath} does not export "run".`);
+                continue;
+            }
+            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) {
+                const commandData = command.data;
+                if (commandData instanceof discord_js_1.SlashCommandBuilder ||
+                    commandData instanceof discord_js_1.ContextMenuCommandBuilder) {
+                    try {
+                        commandData.toJSON();
+                    }
+                    catch (error) { }
+                }
+                // <!-- Delete command if options.deleted -->
+                if (command.options?.deleted) {
+                    const targetCommand = appCommands?.cache.find((cmd) => cmd.name === command.data.name);
+                    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);
+                        targetCommand?.delete().then(() => {
+                            console.log(`🗑️ Deleted command "${command.data.name}" in ${guildCommands.guild.name}.`);
+                        });
+                    }
+                    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);
+                    });
+                }
+            }
+        });
+    }
+    _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 commandObj = {
+                data: targetCommand.data,
+                options: targetCommand.options,
+            };
+            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 });
+            }
+        });
+    }
+    getCommands() {
+        return this._data.commands;
+    }
+}
+exports.CommandHandler = CommandHandler;

package/dist/handlers/event-handler/EventHandler.d.ts

@@ -0,0 +1,11 @@
+import { EventHandlerOptions, EventHandlerData } from './typings';
+export declare class EventHandler {
+    _data: EventHandlerData;
+    constructor({ ...options }: EventHandlerOptions);
+    _buildEvents(): void;
+    _registerEvents(): void;
+    getEvents(): {
+        name: string;
+        functions: Function[];
+    }[];
+}

package/dist/handlers/event-handler/EventHandler.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHandler = void 0;
+const get_paths_1 = require("../../utils/get-paths");
+class EventHandler {
+    _data;
+    constructor({ ...options }) {
+        this._data = {
+            ...options,
+            events: [],
+        };
+        this._buildEvents();
+        this._registerEvents();
+    }
+    _buildEvents() {
+        const eventFolderPaths = (0, get_paths_1.getFolderPaths)(this._data.eventsPath);
+        for (const eventFolderPath of eventFolderPaths) {
+            const eventFolderPathChunks = eventFolderPath.replace('\\', '/').split('/');
+            const eventName = eventFolderPathChunks[eventFolderPathChunks.length - 1];
+            const eventFilePaths = (0, get_paths_1.getFilePaths)(eventFolderPath).filter((path) => path.endsWith('.js') || path.endsWith('.ts'));
+            const eventObj = {
+                name: eventName,
+                functions: [],
+            };
+            this._data.events.push(eventObj);
+            for (const eventFilePath of eventFilePaths) {
+                const eventFunction = require(eventFilePath);
+                if (typeof eventFunction !== 'function') {
+                    console.log(`Ignoring: Event ${eventFilePath} does not export a function.`);
+                    continue;
+                }
+                eventObj.functions.push(eventFunction);
+            }
+        }
+    }
+    _registerEvents() {
+        const client = this._data.client;
+        for (const eventObj of this._data.events) {
+            client.on(eventObj.name, async (...params) => {
+                for (const eventFunction of eventObj.functions) {
+                    const stopEventLoop = await eventFunction(...params, client);
+                    if (stopEventLoop) {
+                        break;
+                    }
+                }
+            });
+        }
+    }
+    getEvents() {
+        return this._data.events;
+    }
+}
+exports.EventHandler = EventHandler;

package/dist/handlers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './command-handler/CommandHandler';
+export * from './event-handler/EventHandler';
+export * from './validation-handler/ValidationHandler';

package/dist/handlers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./command-handler/CommandHandler"), exports);
+__exportStar(require("./event-handler/EventHandler"), exports);
+__exportStar(require("./validation-handler/ValidationHandler"), exports);

package/dist/handlers/validation-handler/ValidationHandler.d.ts

@@ -0,0 +1,7 @@
+import { ValidationHandlerData, ValidationHandlerOptions } from './typings';
+export declare class ValidationHandler {
+    _data: ValidationHandlerData;
+    constructor({ ...options }: ValidationHandlerOptions);
+    _buildValidations(): void;
+    getValidations(): Function[];
+}

package/dist/handlers/validation-handler/ValidationHandler.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationHandler = void 0;
+const get_paths_1 = require("../../utils/get-paths");
+class ValidationHandler {
+    _data;
+    constructor({ ...options }) {
+        this._data = {
+            ...options,
+            validations: [],
+        };
+        this._buildValidations();
+    }
+    _buildValidations() {
+        const validationFilePaths = (0, get_paths_1.getFilePaths)(this._data.validationsPath, true).filter((path) => path.endsWith('.js') || path.endsWith('.ts'));
+        for (const validationFilePath of validationFilePaths) {
+            const validationFunction = require(validationFilePath);
+            if (typeof validationFunction !== 'function') {
+                console.log(`Ignoring: Validation ${validationFilePath} does not export a function.`);
+                continue;
+            }
+            this._data.validations.push(validationFunction);
+        }
+    }
+    getValidations() {
+        return this._data.validations;
+    }
+}
+exports.ValidationHandler = ValidationHandler;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './CommandKit';

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./CommandKit"), exports);

package/dist/utils/get-paths.d.ts

@@ -0,0 +1,3 @@
+declare function getFilePaths(directory: string, nesting?: boolean): string[];
+declare function getFolderPaths(directory: string, nesting?: boolean): string[];
+export { getFilePaths, getFolderPaths };

package/dist/utils/get-paths.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFolderPaths = exports.getFilePaths = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+function getFilePaths(directory, nesting) {
+    let filePaths = [];
+    if (!directory)
+        return filePaths;
+    const files = fs_1.default.readdirSync(directory, { withFileTypes: true });
+    for (const file of files) {
+        const filePath = path_1.default.join(directory, file.name);
+        if (file.isFile()) {
+            filePaths.push(filePath);
+        }
+        if (nesting && file.isDirectory()) {
+            filePaths = [...filePaths, ...getFilePaths(filePath, true)];
+        }
+    }
+    return filePaths;
+}
+exports.getFilePaths = getFilePaths;
+function getFolderPaths(directory, nesting) {
+    let folderPaths = [];
+    if (!directory)
+        return folderPaths;
+    const folders = fs_1.default.readdirSync(directory, { withFileTypes: true });
+    for (const folder of folders) {
+        const folderPath = path_1.default.join(directory, folder.name);
+        if (folder.isDirectory()) {
+            folderPaths.push(folderPath);
+            if (nesting) {
+                folderPaths = [...folderPaths, ...getFolderPaths(folderPath, true)];
+            }
+        }
+    }
+    return folderPaths;
+}
+exports.getFolderPaths = getFolderPaths;

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "commandkit",
-  "version": "0.0.1",
-  "description": "",
-  "main": "index.js",
-  "keywords": [],
-  "author": "",
-  "license": "ISC"
+  "version": "0.0.2",
+  "main": "dist/index.js",
+  "license": "MIT",
+  "devDependencies": {
+    "discord.js": "^14.11.0",
+    "tsc": "^2.0.4"
+  },
+  "dependencies": {}
 }

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "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

@@ -0,0 +1,61 @@
+import {
+  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[];
+}
+
+export interface CommandKitData extends CommandKitOptions {
+  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;
+}
+
+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;
+}