@julanzw/ttoolbox-discordjs-framework 1.0.4 → 1.0.5

package/dist/classes/Command.class.d.ts

@@ -1,6 +1,7 @@
 import { ChatInputCommandInteraction, Client, SlashCommandBuilder, SlashCommandSubcommandBuilder } from 'discord.js';
 import { PermissionLevel } from '../types/permission.js';
 import { ILogger } from '../types/logger.js';
+import { ErrorReporter } from '../utils/ErrorReporter.js';
 /**
  * Abstract base class for Discord slash commands.
  *
@@ -35,6 +36,8 @@ export declare abstract class Command {
     cooldown?: number;
     /** Logger instance to use inside the command */
     protected logger?: ILogger;
+    /** ErrorReporter instance to use inside the command */
+    protected errorReporter?: ErrorReporter;
     /**
      * Validates whether the command can be executed in the current context.
      *
@@ -166,4 +169,8 @@ export declare abstract class Command {
      * @param logToConsole - Whether to also log to console
      */
     protected log(message: string, level: string, scope: string, logToConsole?: boolean): void;
+    /**
+     * Set the error reporter for this command
+     */
+    setErrorReporter(reporter: ErrorReporter): void;
 }

package/dist/classes/Command.class.js

@@ -85,13 +85,19 @@ export class Command {
         const scope = `${commandName}_EXECUTION`;
         try {
             await fn();
-            const subcommandName = interaction.options.getSubcommand(false);
-            this.logger?.log(`${commandName} ${subcommandName ? `(${subcommandName}) ` : ``}command executed`, 'info', scope);
+            this.logger?.log(`${commandName} command executed`, 'info', scope);
         }
         catch (err) {
-            this.logger?.log(
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            `An Error occurred: ${err.message ?? err}`, 'error', scope, true);
+            this.logger?.log(`An Error occurred: ${err.message ?? err}`, 'error', scope, true);
+            if (this.errorReporter) {
+                await this.errorReporter.reportError(err, `Command: ${commandName}`, {
+                    user: interaction.user.tag,
+                    userId: interaction.user.id,
+                    guild: interaction.guild?.name,
+                    guildId: interaction.guildId,
+                    channel: interaction.channel?.id,
+                });
+            }
             return await safeReply(interaction, 'An unexpected error occurred.');
         }
     }
@@ -153,4 +159,10 @@ export class Command {
     log(message, level, scope, logToConsole = false) {
         this.logger?.log(message, level, scope, logToConsole);
     }
+    /**
+     * Set the error reporter for this command
+     */
+    setErrorReporter(reporter) {
+        this.errorReporter = reporter;
+    }
 }

package/dist/classes/CommandManager.class.d.ts

@@ -2,9 +2,11 @@ import { ChatInputCommandInteraction, Client, RESTPostAPIChatInputApplicationCom
 import { ILogger } from '../types/logger.js';
 import { Command } from './Command.class.js';
 import { SubcommandGroup } from './SubcommandGroup.class.js';
+import { ErrorReporter } from '../utils/ErrorReporter.js';
 export declare class CommandManager {
     private commands;
     protected logger?: ILogger;
+    protected errorReporter?: ErrorReporter;
     /**
      * Register a single command or subcommand group
      */
@@ -66,4 +68,8 @@ export declare class CommandManager {
      */
     getCommandNames(): string[];
     setLogger(logger: ILogger): this;
+    /**
+     * Set the error reporter for all commands
+     */
+    setErrorReporter(reporter: ErrorReporter): this;
 }

package/dist/classes/CommandManager.class.js

@@ -10,6 +10,9 @@ export class CommandManager {
         if (this.logger) {
             command.setLogger(this.logger);
         }
+        if (this.errorReporter) {
+            command.setErrorReporter(this.errorReporter);
+        }
         this.commands.set(command.name, command);
         return this;
     }
@@ -146,4 +149,14 @@ export class CommandManager {
         }
         return this;
     }
+    /**
+     * Set the error reporter for all commands
+     */
+    setErrorReporter(reporter) {
+        this.errorReporter = reporter;
+        for (const command of this.commands.values()) {
+            command.setErrorReporter(reporter);
+        }
+        return this;
+    }
 }

