zumito-framework 1.22.2 → 1.23.0

package/dist/ZumitoFramework.js

@@ -316,27 +316,44 @@ export class ZumitoFramework {
             modulesFolder = `${process.cwd()}/src/modules`;
         }
         const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+        const moduleEntries = [];
         if (this.settings.bundles && this.settings.bundles.length > 0) {
             for (const bundle of this.settings.bundles) {
-                await this.registerBundle(bundle.path, bundle.options);
+                moduleEntries.push({
+                    rootPath: bundle.path,
+                    options: bundle.options,
+                });
             }
         }
-        await this.registerModule(path.join(__dirname, 'modules', 'core'), 'baseModule');
+        moduleEntries.push({
+            rootPath: path.join(__dirname, 'modules', 'core'),
+            name: 'baseModule',
+        });
         if (fs.existsSync(`${process.cwd()}/node_modules/.zumitoBundles`)) {
             const files = fs.readdirSync(`${process.cwd()}/node_modules/.zumitoBundles`);
             for (const file of files) {
-                await this.registerModule(`${process.cwd()}/node_modules/.zumitoBundles`, file);
+                moduleEntries.push({
+                    rootPath: path.join(process.cwd(), 'node_modules', '.zumitoBundles', file),
+                    name: file,
+                });
             }
         }
         if (modulesFolder) {
             const files = fs.readdirSync(modulesFolder);
             for (const file of files) {
-                await this.registerModule(modulesFolder, file);
+                moduleEntries.push({
+                    rootPath: path.join(modulesFolder, file),
+                    name: file,
+                });
             }
         }
         else if (this.settings.srcMode == 'monoBundle') {
-            await this.registerModule(process.cwd(), 'src');
+            moduleEntries.push({
+                rootPath: path.join(process.cwd(), 'src'),
+                name: 'src',
+            });
         }
