zumito-framework 1.10.0 → 1.11.1

package/dist/definitions/ErrorType.d.ts

@@ -3,5 +3,7 @@ export declare enum ErrorType {
     CommandLoad = 2,
     CommandRun = 3,
     Api = 4,
-    Other = 5
+    Other = 5,
+    ModuleLoad = 6,
+    RouteLoad = 7
 }

package/dist/definitions/ErrorType.js

@@ -5,4 +5,6 @@ export var ErrorType;
     ErrorType[ErrorType["CommandRun"] = 3] = "CommandRun";
     ErrorType[ErrorType["Api"] = 4] = "Api";
     ErrorType[ErrorType["Other"] = 5] = "Other";
+    ErrorType[ErrorType["ModuleLoad"] = 6] = "ModuleLoad";
+    ErrorType[ErrorType["RouteLoad"] = 7] = "RouteLoad";
 })(ErrorType || (ErrorType = {}));

package/dist/definitions/Module.d.ts

@@ -3,6 +3,7 @@ import { Command } from './commands/Command.js';
 import { FrameworkEvent } from './FrameworkEvent.js';
 import { CommandManager } from '../services/managers/CommandManager.js';
 import { ModuleParameters } from './parameters/ModuleParameters.js';
+import { ErrorHandler } from '../services/handlers/ErrorHandler.js';
 export type ModuleRequeriments = {
     modules: Array<string>;
     services: Array<string>;
@@ -16,6 +17,7 @@ export declare abstract class Module {
     protected events: Map<string, FrameworkEvent>;
     static requeriments: ModuleRequeriments;
     protected commandManager: CommandManager;
+    protected errorHandler: ErrorHandler;
     constructor(path: any, parameters?: ModuleParameters);
     initialize(): Promise<void>;
     registerCommands(): Promise<void>;

package/dist/definitions/Module.js

@@ -4,6 +4,8 @@ import path from 'path';
 import { ButtonInteraction, CommandInteraction, ModalSubmitInteraction, StringSelectMenuInteraction, } from 'discord.js';
 import { CommandManager } from '../services/managers/CommandManager.js';
 import { ServiceContainer } from '../services/ServiceContainer.js';
+import { ErrorHandler } from '../services/handlers/ErrorHandler.js';
+import { ErrorType } from './ErrorType.js';
 export class Module {
     path;
     parameters;
@@ -12,11 +14,13 @@ export class Module {
     events = new Map();
     static requeriments;
     commandManager;
+    errorHandler;
     constructor(path, parameters) {
         this.path = path;
         this.parameters = parameters;
         this.framework = ServiceContainer.getService(ZumitoFramework);
         this.commands = new CommandManager(this.framework);
+        this.errorHandler = ServiceContainer.getService(ErrorHandler);
     }
     async initialize() {
         await this.registerCommands();
@@ -125,7 +129,10 @@ export class Module {
                 continue;
             if (file.endsWith('.js') || file.endsWith('.ts')) {
                 let route = await import('file://' + path.join(folderPath, file)).catch((e) => {
-                    console.error(`[🔄🔴 ] Error loading ${file.slice(0, -3)} route on module ${this.constructor.name}`);
+                    this.errorHandler.handleError(e, {
+                        type: ErrorType.RouteLoad,
+                        moduleName: this.constructor.name,
+                    });
                 });
                 route = Object.values(route)[0];
                 route = new route();

package/dist/services/handlers/ErrorHandler.d.ts

@@ -17,7 +17,17 @@ type ApiErrorOptions = BaseErrorOptions & {
 type OtherErrorOptions = BaseErrorOptions & {
     type: ErrorType.Other;
 };
-type ErrorOptions = CommandErrorOptions | ApiErrorOptions | OtherErrorOptions;
+type ModuleLoadErrorOptions = BaseErrorOptions & {
+    type: ErrorType.ModuleLoad;
+    moduleName: string;
+};
+type RouteLoadErrorOptions = BaseErrorOptions & {
+    type: ErrorType.RouteLoad;
+    path?: string;
+    method?: string;
+    moduleName?: string;
+};
+type ErrorOptions = CommandErrorOptions | ApiErrorOptions | OtherErrorOptions | ModuleLoadErrorOptions | RouteLoadErrorOptions;
 export declare class ErrorHandler {
     framework: ZumitoFramework;
     constructor(framework: ZumitoFramework);

package/dist/services/handlers/ErrorHandler.js

@@ -29,6 +29,29 @@ export class ErrorHandler {
             console.line('');
             console.groupEnd();
         }
+        else if (options?.type == ErrorType.ModuleLoad) {
+            console.group(`[❌] Error loading module ${options.moduleName}`);
+            console.line(chalk.red('Error:'));
+            console.line(error?.toString?.() || 'Unknown error');
+            console.line('');
+            console.groupEnd();
+        }
+        else if (options?.type == ErrorType.RouteLoad) {
+            console.group(`[❌] Error loading route ${options.path}`);
+            console.line(chalk.red('Error:'));
+            console.line(error?.toString?.() || 'Unknown error');
+            console.line('');
+            console.groupEnd();
+            if (options?.moduleName) {
+                console.line(chalk.blue('Module: ') + options.moduleName);
+            }
+            if (options?.method) {
+                console.line(chalk.blue('Method: ') + options.method);
+            }
+            if (options?.path) {
+                console.line(chalk.blue('Path: ') + options.path);
+            }
+        }
         else {
             console.error(error?.toString?.() || 'Unknown error');
             console.line('');

package/dist/services/handlers/InteractionHandler.js

@@ -185,6 +185,9 @@ export class InteractionHandler {
         if (!commandInstance) {
             throw new Error(`Command ${path[0]} not found or modal id bad formatted`);
         }
+        if (!guildSettings && interaction.guildId) {
+            guildSettings = await ServiceContainer.getService(GuildDataGetter).getGuildSettings(interaction.guildId);
+        }
         const framework = ServiceContainer.getService(ZumitoFramework);
         if (commandInstance.binds?.modalSubmit) {
             const trans = this.translationManager.getShortHandMethod('command.' + commandInstance.name, guildSettings?.lang);

package/dist/services/managers/ModuleManager.d.ts

@@ -1,7 +1,10 @@
 import { ZumitoFramework } from "../../ZumitoFramework.js";
 import { Module } from "../../definitions/Module.js";
+import { ErrorHandler } from "../handlers/ErrorHandler.js";
 import { ModuleParameters } from "../../definitions/parameters/ModuleParameters.js";
 export declare class ModuleManager {
+    protected framework: ZumitoFramework;
+    protected errorHandler: ErrorHandler;
     protected modules: Map<string, Module>;
     protected pendingInstancePool: Array<{
         module: any;
@@ -9,8 +12,7 @@ export declare class ModuleManager {
         name?: string;
         options?: ModuleParameters;
     }>;
-    protected framework: ZumitoFramework;
-    constructor(framework: ZumitoFramework);
+    constructor(framework?: ZumitoFramework, errorHandler?: ErrorHandler);
     set(name: string, module: Module): void;
     get(name: string): Module;
     getAll(): Map<string, Module>;

package/dist/services/managers/ModuleManager.js

@@ -1,14 +1,19 @@
+import { ZumitoFramework } from "../../ZumitoFramework.js";
 import { Module } from "../../definitions/Module.js";
 import fs from 'fs';
 import path from 'path';
+import { ErrorHandler } from "../handlers/ErrorHandler.js";
 import { ServiceContainer } from "../ServiceContainer.js";
+import { ErrorType } from "../../definitions/ErrorType.js";
 export class ModuleManager {
+    framework;
+    errorHandler;
     modules;
     pendingInstancePool = [];
-    framework;
-    constructor(framework) {
-        this.modules = new Map();
+    constructor(framework = ServiceContainer.getService(ZumitoFramework), errorHandler = ServiceContainer.getService(ErrorHandler)) {
         this.framework = framework;
+        this.errorHandler = errorHandler;
+        this.modules = new Map();
     }
     set(name, module) {
         this.modules.set(name, module);
@@ -74,8 +79,10 @@ export class ModuleManager {
                 this.modules.set(name || moduleInstance.constructor.name, moduleInstance);
             }
             catch (err) {
-                console.error(`[📦🔴] Error loading module ${name || moduleInstance?.constructor?.name}: ${err.message}`);
-                console.error(err.stack);
+                this.errorHandler.handleError(err, {
+                    type: ErrorType.ModuleLoad,
+                    moduleName: name || moduleInstance?.constructor?.name
+                });
             }
         }
         else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zumito-framework",
-  "version": "1.10.0",
+  "version": "1.11.1",
   "description": "Discord.js bot framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",