package/dist/classes/SubcommandGroup.class.d.ts

@@ -1,6 +1,7 @@
 import { ChatInputCommandInteraction, Client, RESTPostAPIChatInputApplicationCommandsJSONBody } from 'discord.js';
 import { ILogger } from '../types/logger.js';
 import { Command } from './Command.class.js';
+import { ErrorReporter } from '../utils/ErrorReporter.js';
 /**
  * Abstract base class for Discord slash command groups with subcommands.
  *
@@ -32,6 +33,8 @@ export declare abstract class SubcommandGroup {
     protected abstract subcommands: Map<string, Command>;
     /** The logger instance used in the subcommand group */
     protected logger?: ILogger;
+    /** ErrorReporter instance to use inside the subcommand group */
+    private errorReporter?;
     /**
      * Safely executes a function with error handling and logging.
      *
@@ -39,7 +42,7 @@ export declare abstract class SubcommandGroup {
      * and automatically handles errors by logging them and sending a user-friendly
      * error message.
      *
-     * @param commandName - The name of the parent command
+     * @param subcommandName - The name of the subcommand
      * @param scope - The logging scope for this execution
      * @param interaction - The command interaction
      * @param fn - The function to execute
@@ -124,4 +127,8 @@ export declare abstract class SubcommandGroup {
      * @param logToConsole - Whether to also log to console
      */
     protected log(message: string, level: string, scope: string, logToConsole?: boolean): void;
+    /**
+     * Set the error reporter for this subcommand group.
+     */
+    setErrorReporter(reporter: ErrorReporter): this;
 }

package/dist/classes/SubcommandGroup.class.js

@@ -30,20 +30,26 @@ export class SubcommandGroup {
      * and automatically handles errors by logging them and sending a user-friendly
      * error message.
      *
-     * @param commandName - The name of the parent command
+     * @param subcommandName - The name of the subcommand
      * @param scope - The logging scope for this execution
      * @param interaction - The command interaction
      * @param fn - The function to execute
      * @private
      */
-    async safeExecute(commandName, scope, interaction, fn) {
+    async safeExecute(subcommandName, scope, interaction, fn) {
         try {
             await fn();
-            const subcommandName = interaction.options.getSubcommand(false);
-            this.logger?.log(`${commandName} ${subcommandName ? `(${subcommandName}) ` : ``}command executed`, 'info', scope);
+            this.logger?.log(`${this.name} (${subcommandName}) command executed`, 'info', scope);
         }
         catch (err) {
             this.logger?.log('An Error occured' + err, 'error', scope, true);
+            await this.errorReporter?.reportError(err, `Command: ${subcommandName} in SubcommandGroup: ${this.name}`, {
+                user: interaction.user.tag,
+                userId: interaction.user.id,
+                guild: interaction.guild?.name,
+                guildId: interaction.guildId,
+                channel: interaction.channel?.id,
+            });
             return await safeReply(interaction, 'An unexpected error occurred.');
         }
     }
@@ -74,7 +80,7 @@ export class SubcommandGroup {
             throw new Error(`Unknown subcommand: ${subcommandName}`);
         }
         const scope = `${subcommand.name}_EXECUTION`;
-        await this.safeExecute(this.name, scope, interaction, () => subcommand.execute(interaction, client));
+        await this.safeExecute(subcommandName, scope, interaction, () => subcommand.execute(interaction, client));
     }
     /**
      * Converts the command group to Discord API JSON format for registration.
@@ -153,4 +159,14 @@ export class SubcommandGroup {
     log(message, level, scope, logToConsole = false) {
         this.logger?.log(message, level, scope, logToConsole);
     }
+    /**
+     * Set the error reporter for this subcommand group.
+     */
+    setErrorReporter(reporter) {
+        this.errorReporter = reporter;
+        for (const command of this.subcommands.values()) {
+            command.setErrorReporter(reporter);
+        }
+        return this;
+    }
 }

