magic madness

packages/commandkit/src/CommandKit.ts

@@ -7,6 +7,7 @@ import colors from './utils/colors';
 
 export class CommandKit {
     #data: CommandKitData;
+    static instance: CommandKit;
 
     /**
      * Create a new command and event handler with CommandKit.
@@ -25,11 +26,21 @@ export class CommandKit {
             );
         }
 
+        CommandKit.instance = this;
+
         this.#data = options;
 
         this.#init();
     }
 
+    getCommandHandler() {
+        return this.#data.commandHandler;
+    }
+
+    getClient() {
+        return this.#data.client;
+    }
+
     /**
      * (Private) Initialize CommandKit.
      */

packages/commandkit/src/handlers/command-handler/CommandHandler.ts

@@ -9,12 +9,20 @@ import loadCommandsWithRest from './functions/loadCommandsWithRest';
 import registerCommands from './functions/registerCommands';
 import builtInValidationsFunctions from './validations';
 import colors from '../../utils/colors';
+import { createStore } from '../../utils/store';
+import { Interaction } from 'discord.js';
+
+interface CommandStore {
+    command: CommandFileObject;
+    interaction: Interaction;
+}
 
 /**
  * A handler for client application commands.
  */
 export class CommandHandler {
     #data: CommandHandlerData;
+    public context = createStore<CommandStore>();
 
     constructor({ ...options }: CommandHandlerOptions) {
         this.#data = {
@@ -178,59 +186,61 @@ export class CommandHandler {
             // Skip if autocomplete handler is not defined
             if (isAutocomplete && !autocomplete) return;
 
-            const commandObj = {
-                data: targetCommand.data,
-                options: targetCommand.options,
-                ...rest,
-            };
-
-            if (this.#data.validationHandler) {
-                let canRun = true;
-
-                for (const validationFunction of this.#data.validationHandler.validations) {
-                    const stopValidationLoop = await validationFunction({
-                        interaction,
-                        commandObj,
-                        client: this.#data.client,
-                        handler: this.#data.commandkitInstance,
-                    });
-
-                    if (stopValidationLoop) {
-                        canRun = false;
-                        break;
+            this.context.run({ command: targetCommand, interaction }, async () => {
+                const commandObj = {
+                    data: targetCommand.data,
+                    options: targetCommand.options,
+                    ...rest,
+                };
+
+                if (this.#data.validationHandler) {
+                    let canRun = true;
+
+                    for (const validationFunction of this.#data.validationHandler.validations) {
+                        const stopValidationLoop = await validationFunction({
+                            interaction,
+                            commandObj,
+                            client: this.#data.client,
+                            handler: this.#data.commandkitInstance,
+                        });
+
+                        if (stopValidationLoop) {
+                            canRun = false;
+                            break;
+                        }
                     }
-                }
 
-                if (!canRun) return;
-            }
-
-            let canRun = true;
+                    if (!canRun) return;
+                }
 
-            // If custom validations pass and !skipBuiltInValidations, run built-in CommandKit validation functions
-            if (!this.#data.skipBuiltInValidations) {
-                for (const validation of this.#data.builtInValidations) {
-                    const stopValidationLoop = validation({
-                        targetCommand,
-                        interaction,
-                        handlerData: this.#data,
-                    });
+                let canRun = true;
 
-                    if (stopValidationLoop) {
-                        canRun = false;
-                        break;
+                // If custom validations pass and !skipBuiltInValidations, run built-in CommandKit validation functions
+                if (!this.#data.skipBuiltInValidations) {
+                    for (const validation of this.#data.builtInValidations) {
+                        const stopValidationLoop = validation({
+                            targetCommand,
+                            interaction,
+                            handlerData: this.#data,
+                        });
+
+                        if (stopValidationLoop) {
+                            canRun = false;
+                            break;
+                        }
                     }
                 }
-            }
 
-            if (!canRun) return;
+                if (!canRun) return;
 
-            const context = {
-                interaction,
-                client: this.#data.client,
-                handler: this.#data.commandkitInstance,
-            };
+                const context = {
+                    interaction,
+                    client: this.#data.client,
+                    handler: this.#data.commandkitInstance,
+                };
 
-            await targetCommand[isAutocomplete ? 'autocomplete' : 'run']!(context);
+                await targetCommand[isAutocomplete ? 'autocomplete' : 'run']!(context);
+            });
         });
     }
 

packages/commandkit/src/hooks/common.ts

@@ -0,0 +1,21 @@
+import { CommandKit } from '..';
+
+export const getCommandKit = () => {
+    const instance = CommandKit.instance;
+    if (!instance) {
+        throw new Error('CommandKit is not initialized.');
+    }
+
+    return instance;
+};
+
+export const getCommandHandler = () => {
+    const ckit = getCommandKit();
+    const handler = ckit.getCommandHandler();
+
+    if (!handler) {
+        throw new Error('CommandHandler is not initialized.');
+    }
+
+    return handler;
+};

packages/commandkit/src/hooks/index.ts

@@ -0,0 +1,2 @@
+export * from './useGuild';
+export * from './useInteraction';

packages/commandkit/src/hooks/useClient.ts

@@ -0,0 +1,5 @@
+import { getCommandKit } from './common';
+
+export function useClient() {
+    return getCommandKit().getClient();
+}

packages/commandkit/src/hooks/useGuild.ts

@@ -0,0 +1,13 @@
+import { getCommandHandler } from './common';
+
+export function useGuild() {
+    const { context } = getCommandHandler();
+
+    const data = context.getStore();
+
+    if (!data) {
+        throw new Error('Cannot invoke "useGuild" outside of a command.');
+    }
+
+    return data.interaction.guild;
+}

packages/commandkit/src/hooks/useInteraction.ts

@@ -0,0 +1,13 @@
+import { Interaction } from 'discord.js';
+import { getCommandHandler } from './common';
+
+export function useInteraction<T>(): T {
+    const { context } = getCommandHandler();
+
+    const data = context.getStore();
+    if (!data) {
+        throw new Error('Cannot invoke "useInteraction" outside of a command.');
+    }
+
+    return data.interaction as T;
+}

packages/commandkit/src/index.ts

@@ -1,5 +1,6 @@
 export * from './CommandKit';
 export * from './components';
+export * from './hooks';
 export * from './config';
 export * from './utils/signal';
 export type * from './types';

packages/commandkit/src/utils/store.ts

@@ -0,0 +1,5 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+export const createStore = <T = unknown>() => {
+    return new AsyncLocalStorage<T>();
+};

packages/commandkit/tests/src/commands/misc/count.ts

@@ -1,6 +1,6 @@
 import type { SlashCommandProps, CommandOptions, CommandData } from '../../../../src';
-import { ButtonKit, createEffect, createSignal } from '../../../../src/index';
-import { ButtonStyle, ActionRowBuilder, ButtonInteraction } from 'discord.js';
+import { ButtonKit, createEffect, createSignal, useInteraction } from '../../../../src/index';
+import { ButtonStyle, ActionRowBuilder, ButtonInteraction, CommandInteraction } from 'discord.js';
 
 export const data: CommandData = {
     name: 'count',
@@ -39,7 +39,10 @@ function getButtons() {
     return { dec, reset, inc, trash, row };
 }
 
-export async function run({ interaction }: SlashCommandProps) {
+export async function run() {
+    const interaction = useInteraction<CommandInteraction<'cached'>>(); // ignore this type im using ts here
+    if (!interaction.channel) return;
+
     const [count, setCount, disposeCountSubscribers] = createSignal(0);
     const { dec, reset, inc, trash, row } = getButtons();
 

packages/commandkit/tests/src/commands/misc/ping.ts

@@ -1,10 +1,15 @@
-import { ActionRowBuilder, ApplicationCommandOptionType, ButtonStyle } from 'discord.js';
 import {
-    SlashCommandProps,
+    ActionRowBuilder,
+    ApplicationCommandOptionType,
+    ButtonStyle,
+    CommandInteraction,
+} from 'discord.js';
+import {
     CommandOptions,
     CommandData,
     ButtonKit,
     AutocompleteProps,
+    useInteraction,
 } from '../../../../src/index';
 
 export const data: CommandData = {
@@ -36,7 +41,8 @@ export async function autocomplete({ interaction }: AutocompleteProps) {
     interaction.respond(filtered);
 }
 
-export async function run({ interaction, client }: SlashCommandProps) {
+export async function run() {
+    const interaction = useInteraction<CommandInteraction<'cached'>>(); // ignore this type im using ts here
     if (!interaction.channel) return;
 
     const button = new ButtonKit()
@@ -73,5 +79,5 @@ export async function run({ interaction, client }: SlashCommandProps) {
 }
 
 export const options: CommandOptions = {
-    devOnly: true,
+    devOnly: false,
 };

packages/commandkit/tests/src/index.ts

@@ -1,4 +1,4 @@
-import { CommandKit } from '../../src/index';
+import { CommandKit, useInteraction } from '../../src/index';
 import { Client } from 'discord.js';
 // require('dotenv').config();
 
@@ -17,3 +17,7 @@ new CommandKit({
 });
 
 await client.login(process.env.TOKEN);
+
+setTimeout(() => {
+    useInteraction();
+});