feat: error catching in events and commands

Author: ghostdevv

.changeset/silly-goats-kiss.md

@@ -0,0 +1,5 @@
+---
+'jellycommands': minor
+---
+
+error catching in events and commands

packages/jellycommands/src/JellyCommands/commands/CommandManager.ts

@@ -1,13 +1,13 @@
 import type { RESTPutAPIGuildApplicationCommandsPermissionsJSONBody } from 'discord-api-types/v9';
 import { CommandCache, CommandIdResolver } from './CommandPersistance';
 import type { APIApplicationCommand } from 'discord-api-types/v9';
+import { Command } from './types/commands/Command.js';
 import type { JellyCommands } from '../JellyCommands';
 import { getAuthDetails } from '../../util/token.js';
 import { createRequest } from '../../util/request';
 import { BaseCommand } from './base/BaseCommand';
 import type { Interaction } from 'discord.js';
 import { Routes } from 'discord-api-types/v9';
-import { Command } from './types/commands/Command.js';
 
 export type CommandIDMap = Map<string, BaseCommand>;
 export type CommandMap = Map<string, BaseCommand>;
@@ -59,10 +59,18 @@ export class CommandManager {
             );
 
         // Run the command
-        command.run({
-            client: this.client,
-            interaction,
-        });
+        try {
+            await command.run({
+                client: this.client,
+                interaction,
+            });
+        } catch (e) {
+            console.error(
+                `There was an error running command ${command.options.name}`,
+                `interaction: ${interaction.id}, channel: ${interaction.channel}, guild: ${interaction.guild}`,
+                e,
+            );
+        }
     }
 
     static async readCommands(

packages/jellycommands/src/JellyCommands/events/Event.ts

@@ -2,16 +2,23 @@ import { schema, EventOptions } from './options';
 import { removeKeys } from 'ghoststools';
 
 import type { JellyCommands } from '../JellyCommands';
-import type { Client, ClientEvents } from 'discord.js';
+import type { ClientEvents } from 'discord.js';
+
+type Awaitable<T> = Promise<T> | T;
+
+export type EventCallback<EventName extends keyof ClientEvents> = (
+    instance: { client: JellyCommands },
+    ...args: ClientEvents[EventName]
+) => Awaitable<void>;
 
 export class Event<T extends keyof ClientEvents> {
     public readonly name: keyof ClientEvents;
-    public readonly run: Function;
+    public readonly run: EventCallback<T>;
     public readonly options: Required<EventOptions<T>>;
 
     constructor(
         name: keyof ClientEvents,
-        run: Function,
+        run: Event<T>['run'],
         options: EventOptions<T>,
     ) {
         this.name = name;
@@ -37,10 +44,7 @@ export class Event<T extends keyof ClientEvents> {
 
 export const event = <K extends keyof ClientEvents>(
     options: EventOptions<K> & {
-        run: (
-            instance: { client: JellyCommands },
-            ...args: ClientEvents[K]
-        ) => void | any;
+        run: EventCallback<K>;
     },
 ) => {
     return new Event<K>(

packages/jellycommands/src/JellyCommands/events/EventManager.ts

@@ -1,4 +1,5 @@
 import type { JellyCommands } from '../JellyCommands';
+import type { ClientEvents } from 'discord.js';
 import type { Event } from './Event';
 
 export class EventManager {
@@ -9,7 +10,18 @@ export class EventManager {
         for (const event of events) {
             if (event.options.disabled) continue;
 
-            const cb = (...ctx: any[]) => event.run({ client }, ...ctx);
+            const cb = async <EventName extends keyof ClientEvents>(
+                ...ctx: ClientEvents[EventName]
+            ) => {
+                try {
+                    await event.run({ client }, ...ctx);
+                } catch (e) {
+                    console.error(
+                        `There was an error running event ${event.name}`,
+                        e,
+                    );
+                }
+            };
 
             if (event.options.once) client.once(event.name, cb);
             else client.on(event.name, cb);