+        await this.modules.resolveAndInstantiateAll(moduleEntries);
     }
     async registerModule(modulesFolder, moduleName, module) {
         if (!module) {

package/dist/definitions/Module.d.ts

@@ -8,11 +8,22 @@ export type ModuleRequeriments = {
     services: Array<string>;
     custom: Array<() => Promise<boolean>>;
 };
+export type ModuleDeclaration = {
+    moduleClass: typeof Module;
+    name: string;
+    rootPath: string;
+    options?: ModuleParameters;
+    requiredDeps: string[];
+    optionalDeps: string[];
+};
 export declare abstract class Module {
     protected path: string;
     protected parameters: ModuleParameters;
     protected framework: ZumitoFramework;
     protected events: Map<string, FrameworkEvent>;
+    static moduleName?: string;
+    static dependencies?: readonly string[];
+    static optionalDependencies?: readonly string[];
     static requeriments: ModuleRequeriments;
     protected errorHandler: ErrorHandler;
     constructor(path: any, parameters?: ModuleParameters);

package/dist/definitions/Module.js

@@ -11,6 +11,9 @@ export class Module {
     parameters;
     framework;
     events = new Map();
+    static moduleName;
+    static dependencies;
+    static optionalDependencies;
     static requeriments;
     errorHandler;
     constructor(path, parameters) {

package/dist/index.d.ts

@@ -12,7 +12,7 @@ import { DatabaseConfigLoader } from './services/utilities/DatabaseConfigLoader.
 import { EmojiFallback } from './services/EmojiFallback.js';
 import { FrameworkEvent } from './definitions/FrameworkEvent.js';
 import { FrameworkSettings } from './definitions/FrameworkSettings.js';
-import { Module } from './definitions/Module.js';
+import { Module, ModuleDeclaration, ModuleRequeriments } from './definitions/Module.js';
 import { SelectMenuParameters } from './definitions/parameters/SelectMenuParameters.js';
 import { TextFormatter } from './services/utilities/TextFormatter.js';
 import { Translation } from './definitions/Translation.js';
@@ -42,4 +42,4 @@ export { CommandBinds } from './definitions/commands/CommandBinds.js';
 export { Injectable } from './definitions/decorators/Injectable.decorator.js';
 export { LauncherConfig } from './definitions/config/LauncherConfig.js';
 export { ModuleParameters } from './definitions/parameters/ModuleParameters.js';
-export { ZumitoFramework, FrameworkSettings, Command, Module, CommandParameters, CommandArguments, FrameworkEvent, Translation, TranslationManager, ApiResponse, SelectMenuParameters, CommandType, CommandArgDefinition, CommandChoiceDefinition, ButtonPressed, ButtonPressedParams, TextFormatter, EmojiFallback, DatabaseConfigLoader, PresenceDataRule, RuledPresenceData, StatusManagerOptions, discord, EventParameters, ServiceContainer, GuildDataGetter, SlashCommandRefresher, CommandParser, ErrorHandler, ErrorType, Route, RouteMethod, InteractionHandler, CommandManager, InviteUrlGenerator, PrefixResolver, CommandExecutionChecker, DatabaseManager, };
+export { ZumitoFramework, FrameworkSettings, Command, Module, ModuleDeclaration, ModuleRequeriments, CommandParameters, CommandArguments, FrameworkEvent, Translation, TranslationManager, ApiResponse, SelectMenuParameters, CommandType, CommandArgDefinition, CommandChoiceDefinition, ButtonPressed, ButtonPressedParams, TextFormatter, EmojiFallback, DatabaseConfigLoader, PresenceDataRule, RuledPresenceData, StatusManagerOptions, discord, EventParameters, ServiceContainer, GuildDataGetter, SlashCommandRefresher, CommandParser, ErrorHandler, ErrorType, Route, RouteMethod, InteractionHandler, CommandManager, InviteUrlGenerator, PrefixResolver, CommandExecutionChecker, DatabaseManager, };

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

@@ -76,6 +76,7 @@ export class MessageCreate extends FrameworkEvent {
                         allowedMentions: { repliedUser: false },
                     });
                 }
+                const startTime = Date.now();
                 await commandInstance.execute({
                     message,
                     args: parsedArgs,
@@ -90,7 +91,22 @@ export class MessageCreate extends FrameworkEvent {
                             return this.framework.translations.get('command.' + commandInstance.name + '.' + key, guildSettings.lang, params);
                         }
                     },
+                }).then(() => {
+                    this.framework.eventEmitter.emit('commandExecuted', {
+                        guildId: message.guildId,
+                        commandName: commandInstance.name,
+                        type: 'prefix',
+                        executionTimeMs: Date.now() - startTime,
+                        success: true,
+                    });
                 }).catch((error) => {
+                    this.framework.eventEmitter.emit('commandExecuted', {
+                        guildId: message.guildId,
+                        commandName: commandInstance.name,
+                        type: 'prefix',
+                        executionTimeMs: Date.now() - startTime,
+                        success: false,
+                    });
                     const errorHandler = ServiceContainer.getService(ErrorHandler);
                     errorHandler.handleError(error, {
                         command: commandInstance,

package/dist/services/handlers/InteractionHandler.js

@@ -112,31 +112,57 @@ export class InteractionHandler {
             return;
         }
         const trans = this.translationManager.getShortHandMethod('command.' + commandInstance.name, guildSettings?.lang);
+        const startTime = Date.now();
         if (commandInstance.type === CommandType.separated ||
             commandInstance.type === CommandType.slash) {
-            await commandInstance.executeSlashCommand({
-                client: this.client,
-                interaction, args, framework, guildSettings, trans,
-            });
-        }
-        else {
             try {
-                await commandInstance.execute({
+                await commandInstance.executeSlashCommand({
                     client: this.client,
                     interaction, args, framework, guildSettings, trans,
-                }).catch((error) => {
-                    this.errorHandler.handleError(error, {
-                        command: commandInstance,
-                        type: ErrorType.CommandRun,
-                        interaction,
-                    });
-                    interaction.reply({
-                        content: "An error ocurred while running this command.",
-                        ephemeral: true
-                    });
+                });
+                framework.eventEmitter.emit('commandExecuted', {
+                    guildId: interaction.guildId,
+                    commandName: commandInstance.name,
+                    type: 'slash',
+                    executionTimeMs: Date.now() - startTime,
+                    success: true,
                 });
             }
             catch (error) {
+                framework.eventEmitter.emit('commandExecuted', {
+                    guildId: interaction.guildId,
+                    commandName: commandInstance.name,
+                    type: 'slash',
+                    executionTimeMs: Date.now() - startTime,
+                    success: false,
+                });
+                this.errorHandler.handleError(error, {
+                    command: commandInstance,
+                    type: ErrorType.CommandRun,
+                    interaction,
+                });
+            }
+        }
+        else {
+            await commandInstance.execute({
+                client: this.client,
+                interaction, args, framework, guildSettings, trans,
+            }).then(() => {
+                framework.eventEmitter.emit('commandExecuted', {
+                    guildId: interaction.guildId,
+                    commandName: commandInstance.name,
+                    type: 'slash',
+                    executionTimeMs: Date.now() - startTime,
+                    success: true,
+                });
+            }).catch((error) => {
+                framework.eventEmitter.emit('commandExecuted', {
+                    guildId: interaction.guildId,
+                    commandName: commandInstance.name,
+                    type: 'slash',
+                    executionTimeMs: Date.now() - startTime,
+                    success: false,
+                });
                 this.errorHandler.handleError(error, {
                     command: commandInstance,
                     type: ErrorType.CommandRun,
@@ -144,9 +170,9 @@ export class InteractionHandler {
                 });
                 interaction.reply({
                     content: "An error ocurred while running this command.",
-                    ephemeral: true,
+                    ephemeral: true
                 });
-            }
+            });
         }
     }
     async handleButtonInteraction(interaction, guildSettings) {

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

@@ -1,5 +1,5 @@
 import { ZumitoFramework } from "../../ZumitoFramework.js";
-import { Module } from "../../definitions/Module.js";
+import { Module, ModuleDeclaration } from "../../definitions/Module.js";
 import { ErrorHandler } from "../handlers/ErrorHandler.js";
 import { ModuleParameters } from "../../definitions/parameters/ModuleParameters.js";
 export declare class ModuleManager {
@@ -20,7 +20,19 @@ export declare class ModuleManager {
      * @deprecated
      */
     get size(): number;
-    loadModuleFile(folderPath: string): Promise<unknown>;
+    resolveModuleName(moduleClass: typeof Module, fallbackName: string): string;
+    resolveModuleDeps(moduleClass: typeof Module): {
+        required: string[];
+        optional: string[];
+    };
+    buildDependencyGraph(declarations: ModuleDeclaration[]): Map<string, string[]>;
+    topologicalSort(declarations: ModuleDeclaration[]): ModuleDeclaration[];
+    resolveAndInstantiateAll(modulePaths: Array<{
+        rootPath: string;
+        options?: ModuleParameters;
+        name?: string;
+    }>): Promise<void>;
+    loadModuleFile(folderPath: string): Promise<typeof Module | undefined>;
     registerModule(module: InstanceType<typeof Module>): void;
     instanceModule(module: any, rootPath: string, name?: string, options?: ModuleParameters): Promise<Module | {
         modules: string[];

package/dist/services/managers/ModuleManager.js

@@ -30,6 +30,123 @@ export class ModuleManager {
     get size() {
         return this.modules.size;
     }
+    resolveModuleName(moduleClass, fallbackName) {
+        return moduleClass.moduleName || fallbackName;
+    }
+    resolveModuleDeps(moduleClass) {
+        const required = new Set();
+        const optional = new Set();
+        if (moduleClass.dependencies) {
+            for (const d of moduleClass.dependencies)
+                required.add(d);
+        }
+        if (moduleClass.optionalDependencies) {
+            for (const d of moduleClass.optionalDependencies)
+                optional.add(d);
+        }
+        if (moduleClass.requeriments?.modules) {
+            for (const m of moduleClass.requeriments.modules)
+                required.add(m);
+        }
+        return { required: [...required], optional: [...optional] };
+    }
+    buildDependencyGraph(declarations) {
+        const nameSet = new Set(declarations.map((d) => d.name));
+        const graph = new Map();
+        for (const decl of declarations) {
+            const deps = [...decl.requiredDeps];
+            for (const opt of decl.optionalDeps) {
+                if (nameSet.has(opt))
+                    deps.push(opt);
+            }
+            for (const dep of deps) {
+                if (!nameSet.has(dep)) {
+                    throw new Error(`Module "${decl.name}" depends on "${dep}" which was not found`);
+                }
+            }
+            graph.set(decl.name, deps);
+        }
+        return graph;
+    }
+    topologicalSort(declarations) {
+        const graph = this.buildDependencyGraph(declarations);
+        const inDegree = new Map();
+        const adjacency = new Map();
+        for (const decl of declarations) {
+            const name = decl.name;
+            if (!inDegree.has(name))
+                inDegree.set(name, 0);
+            if (!adjacency.has(name))
+                adjacency.set(name, []);
+        }
+        for (const [name, deps] of graph) {
+            for (const dep of deps) {
+                if (!adjacency.has(dep))
+                    adjacency.set(dep, []);
+                adjacency.get(dep).push(name);
+                inDegree.set(name, (inDegree.get(name) || 0) + 1);
+            }
+        }
+        const queue = [];
+        for (const [name, degree] of inDegree) {
+            if (degree === 0)
+                queue.push(name);
+        }
+        const sorted = [];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            sorted.push(current);
+            for (const neighbor of adjacency.get(current) || []) {
+                const newDegree = inDegree.get(neighbor) - 1;
+                inDegree.set(neighbor, newDegree);
+                if (newDegree === 0)
+                    queue.push(neighbor);
+            }
+        }
+        if (sorted.length < declarations.length) {
+            const unresolved = declarations
+                .filter((d) => !sorted.includes(d.name))
+                .map((d) => d.name);
+            throw new Error(`Circular dependency detected involving: ${unresolved.join(', ')}`);
+        }
+        const nameMap = new Map(declarations.map((d) => [d.name, d]));
+        return sorted.map((name) => nameMap.get(name));
+    }
+    async resolveAndInstantiateAll(modulePaths) {
+        const declarations = [];
+        for (const entry of modulePaths) {
+            const moduleClass = await this.loadModuleFile(entry.rootPath);
+            if (!moduleClass || moduleClass === Module)
+                continue;
+            const { required, optional } = this.resolveModuleDeps(moduleClass);
+            const name = this.resolveModuleName(moduleClass, entry.name || path.basename(entry.rootPath));
+            declarations.push({
+                moduleClass,
+                name,
+                rootPath: entry.rootPath,
+                options: entry.options,
+                requiredDeps: required,
+                optionalDeps: optional,
+            });
+        }
+        if (declarations.length === 0)
+            return;
+        let sorted;
+        try {
+            sorted = this.topologicalSort(declarations);
+        }
+        catch (err) {
+            console.error(`[📦❌] ${err.message}`);
+            return;
+        }
+        for (const decl of sorted) {
+            const result = await this.instanceModule(decl.moduleClass, decl.rootPath, decl.name, decl.options);
+            if (result instanceof Module) {
+                console.log(`[📦✅] Module "${decl.name}" loaded successfully`);
+            }
+        }
+        await this.initializePendingModules();
+    }
     async loadModuleFile(folderPath) {
         let file;
         if (fs.existsSync(path.join(folderPath, 'index.js'))) {
@@ -46,7 +163,7 @@ export class ModuleManager {
         const moduleClass = exports.find((candidate) => {
             return Object.getPrototypeOf(candidate).name === 'Module';
         });
-        return moduleClass || exports[0];
+        return (moduleClass || exports[0]);
     }
     registerModule(module) {
         // Register module events

package/package.json

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