add type defs + update built-in validations

Author: notunderctrl

packages/commandkit/src/CommandKit.ts

@@ -1,5 +1,6 @@
 import { CommandHandler, EventHandler, ValidationHandler } from './handlers';
-import { CommandKitData, CommandKitOptions, CommandFileObject } from './typings';
+import { CommandKitData, CommandKitOptions } from './typings';
+import { CommandFileObject } from './types';
 import colors from 'colors/safe';
 
 export class CommandKit {
@@ -25,30 +26,26 @@ export class CommandKit {
     }
 
     async #init() {
-        // Event handler
         if (this.#data.eventsPath) {
             const eventHandler = new EventHandler({
                 client: this.#data.client,
                 eventsPath: this.#data.eventsPath,
+                commandKitInstance: this,
             });
 
             await eventHandler.init();
         }
 
-        // Validation handler
         let validationFunctions: Function[] = [];
-
         if (this.#data.validationsPath) {
             const validationHandler = new ValidationHandler({
                 validationsPath: this.#data.validationsPath,
             });
 
             await validationHandler.init();
-
             validationHandler.validations.forEach((v) => validationFunctions.push(v));
         }
 
-        // Command handler
         if (this.#data.commandsPath) {
             const commandHandler = new CommandHandler({
                 client: this.#data.client,
@@ -58,14 +55,19 @@ export class CommandKit {
                 devRoleIds: this.#data.devRoleIds || [],
                 customValidations: validationFunctions,
                 skipBuiltInValidations: this.#data.skipBuiltInValidations || false,
+                commandKitInstance: this,
             });
 
             await commandHandler.init();
-
             this.#data.commands = commandHandler.commands;
         }
     }
 
+    /**
+     * Returns all the commands that CommandKit is handling.
+     *
+     * @returns An array of command objects
+     */
     get commands(): CommandFileObject[] {
         const commands = this.#data.commands.map((cmd) => {
             const { run, ...command } = cmd;

packages/commandkit/src/handlers/command-handler/functions/handleCommands.ts

@@ -2,6 +2,7 @@ import { CommandHandler } from '../CommandHandler';
 
 export default function handleCommands(commandHandler: CommandHandler) {
     const client = commandHandler._data.client;
+    const handler = commandHandler._data.commandKitInstance;
 
     client.on('interactionCreate', async (interaction) => {
         if (!interaction.isChatInputCommand() && !interaction.isContextMenuCommand()) return;
@@ -27,6 +28,7 @@ export default function handleCommands(commandHandler: CommandHandler) {
                 interaction,
                 client,
                 commandObj,
+                handler,
             });
 
             if (stopValidationLoop) {
@@ -55,6 +57,6 @@ export default function handleCommands(commandHandler: CommandHandler) {
 
         if (!canRun) return;
 
-        targetCommand.run({ interaction, client });
+        targetCommand.run({ interaction, client, handler });
     });
 }

packages/commandkit/src/handlers/command-handler/typings.d.ts

@@ -1,5 +1,6 @@
 import { ChatInputCommandInteraction, Client, ContextMenuCommandInteraction } from 'discord.js';
 import { ContextCommandObject, SlashCommandObject } from '../../typings';
+import { CommandKit } from '../../CommandKit';
 
 export interface CommandHandlerOptions {
     client: Client;
@@ -9,6 +10,7 @@ export interface CommandHandlerOptions {
     devRoleIds: string[];
     customValidations: Function[];
     skipBuiltInValidations: boolean;
+    commandKitInstance: CommandKit;
 }
 
 export interface CommandHandlerData extends CommandHandlerOptions {

packages/commandkit/src/handlers/command-handler/validations/botPermissions.ts

@@ -2,27 +2,32 @@ import { BuiltInValidationParams } from '../typings';
 
 export default function ({ interaction, targetCommand }: BuiltInValidationParams) {
     const botMember = interaction.guild?.members.me;
+    let commandPermissions = targetCommand.options?.botPermissions;
 
-    if (targetCommand.options?.botPermissions && botMember) {
-        const missingPermissions: string[] = [];
+    if (!botMember || !commandPermissions) return;
 
-        for (const permission of targetCommand.options.botPermissions) {
-            const hasPermission = botMember.permissions.has(permission);
+    if (!Array.isArray(commandPermissions)) {
+        commandPermissions = [commandPermissions];
+    }
 
-            if (!hasPermission) {
-                missingPermissions.push(`\`${permission.toString()}\``);
-            }
-        }
+    const missingPermissions: string[] = [];
 
-        if (missingPermissions.length) {
-            interaction.reply({
-                content: `❌ I do not have enough permission to execute this command. Missing: ${missingPermissions.join(
-                    ', ',
-                )}`,
-                ephemeral: true,
-            });
+    for (const permission of commandPermissions) {
+        const hasPermission = botMember.permissions.has(permission);
 
-            return true;
+        if (!hasPermission) {
+            missingPermissions.push(`\`${permission.toString()}\``);
         }
     }
+
+    if (missingPermissions.length) {
+        interaction.reply({
+            content: `❌ I do not have enough permissions to execute this command. Missing: ${missingPermissions.join(
+                ', ',
+            )}`,
+            ephemeral: true,
+        });
+
+        return true;
+    }
 }

packages/commandkit/src/handlers/command-handler/validations/userPermissions.ts

@@ -2,27 +2,32 @@ import { BuiltInValidationParams } from '../typings';
 
 export default function ({ interaction, targetCommand }: BuiltInValidationParams) {
     const memberPermissions = interaction.memberPermissions;
+    let commandPermissions = targetCommand.options?.userPermissions;
 
-    if (targetCommand.options?.userPermissions && memberPermissions) {
-        const missingPermissions: string[] = [];
+    if (!memberPermissions || !commandPermissions) return;
 
-        for (const permission of targetCommand.options.userPermissions) {
-            const hasPermission = memberPermissions.has(permission);
+    if (!Array.isArray(commandPermissions)) {
+        commandPermissions = [commandPermissions];
+    }
 
-            if (!hasPermission) {
-                missingPermissions.push(`\`${permission.toString()}\``);
-            }
-        }
+    const missingPermissions: string[] = [];
 
-        if (missingPermissions.length) {
-            interaction.reply({
-                content: `❌ You do not have enough permission to run this command. Missing: ${missingPermissions.join(
-                    ', ',
-                )}`,
-                ephemeral: true,
-            });
+    for (const permission of commandPermissions) {
+        const hasPermission = memberPermissions.has(permission);
 
-            return true;
+        if (!hasPermission) {
+            missingPermissions.push(`\`${permission.toString()}\``);
         }
     }
+
+    if (missingPermissions.length) {
+        interaction.reply({
+            content: `❌ You do not have enough permissions to run this command. Missing: ${missingPermissions.join(
+                ', ',
+            )}`,
+            ephemeral: true,
+        });
+
+        return true;
+    }
 }

packages/commandkit/src/handlers/event-handler/EventHandler.ts

@@ -57,11 +57,12 @@ export class EventHandler {
 
     #registerEvents() {
         const client = this.#data.client;
+        const handler = this.#data.commandKitInstance;
 
         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);
+                    const stopEventLoop = await eventFunction(...params, client, handler);
 
                     if (stopEventLoop) {
                         break;

packages/commandkit/src/handlers/event-handler/typings.d.ts

@@ -1,8 +1,10 @@
 import { Client } from 'discord.js';
+import { CommandKit } from '../../CommandKit';
 
 export interface EventHandlerOptions {
     client: Client;
     eventsPath: string;
+    commandKitInstance: CommandKit;
 }
 
 export interface EventHandlerData extends EventHandlerOptions {

packages/commandkit/src/index.ts

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

packages/commandkit/src/types/index.ts

@@ -0,0 +1,103 @@
+import type {
+    Client,
+    CommandInteraction,
+    PermissionResolvable,
+    ChatInputCommandInteraction,
+    ContextMenuCommandInteraction,
+    APIApplicationCommandSubcommandOption,
+    APIApplicationCommandSubcommandGroupOption,
+} from 'discord.js';
+import type { CommandKit } from '../CommandKit';
+import type { ContextCommandObject, SlashCommandObject } from '../typings';
+
+export interface CommandProps {
+    interaction: CommandInteraction;
+    client: Client<true>;
+    handler: CommandKit;
+}
+
+export interface SlashCommandProps {
+    interaction: ChatInputCommandInteraction;
+    client: Client<true>;
+    handler: CommandKit;
+}
+
+export interface ContextMenuCommandProps {
+    interaction: ContextMenuCommandInteraction;
+    client: Client<true>;
+    handler: CommandKit;
+}
+
+export interface ValidationFunctionProps {
+    interaction: ChatInputCommandInteraction | ContextMenuCommandInteraction;
+    client: Client<true>;
+    commandObj: SlashCommandObject | ContextCommandObject;
+    handler: CommandKit;
+}
+
+export interface CommandOptions {
+    guildOnly?: boolean;
+    devOnly?: boolean;
+    deleted?: boolean;
+    userPermissions?: PermissionResolvable;
+    botPermissions?: PermissionResolvable;
+    [key: string]: any;
+}
+
+export enum CommandType {
+    'ChatInput' = 1,
+    'Message' = 3,
+    'User' = 2,
+}
+
+type LocaleString =
+    | 'id'
+    | 'en-US'
+    | 'en-GB'
+    | 'bg'
+    | 'zh-CN'
+    | 'zh-TW'
+    | 'hr'
+    | 'cs'
+    | 'da'
+    | 'nl'
+    | 'fi'
+    | 'fr'
+    | 'de'
+    | 'el'
+    | 'hi'
+    | 'hu'
+    | 'it'
+    | 'ja'
+    | 'ko'
+    | 'lt'
+    | 'no'
+    | 'pl'
+    | 'pt-BR'
+    | 'ro'
+    | 'ru'
+    | 'es-ES'
+    | 'sv-SE'
+    | 'th'
+    | 'tr'
+    | 'uk'
+    | 'vi';
+
+export type CommandData = {
+    name: string;
+    description: string;
+    type?: CommandType;
+    name_localizations?: Partial<Record<LocaleString, string | null>>;
+    description_localizations?: Partial<Record<LocaleString, string | null>>;
+    dm_permission?: boolean;
+    default_member_permissions?: string;
+    nsfw?: boolean;
+    options?: Array<
+        APIApplicationCommandSubcommandOption | APIApplicationCommandSubcommandGroupOption
+    >;
+};
+
+export interface CommandFileObject {
+    data: CommandData;
+    options?: CommandOptions;
+}