zumito-framework 1.4.2 → 1.6.0

package/dist/ZumitoFramework.js

@@ -21,6 +21,8 @@ import { RecursiveObjectMerger } from './services/utilities/RecursiveObjectMerge
 import { MemberPermissionChecker } from './services/utilities/MemberPermissionChecker.js';
 import { CommandParser } from './services/CommandParser.js';
 import { SlashCommandRefresher } from './services/SlashCommandRefresher.js';
+import { ErrorHandler } from '@services/handlers/ErrorHandler.js';
+import { ErrorType } from '@definitions/ErrorType.js';
 // import better-logging
 betterLogging(console);
 /**
@@ -211,6 +213,21 @@ export class ZumitoFramework {
         this.app.use(express.json());
         this.app.use(express.urlencoded({ extended: false }));
         this.app.use(cookieParser());
+        //Error handler
+        this.app.use(function (err, req, res, next) {
+            const errorHandler = ServiceContainer.getService(ErrorHandler);
+            errorHandler.handleError(err, {
+                type: ErrorType.Api,
+                endpoint: req.originalUrl,
+                method: req.method,
+            });
+            if (!res.headersSent) {
+                return res.status(500).json({
+                    error: 'Internal Server Error',
+                    message: 'An unexpected error occurred. Please try again later.',
+                });
+            }
+        });
         //this.app.use(express.static(path.join(__dirname, "public")));
         //To allow cross-origin requests
         this.app.use(cors());
@@ -291,16 +308,13 @@ export class ZumitoFramework {
             module = await this.modules.loadModuleFile(path.join(modulesFolder, moduleName));
         }
         // Create module instance
-        const moduleInstance = await this.modules.instanceModule(module, path.join(modulesFolder, moduleName), moduleName);
-        // Register module in the framework
-        this.modules.registerModule(moduleInstance);
+        await this.modules.instanceModule(module, path.join(modulesFolder, moduleName), moduleName);
     }
     async registerBundle(bundlePath, bundleOptions) {
         console.log(bundlePath);
         const bundle = await this.modules.loadModuleFile(bundlePath);
         const bundleName = path.basename(bundlePath);
-        const moduleInstance = await this.modules.instanceModule(bundle, bundlePath, bundleName, bundleOptions);
-        this.modules.registerModule(moduleInstance);
+        await this.modules.instanceModule(bundle, bundlePath, bundleName, bundleOptions);
     }
     /**
      * Initializes the Discord client using the Discord.js library.

package/dist/definitions/ErrorType.d.ts

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

package/dist/definitions/ErrorType.js

@@ -3,5 +3,6 @@ export var ErrorType;
     ErrorType[ErrorType["CommandInstance"] = 1] = "CommandInstance";
     ErrorType[ErrorType["CommandLoad"] = 2] = "CommandLoad";
     ErrorType[ErrorType["CommandRun"] = 3] = "CommandRun";
-    ErrorType[ErrorType["Other"] = 4] = "Other";
+    ErrorType[ErrorType["Api"] = 4] = "Api";
+    ErrorType[ErrorType["Other"] = 5] = "Other";
 })(ErrorType || (ErrorType = {}));

package/dist/definitions/Module.d.ts

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

package/dist/definitions/Module.js

@@ -11,6 +11,7 @@ export class Module {
     commands;
     events = new Map();
     models = [];
+    static requeriments;
     commandManager;
     constructor(path, parameters) {
         this.path = path;

package/dist/modules/core/baseModule/events/discord/MessageCreate.d.ts

@@ -1,4 +1,3 @@
-import { ActionRowBuilder, EmbedBuilder } from 'discord.js';
 import { EventParameters } from '../../../../../definitions/parameters/EventParameters.js';
 import { FrameworkEvent } from '../../../../../definitions/FrameworkEvent.js';
 import { MemberPermissionChecker } from '../../../../../services/utilities/MemberPermissionChecker.js';
@@ -13,12 +12,4 @@ export declare class MessageCreate extends FrameworkEvent {
     constructor();
     execute({ message, framework }: EventParameters): Promise<import("discord.js").Message<boolean>>;
     autocorrect(str: string, words: string[]): any;
-    getErrorEmbed(error: any, parse: any): {
-        embeds: EmbedBuilder[];
-        components: ActionRowBuilder<import("@discordjs/builders").AnyComponentBuilder>[];
-        allowedMentions: {
-            repliedUser: boolean;
-        };
-    };
-    parseError(error: any): any;
 }

package/dist/modules/core/baseModule/events/discord/MessageCreate.js

@@ -1,13 +1,13 @@
-import { ActionRowBuilder, ButtonBuilder, ButtonStyle, ChannelType, EmbedBuilder, PermissionsBitField, } from 'discord.js';
-import ErrorStackParser from 'error-stack-parser';
+import { PermissionsBitField, } from 'discord.js';
 import { FrameworkEvent } from '../../../../../definitions/FrameworkEvent.js';
 import leven from 'leven';
-import path from 'path';
 import { ServiceContainer } from '../../../../../services/ServiceContainer.js';
 import { CommandParser } from '../../../../../services/CommandParser.js';
 import { MemberPermissionChecker } from '../../../../../services/utilities/MemberPermissionChecker.js';
 import { ZumitoFramework } from '../../../../../ZumitoFramework.js';
 import { GuildDataGetter } from '../../../../../services/utilities/GuildDataGetter.js';
+import { ErrorHandler } from '../../../../../services/handlers/ErrorHandler.js';
+import { ErrorType } from '../../../../../definitions/ErrorType.js';
 export class MessageCreate extends FrameworkEvent {
     once = false;
     source = 'discord';
@@ -114,6 +114,15 @@ export class MessageCreate extends FrameworkEvent {
                             return framework.translations.get('command.' + commandInstance.name + '.' + key, guildSettings.lang, params);
                         }
                     },
+                }).catch((error) => {
+                    const errorHandler = ServiceContainer.getService(ErrorHandler);
+                    errorHandler.handleError(error, {
+                        command: commandInstance,
+                        type: ErrorType.CommandRun,
+                    });
+                    message.reply({
+                        content: "An error ocurred while running this command.",
+                    });
                 });
                 if (!message.channel.isDMBased && !message.deletable) {
                     return; // TODO: test if this works
@@ -129,21 +138,14 @@ export class MessageCreate extends FrameworkEvent {
                 }
             }
             catch (error) {
-                const content = await this.getErrorEmbed({
-                    name: error.name,
-                    message: error.message,
+                const errorHandler = ServiceContainer.getService(ErrorHandler);
+                errorHandler.handleError(error, {
                     command: commandInstance,
-                    args: args,
-                    stack: error.stack,
-                }, true);
-                try {
-                    message.reply(content);
-                }
-                catch (e) {
-                    if (channel.type !== ChannelType.GuildStageVoice) {
-                        channel.send(content);
-                    }
-                }
+                    type: ErrorType.CommandRun,
+                });
+                message.reply({
+                    content: "An error ocurred while running this command.",
+                });
             }
         }
     }
@@ -164,106 +166,4 @@ export class MessageCreate extends FrameworkEvent {
         }
         return bestWord;
     }
-    getErrorEmbed(error, parse) {
-        let parsedError;
-        if (parse) {
-            parsedError = this.parseError(error);
-        }
-        else {
-            parsedError = error;
-        }
-        const embed = new EmbedBuilder()
-            .setTitle('Error')
-            .setDescription('An error has occured while executing this command.')
-            .setTimestamp()
-            .addFields([
-            {
-                name: 'Command:',
-                value: error.command.name || 'Not defined',
-            },
-        ])
-            .addFields([
-            {
-                name: 'Arguments:',
-                value: error.args.toString() || 'None',
-            },
-        ])
-            .addFields([
-            {
-                name: 'Error name:',
-                value: error.name || 'Not defined',
-            },
-        ])
-            .addFields([
-            {
-                name: 'Error message:',
-                value: error.message || 'Not defined',
-            },
-        ]);
-        if (error.possibleSolutions !== undefined) {
-            error.possibleSolutions.forEach((solution) => {
-                embed.addFields([
-                    {
-                        name: 'Posible solution:',
-                        value: solution,
-                    },
-                ]);
-            });
-        }
-        const stackFrames = ErrorStackParser.parse(error).filter((e) => !e.fileName.includes('node_modules') &&
-            !e.fileName.includes('node:internal'));
-        let stack = '';
-        const path1 = path.resolve('./');
-        const path2 = path1.replaceAll('\\', '/');
-        stackFrames.forEach((frame) => {
-            stack += `[${frame.fileName
-                .replace(path1, '')
-                .replace(path2, '')
-                .replace('file://', '')}:${frame.lineNumber}](https://zumito.ga/redirect?url=vscode://file/${frame.fileName.replace('file://', '')}:${frame.lineNumber}) ${frame.functionName}()\n`;
-        });
-        if (error.stack !== undefined) {
-            embed.addFields([
-                {
-                    name: 'Call stack:',
-                    value: stack || error.stack || error.stack.toString(),
-                },
-            ]);
-        }
-        if (error.details !== undefined) {
-            error.details.forEach((detail) => {
-                embed.addFields([
-                    {
-                        name: 'Detail:',
-                        value: detail,
-                    },
-                ]);
-            });
-        }
-        const body = `\n\n\n---\nComand:\`\`\`${error.command.name || 'not defined'}\`\`\`\nArguments:\`\`\`${error.args.toString() || 'none'}\`\`\`\nError:\`\`\`${error.name || 'not defined'}\`\`\`\nError message:\`\`\`${error.message || 'not defined'}\`\`\`\n`;
-        const requestUrl = `https://github.com/ZumitoTeam/Zumito/issues/new?body=${encodeURIComponent(body)}`;
-        const row = new ActionRowBuilder().addComponents(new ButtonBuilder()
-            .setStyle(ButtonStyle.Link)
-            .setLabel('Report error')
-            .setEmoji('975645505302437978')
-            .setURL(requestUrl));
-        return {
-            embeds: [embed],
-            components: [row],
-            allowedMentions: {
-                repliedUser: false,
-            },
-        };
-    }
-    parseError(error) {
-        error.possibleSolutions = [];
-        if (/(?:^|(?<= ))(EmbedBuilder|Discord|ActionRowBuilder|ButtonBuilder|MessageSelectMenu)(?:(?= )|$) is not defined/gm.test(error.message)) {
-            error.possibleSolutions.push('const { ' +
-                error.message.split(' ')[0] +
-                " } = require('discord.js');");
-        }
-        else if (error.message.includes('A custom id and url cannot both be specified')) {
-            error.possibleSolutions.push('Remove .setCustomId(...) or .setURL(...)');
-        }
-        return error;
-    }
 }

package/dist/services/ServiceContainer.d.ts

@@ -4,6 +4,7 @@ declare class ServiceContainerManager {
     getService<T>(serviceClass: new (...args: any[]) => T | string): T;
     getServiceByName<T>(serviceName: string): T;
     addInstance(serviceClass: any, instance: any): void;
+    hasService(serviceClass: any): boolean;
 }
 export declare const ServiceContainer: ServiceContainerManager;
 export {};

package/dist/services/ServiceContainer.js

@@ -39,6 +39,10 @@ class ServiceContainerManager {
             return;
         this.services.get(serviceName).instance = instance;
     }
+    hasService(serviceClass) {
+        const serviceName = typeof serviceClass == 'string' ? serviceClass : serviceClass.name;
+        return this.services.has(serviceName);
+    }
 }
 if (!global.ServiceContainer)
     global.ServiceContainer = new ServiceContainerManager();

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

@@ -9,10 +9,19 @@ declare type CommandErrorOptions = BaseErrorOptions & {
     type: ErrorType.CommandInstance | ErrorType.CommandLoad | ErrorType.CommandRun;
     command: Command;
 };
+declare type ApiErrorOptions = BaseErrorOptions & {
+    type: ErrorType.Api;
+    endpoint: string;
+    method: string;
+};
+declare type OtherErrorOptions = BaseErrorOptions & {
+    type: ErrorType.Other;
+};
+declare type ErrorOptions = CommandErrorOptions | ApiErrorOptions | OtherErrorOptions;
 export declare class ErrorHandler {
     framework: ZumitoFramework;
     constructor(framework: ZumitoFramework);
-    handleError(error: any, options: BaseErrorOptions | CommandErrorOptions): void;
+    handleError(error: any, options: ErrorOptions): void;
     handleCommandError(error: Error, options: CommandErrorOptions): void;
     handleShapeShiftErrors(error: any): void;
     printErrorStack(error: Error): void;

package/dist/services/handlers/ErrorHandler.js

@@ -22,6 +22,13 @@ export class ErrorHandler {
             console.error(`Validation error: ${error.validator} received invalid input: ${error.given}`);
             console.line('');
         }
+        else if (options?.type == ErrorType.Api) {
+            console.group(`[❌] Error in API endpoint ${options.endpoint} (${options.method})`);
+            console.line(chalk.red('Error:'));
+            console.line(error.toString());
+            console.line('');
+            console.groupEnd();
+        }
         else {
             console.error(error.toString());
             console.line('');

package/dist/services/handlers/InteractionHandler.js

@@ -197,13 +197,27 @@ export class InteractionHandler {
             if (!guildSettings && interaction.guildId) {
                 guildSettings = await ServiceContainer.getService(GuildDataGetter).getGuildSettings(interaction.guildId);
             }
-            commandInstance.modalSubmit({
-                client: this.client,
-                path,
-                interaction,
-                framework,
-                guildSettings,
-            });
+            const trans = this.translationManager.getShortHandMethod('command.' + commandInstance.name, guildSettings?.lang);
+            if (commandInstance.binds?.modalSubmit) {
+                commandInstance.binds?.modalSubmit({
+                    path,
+                    interaction,
+                    client: this.client,
+                    framework,
+                    guildSettings,
+                    trans,
+                });
+            }
+            else if ( // Deprecated
+            commandInstance.constructor.prototype.hasOwnProperty('modalSubmit')) {
+                commandInstance.modalSubmit({
+                    client: this.client,
+                    path,
+                    interaction,
+                    framework,
+                    guildSettings,
+                });
+            }
         }
         this.eventManager.emitEvent('modalSubmit', 'framework', {
             client: this.client,

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

@@ -3,6 +3,12 @@ import { Module } from "../../definitions/Module.js";
 import { ModuleParameters } from "../../definitions/parameters/ModuleParameters.js";
 export declare class ModuleManager {
     protected modules: Map<string, Module>;
+    protected pendingInstancePool: Array<{
+        module: any;
+        rootPath: string;
+        name?: string;
+        options?: ModuleParameters;
+    }>;
     protected framework: ZumitoFramework;
     constructor(framework: ZumitoFramework);
     set(name: string, module: Module): void;
@@ -14,5 +20,24 @@ export declare class ModuleManager {
     get size(): number;
     loadModuleFile(folderPath: string): Promise<unknown>;
     registerModule(module: InstanceType<typeof Module>): void;
-    instanceModule(module: any, rootPath: string, name?: string, options?: ModuleParameters): Promise<Module>;
+    instanceModule(module: any, rootPath: string, name?: string, options?: ModuleParameters): Promise<Module | {
+        modules: string[];
+        services: string[];
+        custom: boolean;
+    }>;
+    /**
+     * Comprueba si los requisitos de un módulo están satisfechos antes de instanciarlo.
+     * Retorna un array con los requisitos incumplidos.
+     * @param moduleClass Clase del módulo (no instancia)
+     */
+    checkModuleRequeriments(moduleClass: typeof Module): Promise<{
+        modules: string[];
+        services: string[];
+        custom: boolean;
+    }>;
+    /**
+     * Intenta inicializar todos los módulos pendientes en la pool, iterando hasta que no queden o no se pueda avanzar más.
+     * Evita bucles infinitos si ningún módulo puede ser inicializado en una iteración.
+     */
+    initializePendingModules(): Promise<void>;
 }