package/dist/index.d.ts

@@ -15,4 +15,5 @@ export { safeReply, safeEdit } from './utils/editAndReply.js';
 export { formatDuration, formatDateToString, formatDateToYYYYMMDDHHMMSS, formatDateToDDMMYYYY, getDaySuffix, capitalizeFirst, } from './utils/formatting.js';
 export { TIMES_MILISECONDS } from './utils/miliseconds.js';
 export { TToolboxLogger } from './utils/TToolboxLogger.class.js';
+export { ErrorReporter } from './utils/ErrorReporter.js';
 export { InteractionError } from './classes/InteractionError.class.js';

package/dist/index.js

@@ -13,5 +13,6 @@ export { safeReply, safeEdit } from './utils/editAndReply.js';
 export { formatDuration, formatDateToString, formatDateToYYYYMMDDHHMMSS, formatDateToDDMMYYYY, getDaySuffix, capitalizeFirst, } from './utils/formatting.js';
 export { TIMES_MILISECONDS } from './utils/miliseconds.js';
 export { TToolboxLogger } from './utils/TToolboxLogger.class.js';
+export { ErrorReporter } from './utils/ErrorReporter.js';
 // Errors
 export { InteractionError } from './classes/InteractionError.class.js';

package/dist/testing/mock.d.ts

@@ -0,0 +1,72 @@
+import type { ChatInputCommandInteraction, User, Guild, TextChannel, Client } from 'discord.js';
+/**
+ * Options for creating a mock interaction
+ */
+export interface MockInteractionOptions {
+    commandName?: string;
+    user?: Partial<User>;
+    guild?: Partial<Guild>;
+    guildId?: string | null;
+    channelId?: string;
+    options?: Record<string, any>;
+    replied?: boolean;
+    deferred?: boolean;
+}
+/**
+ * Create a mock ChatInputCommandInteraction for testing.
+ *
+ * @param overrides - Optional overrides for interaction properties
+ * @returns A mocked interaction object
+ *
+ * @example
+ * ```typescript
+ * import { describe, it, expect, vi } from 'vitest';
+ * import { createMockInteraction } from '@julanzw/ttoolbox-discordjs-framework/testing';
+ *
+ * describe('PingCommand', () => {
+ *   it('should reply with pong', async () => {
+ *     const interaction = createMockInteraction({
+ *       commandName: 'ping',
+ *     });
+ *
+ *     const command = new PingCommand();
+ *     await command.execute(interaction, mockClient);
+ *
+ *     expect(interaction.reply).toHaveBeenCalledWith('Pong!');
+ *   });
+ * });
+ * ```
+ */
+export declare function createMockInteraction(overrides?: MockInteractionOptions): ChatInputCommandInteraction;
+/**
+ * Create a mock Discord client for testing.
+ *
+ * @example
+ * ```typescript
+ * const client = createMockClient();
+ * const command = new PingCommand();
+ * await command.execute(mockInteraction, client);
+ * ```
+ */
+export declare function createMockClient(): Client;
+/**
+ * Create a mock user for testing.
+ *
+ * @param overrides - Optional overrides for user properties
+ * @returns A mocked User object
+ */
+export declare function createMockUser(overrides?: Partial<User>): User;
+/**
+ * Create a mock guild for testing.
+ *
+ * @param overrides - Optional overrides for guild properties
+ * @returns A mocked Guild object
+ */
+export declare function createMockGuild(overrides?: Partial<Guild>): Guild;
+/**
+ * Create a mock text channel for testing.
+ *
+ * @param overrides - Optional overrides for channel properties
+ * @returns A mocked TextChannel object
+ */
+export declare function createMockChannel(overrides?: Partial<TextChannel>): TextChannel;

