feat: add function types for ModuleEventHandler

introduces setEvent, updates tests to include isUnconfiguredHandler also updates eslintrc to fix a tiny oversight
ZPTXDev · Nov 10, 2023 · fea324a · fea324a
1 parent 68576a9
commit fea324a
Show file tree

Hide file tree

Showing 12 changed files with 92 additions and 7 deletions.
diff --git a/.eslintrc b/.eslintrc
@@ -61,6 +61,14 @@
 		"yoda": "error",
 		"@typescript-eslint/no-shadow": ["error", { "allow": ["err", "resolve", "reject"] }],
 		"@typescript-eslint/explicit-function-return-type": ["error", { "allowTypedFunctionExpressions": false }],
-		"@typescript-eslint/consistent-type-imports": ["error"]
+		"@typescript-eslint/consistent-type-imports": ["error"],
+		"@typescript-eslint/no-unused-vars": [
+			"error",
+			{
+			  "argsIgnorePattern": "^_",
+			  "varsIgnorePattern": "^_",
+			  "caughtErrorsIgnorePattern": "^_"
+			}
+		]
 	}
 }
diff --git a/src/ModuleHandlers/ModuleBaseHandler.ts b/src/ModuleHandlers/ModuleBaseHandler.ts
@@ -1,4 +1,5 @@
 import type {
+    AcceptedEventTypes,
     ModuleAutocompleteHandler,
     ModuleButtonHandler,
     ModuleCommandHandler,
@@ -44,7 +45,7 @@ export abstract class ModuleBaseHandler {
      * Checks if this handler is an event handler.
      * @returns Whether this handler is an event handler.
      */
-    isEventHandler(): this is ModuleEventHandler {
+    isEventHandler(): this is ModuleEventHandler<AcceptedEventTypes> {
         return this.type === 'ModuleEventHandler';
     }
 

diff --git a/src/ModuleHandlers/ModuleEventHandler.ts b/src/ModuleHandlers/ModuleEventHandler.ts
@@ -1,11 +1,20 @@
+import type { ClientEvents } from 'discord.js';
 import {
     ModuleBaseHandler,
     type GenericExecuteFunction,
 } from './ModuleBaseHandler.js';
 
-export class ModuleEventHandler extends ModuleBaseHandler {
+type GenericEventExecuteFunction<K extends keyof ClientEvents> = (
+    ...args: ClientEvents[K]
+) => Promise<void> | void;
+
+export type AcceptedEventTypes = keyof ClientEvents | string | symbol;
+
+export class ModuleEventHandler<
+    E extends AcceptedEventTypes,
+> extends ModuleBaseHandler {
     once = false;
-    execute: GenericExecuteFunction;
+    execute: GenericEventExecuteFunction<keyof ClientEvents>;
 
     /**
      * Set whether this event handler should only be called once.
@@ -17,7 +26,23 @@ export class ModuleEventHandler extends ModuleBaseHandler {
         return this;
     }
 
-    setExecute(execute: GenericExecuteFunction): this {
+    /**
+     * Sets the event for this handler.
+     * @param _event - The event.
+     * @returns This instance for chaining.
+     */
+    setEvent<K extends keyof ClientEvents>(_event: K): ModuleEventHandler<K> {
+        const newInstance = new ModuleEventHandler<K>();
+        newInstance.once = this.once;
+        newInstance.execute = this.execute;
+        return newInstance;
+    }
+
+    setExecute(
+        execute: E extends keyof ClientEvents
+            ? GenericEventExecuteFunction<E>
+            : GenericExecuteFunction,
+    ): this {
         this.execute = execute;
         return this;
     }

diff --git a/src/ModuleHandlers/__tests__/ModuleAutocompleteHandler.test.ts b/src/ModuleHandlers/__tests__/ModuleAutocompleteHandler.test.ts
@@ -18,6 +18,9 @@ describe('ModuleAutocompleteHandler class', (): void => {
         );
     });
     test('all other typecheck methods return false', (): void => {
+        expect(new ModuleAutocompleteHandler().isUnconfiguredHandler()).toBe(
+            false,
+        );
         expect(new ModuleAutocompleteHandler().isEventHandler()).toBe(false);
         expect(new ModuleAutocompleteHandler().isButtonHandler()).toBe(false);
         expect(new ModuleAutocompleteHandler().isCommandHandler()).toBe(false);

diff --git a/src/ModuleHandlers/__tests__/ModuleButtonHandler.test.ts b/src/ModuleHandlers/__tests__/ModuleButtonHandler.test.ts
@@ -16,6 +16,7 @@ describe('ModuleButtonHandler class', (): void => {
         expect(new ModuleButtonHandler().isButtonHandler()).toBe(true);
     });
     test('all other typecheck methods return false', (): void => {
+        expect(new ModuleButtonHandler().isUnconfiguredHandler()).toBe(false);
         expect(new ModuleButtonHandler().isEventHandler()).toBe(false);
         expect(new ModuleButtonHandler().isAutocompleteHandler()).toBe(false);
         expect(new ModuleButtonHandler().isCommandHandler()).toBe(false);

diff --git a/src/ModuleHandlers/__tests__/ModuleCommandHandler.test.ts b/src/ModuleHandlers/__tests__/ModuleCommandHandler.test.ts
@@ -17,6 +17,7 @@ describe('ModuleCommandHandler class', (): void => {
         expect(new ModuleCommandHandler().isCommandHandler()).toBe(true);
     });
     test('all other typecheck methods return false', (): void => {
+        expect(new ModuleCommandHandler().isUnconfiguredHandler()).toBe(false);
         expect(new ModuleCommandHandler().isEventHandler()).toBe(false);
         expect(new ModuleCommandHandler().isAutocompleteHandler()).toBe(false);
         expect(new ModuleCommandHandler().isButtonHandler()).toBe(false);

diff --git a/src/ModuleHandlers/__tests__/ModuleEventHandler.test.ts b/src/ModuleHandlers/__tests__/ModuleEventHandler.test.ts
@@ -35,6 +35,35 @@ describe('ModuleEventHandler class', (): void => {
             expect(instance.setOnce(true)).toEqual(instance);
         });
     });
+    describe('setEvent method', (): void => {
+        test('is a function', (): void => {
+            expect(typeof ModuleEventHandler.prototype.setEvent).toEqual(
+                'function',
+            );
+        });
+        test('returns a new instance of ModuleEventHandler', (): void => {
+            const instance = new ModuleEventHandler();
+            expect(instance.setEvent('messageCreate')).toBeInstanceOf(
+                ModuleEventHandler,
+            );
+        });
+        test('returns a new instance of ModuleEventHandler with the same execute function', (): void => {
+            const instance = new ModuleEventHandler();
+            instance.setExecute((eventArgs): void => {
+                eventArgs;
+            });
+            expect(instance.setEvent('messageCreate').execute).toEqual(
+                instance.execute,
+            );
+        });
+        test('returns a new instance of ModuleEventHandler with the same once value', (): void => {
+            const instance = new ModuleEventHandler();
+            instance.setOnce(true);
+            expect(instance.setEvent('messageCreate').once).toEqual(
+                instance.once,
+            );
+        });
+    });
     describe('setExecute method', (): void => {
         test('is a function', (): void => {
             expect(typeof ModuleEventHandler.prototype.setExecute).toEqual(

diff --git a/src/ModuleHandlers/__tests__/ModuleMenuCommandHandler.test.ts b/src/ModuleHandlers/__tests__/ModuleMenuCommandHandler.test.ts
@@ -19,6 +19,9 @@ describe('ModuleMenuCommandHandler class', (): void => {
         );
     });
     test('all other typecheck methods return false', (): void => {
+        expect(new ModuleMenuCommandHandler().isUnconfiguredHandler()).toBe(
+            false,
+        );
         expect(new ModuleMenuCommandHandler().isEventHandler()).toBe(false);
         expect(new ModuleMenuCommandHandler().isAutocompleteHandler()).toBe(
             false,

diff --git a/src/ModuleHandlers/__tests__/ModuleMessageCommandHandler.test.ts b/src/ModuleHandlers/__tests__/ModuleMessageCommandHandler.test.ts
@@ -18,6 +18,9 @@ describe('ModuleMessageCommandHandler class', (): void => {
         ).toBe(true);
     });
     test('all other typecheck methods return false', (): void => {
+        expect(new ModuleMessageCommandHandler().isUnconfiguredHandler()).toBe(
+            false,
+        );
         expect(new ModuleMessageCommandHandler().isEventHandler()).toBe(false);
         expect(new ModuleMessageCommandHandler().isAutocompleteHandler()).toBe(
             false,

diff --git a/src/ModuleHandlers/__tests__/ModuleModalSubmitHandler.test.ts b/src/ModuleHandlers/__tests__/ModuleModalSubmitHandler.test.ts
@@ -18,6 +18,9 @@ describe('ModuleModalSubmitHandler class', (): void => {
         );
     });
     test('all other typecheck methods return false', (): void => {
+        expect(new ModuleModalSubmitHandler().isUnconfiguredHandler()).toBe(
+            false,
+        );
         expect(new ModuleModalSubmitHandler().isEventHandler()).toBe(false);
         expect(new ModuleModalSubmitHandler().isAutocompleteHandler()).toBe(
             false,

diff --git a/src/ModuleHandlers/__tests__/ModuleSelectMenuHandler.test.ts b/src/ModuleHandlers/__tests__/ModuleSelectMenuHandler.test.ts
@@ -16,6 +16,9 @@ describe('ModuleSelectMenuHandler class', (): void => {
         expect(new ModuleSelectMenuHandler().isSelectMenuHandler()).toBe(true);
     });
     test('all other typecheck methods return false', (): void => {
+        expect(new ModuleSelectMenuHandler().isUnconfiguredHandler()).toBe(
+            false,
+        );
         expect(new ModuleSelectMenuHandler().isEventHandler()).toBe(false);
         expect(new ModuleSelectMenuHandler().isAutocompleteHandler()).toBe(
             false,

diff --git a/src/SkeletonClient.ts b/src/SkeletonClient.ts
@@ -19,6 +19,7 @@ import { logger, type LoggerObject } from './Logger.js';
 import type { ModuleBaseHandler } from './ModuleHandlers/ModuleBaseHandler.js';
 import {
     ModuleEventHandler,
+    type AcceptedEventTypes,
     type ModuleAutocompleteHandler,
     type ModuleButtonHandler,
     type ModuleCommandHandler,
@@ -58,7 +59,10 @@ export class SkeletonClient extends Client {
     /** Command data stored internally for use in deploying commands */
     private commandData: SlashCommandBuilder[] = [];
     // One event can have multiple handlers
-    protected eventHandlers = new Collection<string, ModuleEventHandler[]>();
+    protected eventHandlers = new Collection<
+        string,
+        ModuleEventHandler<AcceptedEventTypes>[]
+    >();
     private verbose = process.argv
         .slice(2)
         .map((argv): string => argv.toLowerCase())
@@ -305,7 +309,8 @@ export class SkeletonClient extends Client {
                         camelCaseHandlerType === 'event' &&
                         handlerData.isEventHandler()
                     ) {
-                        let eventHandlers: ModuleEventHandler[] = [];
+                        let eventHandlers: ModuleEventHandler<AcceptedEventTypes>[] =
+                            [];
                         // Event already exists in the collection
                         if (this.eventHandlers.has(handlerName)) {
                             eventHandlers = this.eventHandlers.get(handlerName);