package/dist/services/managers/ModuleManager.js

@@ -1,8 +1,10 @@
 import { Module } from "../../definitions/Module.js";
 import fs from 'fs';
 import path from 'path';
+import { ServiceContainer } from "../ServiceContainer.js";
 export class ModuleManager {
     modules;
+    pendingInstancePool = [];
     framework;
     constructor(framework) {
         this.modules = new Map();
@@ -58,6 +60,15 @@ export class ModuleManager {
         */
     }
     async instanceModule(module, rootPath, name, options) {
+        // Comprobar requerimientos del módulo
+        const unmeetRequeriments = await this.checkModuleRequeriments(module);
+        // If there are failed requeriments, put the class into a pool for later retry
+        if (unmeetRequeriments.modules.length > 0 || unmeetRequeriments.services.length > 0 || unmeetRequeriments.custom === false) {
+            this.pendingInstancePool.push({
+                module, rootPath, name, options
+            });
+            return unmeetRequeriments;
+        }
         let moduleInstance;
         if (module.constructor) {
             try {
@@ -73,6 +84,76 @@ export class ModuleManager {
         else {
             //moduleInstance = new Module();
         }
+        this.registerModule(moduleInstance);
         return moduleInstance;
     }
+    /**
+     * Comprueba si los requisitos de un módulo están satisfechos antes de instanciarlo.
+     * Retorna un array con los requisitos incumplidos.
+     * @param moduleClass Clase del módulo (no instancia)
+     */
+    async checkModuleRequeriments(moduleClass) {
+        const requeriments = moduleClass.requeriments;
+        const failed = {
+            modules: [],
+            services: [],
+            custom: true
+        };
+        if (!requeriments) {
+            // Si no hay requerimientos definidos, se considera válido
+            return failed;
+        }
+        // Comprobar módulos requeridos
+        if (requeriments.modules && requeriments.modules.length > 0) {
+            for (const mod of requeriments.modules) {
+                if (!this.modules.get(mod))
+                    failed.modules.push(mod);
+            }
+        }
+        // Comprobar servicios requeridos
+        if (requeriments.services && requeriments.services.length > 0) {
+            for (const service of requeriments.services) {
+                if (!ServiceContainer.hasService(service))
+                    failed.services.push(service);
+            }
+        }
+        // Solo probar custom si los anteriores se cumplieron
+        if (failed.services.length === 0 && failed.modules.length == 0 && requeriments.custom && requeriments.custom.length > 0) {
+            for (const custom of requeriments.custom) {
+                if (!(await custom()))
+                    failed.custom = false;
+            }
+        }
+        return failed;
+    }
+    /**
+     * Intenta inicializar todos los módulos pendientes en la pool, iterando hasta que no queden o no se pueda avanzar más.
+     * Evita bucles infinitos si ningún módulo puede ser inicializado en una iteración.
+     */
+    async initializePendingModules() {
+        let initializedInLastIteration;
+        do {
+            initializedInLastIteration = 0;
+            // Copia actual de la pool para iterar
+            const poolCopy = [...this.pendingInstancePool];
+            this.pendingInstancePool = [];
+            for (const pending of poolCopy) {
+                const result = await this.instanceModule(pending.module, pending.rootPath, pending.name, pending.options);
+                // Si no se pudo inicializar, vuelve a ponerlo en la pool
+                if (typeof result !== 'object' || result instanceof Module) {
+                    initializedInLastIteration++;
+                }
+                else {
+                    this.pendingInstancePool.push(pending);
+                }
+            }
+        } while (this.pendingInstancePool.length > 0 && initializedInLastIteration > 0);
+        // Si quedan módulos en la pool, no se pudieron inicializar por dependencias incumplidas
+        if (this.pendingInstancePool.length > 0) {
+            console.warn(`[📦⚠️] No se pudieron inicializar los siguientes módulos por requerimientos incumplidos:`);
+            for (const pending of this.pendingInstancePool) {
+                console.warn(`- ${pending.name || pending.module.name}`);
+            }
+        }
+    }
 }

package/package.json

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