package/dist/testing/mock.js

@@ -0,0 +1,197 @@
+/**
+ * Create a mock ChatInputCommandInteraction for testing.
+ *
+ * @param overrides - Optional overrides for interaction properties
+ * @returns A mocked interaction object
+ *
+ * @example
+ * ```typescript
+ * import { describe, it, expect, vi } from 'vitest';
+ * import { createMockInteraction } from '@julanzw/ttoolbox-discordjs-framework/testing';
+ *
+ * describe('PingCommand', () => {
+ *   it('should reply with pong', async () => {
+ *     const interaction = createMockInteraction({
+ *       commandName: 'ping',
+ *     });
+ *
+ *     const command = new PingCommand();
+ *     await command.execute(interaction, mockClient);
+ *
+ *     expect(interaction.reply).toHaveBeenCalledWith('Pong!');
+ *   });
+ * });
+ * ```
+ */
+export function createMockInteraction(overrides = {}) {
+    const mockUser = {
+        id: overrides.user?.id || '123456789',
+        username: overrides.user?.username || 'testuser',
+        discriminator: overrides.user?.discriminator || '0001',
+        tag: overrides.user?.tag || 'testuser#0001',
+        bot: overrides.user?.bot || false,
+        system: overrides.user?.system || false,
+        avatar: overrides.user?.avatar || null,
+        ...overrides.user,
+    };
+    const mockGuild = overrides.guildId === null ? null : {
+        id: overrides.guild?.id || overrides.guildId || '987654321',
+        name: overrides.guild?.name || 'Test Guild',
+        ...overrides.guild,
+    };
+    const mockChannel = {
+        id: overrides.channelId || '111222333',
+        type: 0, // TextChannel
+        isTextBased: () => true,
+    };
+    const mockMember = mockGuild ? {
+        id: mockUser.id,
+        user: mockUser,
+        guild: mockGuild,
+        roles: {
+            cache: new Map(),
+            highest: { position: 0 },
+        },
+    } : null;
+    // Create mock options resolver
+    const mockOptionsResolver = {
+        getString: vi.fn((name, required) => {
+            const value = overrides.options?.[name];
+            if (required && !value)
+                throw new Error(`Required option ${name} is missing`);
+            return value || null;
+        }),
+        getInteger: vi.fn((name, required) => {
+            const value = overrides.options?.[name];
+            if (required && value === undefined)
+                throw new Error(`Required option ${name} is missing`);
+            return value !== undefined ? value : null;
+        }),
+        getNumber: vi.fn((name, required) => {
+            const value = overrides.options?.[name];
+            if (required && value === undefined)
+                throw new Error(`Required option ${name} is missing`);
+            return value !== undefined ? value : null;
+        }),
+        getBoolean: vi.fn((name, required) => {
+            const value = overrides.options?.[name];
+            if (required && value === undefined)
+                throw new Error(`Required option ${name} is missing`);
+            return value !== undefined ? value : null;
+        }),
+        getUser: vi.fn((name) => overrides.options?.[name] || null),
+        getChannel: vi.fn((name) => overrides.options?.[name] || null),
+        getRole: vi.fn((name) => overrides.options?.[name] || null),
+        getMember: vi.fn((name) => overrides.options?.[name] || null),
+        getMentionable: vi.fn((name) => overrides.options?.[name] || null),
+        getAttachment: vi.fn((name) => overrides.options?.[name] || null),
+        getSubcommand: vi.fn((required) => {
+            const value = overrides.options?.['_subcommand'];
+            if (required && !value)
+                throw new Error('Subcommand is required');
+            return value || null;
+        }),
+        data: [],
+    };
+    const mockInteraction = {
+        id: 'mock-interaction-id',
+        type: 2, // ApplicationCommandType.ChatInput
+        user: mockUser,
+        member: mockMember,
+        guild: mockGuild,
+        guildId: mockGuild?.id || null,
+        channel: mockChannel,
+        channelId: mockChannel.id,
+        commandName: overrides.commandName || 'test',
+        options: mockOptionsResolver,
+        replied: overrides.replied || false,
+        deferred: overrides.deferred || false,
+        createdTimestamp: Date.now(),
+        // Mock methods
+        reply: vi.fn().mockResolvedValue(undefined),
+        editReply: vi.fn().mockResolvedValue(undefined),
+        followUp: vi.fn().mockResolvedValue(undefined),
+        deferReply: vi.fn().mockResolvedValue(undefined),
+        deleteReply: vi.fn().mockResolvedValue(undefined),
+        fetchReply: vi.fn().mockResolvedValue(undefined),
+    };
+    return mockInteraction;
+}
+/**
+ * Create a mock Discord client for testing.
+ *
+ * @example
+ * ```typescript
+ * const client = createMockClient();
+ * const command = new PingCommand();
+ * await command.execute(mockInteraction, client);
+ * ```
+ */
+export function createMockClient() {
+    const mockClient = {
+        user: {
+            id: '999888777',
+            tag: 'TestBot#1234',
+            username: 'TestBot',
+        },
+        ws: {
+            ping: 42,
+        },
+        channels: {
+            fetch: vi.fn().mockResolvedValue({
+                id: '111222333',
+                isTextBased: () => true,
+                send: vi.fn().mockResolvedValue(undefined),
+            }),
+        },
+    };
+    return mockClient;
+}
+/**
+ * Create a mock user for testing.
+ *
+ * @param overrides - Optional overrides for user properties
+ * @returns A mocked User object
+ */
+export function createMockUser(overrides = {}) {
+    return {
+        id: overrides.id || '123456789',
+        username: overrides.username || 'testuser',
+        discriminator: overrides.discriminator || '0001',
+        tag: overrides.tag || 'testuser#0001',
+        bot: overrides.bot || false,
+        system: overrides.system || false,
+        avatar: overrides.avatar || null,
+        ...overrides,
+    };
+}
+/**
+ * Create a mock guild for testing.
+ *
+ * @param overrides - Optional overrides for guild properties
+ * @returns A mocked Guild object
+ */
+export function createMockGuild(overrides = {}) {
+    return {
+        id: overrides.id || '987654321',
+        name: overrides.name || 'Test Guild',
+        ownerId: '111111111',
+        ...overrides,
+    };
+}
+/**
+ * Create a mock text channel for testing.
+ *
+ * @param overrides - Optional overrides for channel properties
+ * @returns A mocked TextChannel object
+ */
+export function createMockChannel(overrides = {}) {
+    return {
+        id: overrides.id || '111222333',
+        type: 0, // TextChannel
+        name: 'test-channel',
+        isTextBased: () => true,
+        send: vi.fn().mockResolvedValue(undefined),
+        ...overrides,
+    };
+}

package/dist/utils/ErrorReporter.d.ts

@@ -0,0 +1,54 @@
+import { Client } from 'discord.js';
+import type { ILogger } from '../types/logger.js';
+/**
+ * Reports errors to a designated Discord channel.
+ *
+ * Used for monitoring production bots - get notified when errors occur
+ * without having to constantly checking logs.
+ *
+ * @example
+ * ```typescript
+ * const errorReporter = new ErrorReporter(client, '1234567890', logger);
+ *
+ * try {
+ *   await riskyOperation();
+ * } catch (err) {
+ *   await errorReporter.reportError(err, 'Processing user data');
+ * }
+ * ```
+ */
+export declare class ErrorReporter {
+    private client;
+    private channelId;
+    private logger?;
+    constructor(client: Client, channelId: string, logger?: ILogger | undefined);
+    /**
+     * Report an error to the configured Discord channel.
+     *
+     * @param error - The error that occurred
+     * @param context - Context about where/why the error happened
+     * @param additionalInfo - Optional additional information to include
+     *
+     * @example
+     * ```typescript
+     * await errorReporter.reportError(
+     *   new Error('Comparison went wrong'),
+     *   'data not equal to moreData',
+     *   { data: '123', moreData: '456' }
+     * );
+     * ```
+     */
+    reportError(error: Error, context: string, additionalInfo?: Record<string, any>): Promise<void>;
+    /**
+     * Truncate text to a maximum length
+     */
+    private truncate;
+    /**
+     * Update the channel ID for error reporting
+     */
+    setChannel(channelId: string): void;
+    /**
+     * Get the current channel ID
+     */
+    getChannelId(): string;
+}

package/dist/utils/ErrorReporter.js

@@ -0,0 +1,95 @@
+import { EmbedBuilder } from 'discord.js';
+/**
+ * Reports errors to a designated Discord channel.
+ *
+ * Used for monitoring production bots - get notified when errors occur
+ * without having to constantly checking logs.
+ *
+ * @example
+ * ```typescript
+ * const errorReporter = new ErrorReporter(client, '1234567890', logger);
+ *
+ * try {
+ *   await riskyOperation();
+ * } catch (err) {
+ *   await errorReporter.reportError(err, 'Processing user data');
+ * }
+ * ```
+ */
+export class ErrorReporter {
+    constructor(client, channelId, logger) {
+        this.client = client;
+        this.channelId = channelId;
+        this.logger = logger;
+    }
+    /**
+     * Report an error to the configured Discord channel.
+     *
+     * @param error - The error that occurred
+     * @param context - Context about where/why the error happened
+     * @param additionalInfo - Optional additional information to include
+     *
+     * @example
+     * ```typescript
+     * await errorReporter.reportError(
+     *   new Error('Comparison went wrong'),
+     *   'data not equal to moreData',
+     *   { data: '123', moreData: '456' }
+     * );
+     * ```
+     */
+    async reportError(error, context, additionalInfo) {
+        try {
+            const channel = await this.client.channels.fetch(this.channelId);
+            if (!channel?.isTextBased()) {
+                this.logger?.warn(`Error reporter channel ${this.channelId} is not text-based`, 'error-reporter');
+                return;
+            }
+            const embed = new EmbedBuilder()
+                .setTitle('Error Occurred')
+                .setColor(0xed4245)
+                .addFields({ name: 'Context', value: context }, {
+                name: 'Error',
+                value: `\`\`\`${this.truncate(error.message, 1000)}\`\`\``
+            })
+                .setTimestamp();
+            if (error.stack) {
+                embed.addFields({
+                    name: 'Stack Trace',
+                    value: `\`\`\`${this.truncate(error.stack, 1000)}\`\`\``,
+                });
+            }
+            if (additionalInfo && Object.keys(additionalInfo).length > 0) {
+                embed.addFields({
+                    name: 'Additional Info',
+                    value: `\`\`\`json\n${JSON.stringify(additionalInfo, null, 2).slice(0, 1000)}\`\`\``,
+                });
+            }
+            await channel.send({ embeds: [embed] });
+            this.logger?.info(`Error reported to channel ${this.channelId}`, 'error-reporter');
+        }
+        catch (err) {
+            this.logger?.error(`Failed to report error to Discord: ${err.message}`, 'error-reporter');
+        }
+    }
+    /**
+     * Truncate text to a maximum length
+     */
+    truncate(text, maxLength) {
+        if (text.length <= maxLength)
+            return text;
+        return text.slice(0, maxLength - 3) + '...';
+    }
+    /**
+     * Update the channel ID for error reporting
+     */
+    setChannel(channelId) {
+        this.channelId = channelId;
+    }
+    /**
+     * Get the current channel ID
+     */
+    getChannelId() {
+        return this.channelId;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@julanzw/ttoolbox-discordjs-framework",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "A Discord.js command framework with built-in handlers and utilities",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",