zumito-framework 1.22.1 → 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/dist/testing/createTestFramework.d.ts

@@ -3,18 +3,18 @@ export declare function createTestFramework(overrides?: Record<string, any>): {
     framework: any;
     client: {
         _listeners: Record<string, ((...args: any[]) => void)[]>;
-        on: import("vitest").Mock<[event: string, cb: (...args: any[]) => void], void>;
-        once: import("vitest").Mock<[event: string, cb: (...args: any[]) => void], void>;
-        emit: import("vitest").Mock<[event: string, ...args: any[]], void>;
-        login: import("vitest").Mock<any, any>;
-        destroy: import("vitest").Mock<any, any>;
+        on: import("vitest").Mock<(event: string, cb: (...args: any[]) => void) => void>;
+        once: import("vitest").Mock<(event: string, cb: (...args: any[]) => void) => void>;
+        emit: import("vitest").Mock<(event: string, ...args: any[]) => void>;
+        login: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        destroy: import("vitest").Mock<import("@vitest/spy").Procedure>;
         guilds: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         channels: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         user: {
             id: string;
@@ -22,7 +22,7 @@ export declare function createTestFramework(overrides?: Record<string, any>): {
             username: string;
         };
         users: {
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         options: {};
     };

package/dist/testing/mocks/discord.d.ts

@@ -1,17 +1,17 @@
 export declare function createMockClient(overrides?: Record<string, any>): {
     _listeners: Record<string, ((...args: any[]) => void)[]>;
-    on: import("vitest").Mock<[event: string, cb: (...args: any[]) => void], void>;
-    once: import("vitest").Mock<[event: string, cb: (...args: any[]) => void], void>;
-    emit: import("vitest").Mock<[event: string, ...args: any[]], void>;
-    login: import("vitest").Mock<any, any>;
-    destroy: import("vitest").Mock<any, any>;
+    on: import("vitest").Mock<(event: string, cb: (...args: any[]) => void) => void>;
+    once: import("vitest").Mock<(event: string, cb: (...args: any[]) => void) => void>;
+    emit: import("vitest").Mock<(event: string, ...args: any[]) => void>;
+    login: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    destroy: import("vitest").Mock<import("@vitest/spy").Procedure>;
     guilds: {
         cache: Map<any, any>;
-        fetch: import("vitest").Mock<any, any>;
+        fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
     };
     channels: {
         cache: Map<any, any>;
-        fetch: import("vitest").Mock<any, any>;
+        fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
     };
     user: {
         id: string;
@@ -19,7 +19,7 @@ export declare function createMockClient(overrides?: Record<string, any>): {
         username: string;
     };
     users: {
-        fetch: import("vitest").Mock<any, any>;
+        fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
     };
     options: {};
 };
@@ -29,11 +29,11 @@ export declare function createMockGuild(overrides?: Record<string, any>): {
     ownerId: string;
     channels: {
         cache: Map<any, any>;
-        fetch: import("vitest").Mock<any, any>;
+        fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
     };
     members: {
         cache: Map<any, any>;
-        fetch: import("vitest").Mock<any, any>;
+        fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
     };
     roles: {
         cache: Map<any, any>;
@@ -49,21 +49,21 @@ export declare function createMockTextChannel(overrides?: Record<string, any>):
         ownerId: string;
         channels: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         members: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         roles: {
             cache: Map<any, any>;
         };
     };
-    isTextBased: import("vitest").Mock<any, any>;
-    isDMBased: import("vitest").Mock<any, any>;
+    isTextBased: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    isDMBased: import("vitest").Mock<import("@vitest/spy").Procedure>;
     nsfw: boolean;
-    send: import("vitest").Mock<any, any>;
-    permissionsFor: import("vitest").Mock<any, any>;
+    send: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    permissionsFor: import("vitest").Mock<import("@vitest/spy").Procedure>;
 };
 export declare function createMockGuildMember(overrides?: Record<string, any>): {
     id: string;
@@ -77,18 +77,18 @@ export declare function createMockGuildMember(overrides?: Record<string, any>):
         ownerId: string;
         channels: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         members: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         roles: {
             cache: Map<any, any>;
         };
     };
     permissions: {
-        has: import("vitest").Mock<any, any>;
+        has: import("vitest").Mock<import("@vitest/spy").Procedure>;
     };
     roles: {
         cache: Map<any, any>;
@@ -109,18 +109,18 @@ export declare function createMockMessage(overrides?: Record<string, any>): {
             ownerId: string;
             channels: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             members: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             roles: {
                 cache: Map<any, any>;
             };
         };
         permissions: {
-            has: import("vitest").Mock<any, any>;
+            has: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         roles: {
             cache: Map<any, any>;
@@ -136,21 +136,21 @@ export declare function createMockMessage(overrides?: Record<string, any>): {
             ownerId: string;
             channels: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             members: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             roles: {
                 cache: Map<any, any>;
             };
         };
-        isTextBased: import("vitest").Mock<any, any>;
-        isDMBased: import("vitest").Mock<any, any>;
+        isTextBased: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        isDMBased: import("vitest").Mock<import("@vitest/spy").Procedure>;
         nsfw: boolean;
-        send: import("vitest").Mock<any, any>;
-        permissionsFor: import("vitest").Mock<any, any>;
+        send: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        permissionsFor: import("vitest").Mock<import("@vitest/spy").Procedure>;
     };
     guild: {
         id: string;
@@ -158,11 +158,11 @@ export declare function createMockMessage(overrides?: Record<string, any>): {
         ownerId: string;
         channels: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         members: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         roles: {
             cache: Map<any, any>;
@@ -181,26 +181,26 @@ export declare function createMockMessage(overrides?: Record<string, any>): {
             ownerId: string;
             channels: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             members: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             roles: {
                 cache: Map<any, any>;
             };
         };
         permissions: {
-            has: import("vitest").Mock<any, any>;
+            has: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         roles: {
             cache: Map<any, any>;
         };
     };
-    reply: import("vitest").Mock<any, any>;
-    delete: import("vitest").Mock<any, any>;
-    react: import("vitest").Mock<any, any>;
+    reply: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    delete: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    react: import("vitest").Mock<import("@vitest/spy").Procedure>;
     editable: boolean;
     deletable: boolean;
 };
@@ -213,11 +213,11 @@ export declare function createMockCommandInteraction(overrides?: Record<string,
         ownerId: string;
         channels: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         members: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         roles: {
             cache: Map<any, any>;
@@ -234,21 +234,21 @@ export declare function createMockCommandInteraction(overrides?: Record<string,
             ownerId: string;
             channels: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             members: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             roles: {
                 cache: Map<any, any>;
             };
         };
-        isTextBased: import("vitest").Mock<any, any>;
-        isDMBased: import("vitest").Mock<any, any>;
+        isTextBased: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        isDMBased: import("vitest").Mock<import("@vitest/spy").Procedure>;
         nsfw: boolean;
-        send: import("vitest").Mock<any, any>;
-        permissionsFor: import("vitest").Mock<any, any>;
+        send: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        permissionsFor: import("vitest").Mock<import("@vitest/spy").Procedure>;
     };
     member: {
         id: string;
@@ -262,18 +262,18 @@ export declare function createMockCommandInteraction(overrides?: Record<string,
             ownerId: string;
             channels: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             members: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             roles: {
                 cache: Map<any, any>;
             };
         };
         permissions: {
-            has: import("vitest").Mock<any, any>;
+            has: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         roles: {
             cache: Map<any, any>;
@@ -283,19 +283,19 @@ export declare function createMockCommandInteraction(overrides?: Record<string,
         id: string;
         username: string;
     };
-    reply: import("vitest").Mock<any, any>;
-    deferReply: import("vitest").Mock<any, any>;
-    editReply: import("vitest").Mock<any, any>;
-    followUp: import("vitest").Mock<any, any>;
+    reply: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    deferReply: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    editReply: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    followUp: import("vitest").Mock<import("@vitest/spy").Procedure>;
     options: {
-        get: import("vitest").Mock<any, any>;
-        getString: import("vitest").Mock<any, any>;
-        getInteger: import("vitest").Mock<any, any>;
-        getBoolean: import("vitest").Mock<any, any>;
-        getUser: import("vitest").Mock<any, any>;
-        getChannel: import("vitest").Mock<any, any>;
-        getRole: import("vitest").Mock<any, any>;
-        getSubcommand: import("vitest").Mock<any, any>;
+        get: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        getString: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        getInteger: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        getBoolean: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        getUser: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        getChannel: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        getRole: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        getSubcommand: import("vitest").Mock<import("@vitest/spy").Procedure>;
     };
 };
 export declare function createMockButtonInteraction(overrides?: Record<string, any>): {
@@ -307,11 +307,11 @@ export declare function createMockButtonInteraction(overrides?: Record<string, a
         ownerId: string;
         channels: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         members: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         roles: {
             cache: Map<any, any>;
@@ -328,21 +328,21 @@ export declare function createMockButtonInteraction(overrides?: Record<string, a
             ownerId: string;
             channels: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             members: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             roles: {
                 cache: Map<any, any>;
             };
         };
-        isTextBased: import("vitest").Mock<any, any>;
-        isDMBased: import("vitest").Mock<any, any>;
+        isTextBased: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        isDMBased: import("vitest").Mock<import("@vitest/spy").Procedure>;
         nsfw: boolean;
-        send: import("vitest").Mock<any, any>;
-        permissionsFor: import("vitest").Mock<any, any>;
+        send: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        permissionsFor: import("vitest").Mock<import("@vitest/spy").Procedure>;
     };
     member: {
         id: string;
@@ -356,18 +356,18 @@ export declare function createMockButtonInteraction(overrides?: Record<string, a
             ownerId: string;
             channels: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             members: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             roles: {
                 cache: Map<any, any>;
             };
         };
         permissions: {
-            has: import("vitest").Mock<any, any>;
+            has: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         roles: {
             cache: Map<any, any>;
@@ -377,10 +377,10 @@ export declare function createMockButtonInteraction(overrides?: Record<string, a
         id: string;
         username: string;
     };
-    reply: import("vitest").Mock<any, any>;
-    deferReply: import("vitest").Mock<any, any>;
-    deferUpdate: import("vitest").Mock<any, any>;
-    update: import("vitest").Mock<any, any>;
+    reply: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    deferReply: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    deferUpdate: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    update: import("vitest").Mock<import("@vitest/spy").Procedure>;
 };
 export declare function createMockStringSelectMenuInteraction(overrides?: Record<string, any>): {
     id: string;
@@ -392,11 +392,11 @@ export declare function createMockStringSelectMenuInteraction(overrides?: Record
         ownerId: string;
         channels: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         members: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         roles: {
             cache: Map<any, any>;
@@ -413,21 +413,21 @@ export declare function createMockStringSelectMenuInteraction(overrides?: Record
             ownerId: string;
             channels: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             members: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             roles: {
                 cache: Map<any, any>;
             };
         };
-        isTextBased: import("vitest").Mock<any, any>;
-        isDMBased: import("vitest").Mock<any, any>;
+        isTextBased: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        isDMBased: import("vitest").Mock<import("@vitest/spy").Procedure>;
         nsfw: boolean;
-        send: import("vitest").Mock<any, any>;
-        permissionsFor: import("vitest").Mock<any, any>;
+        send: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        permissionsFor: import("vitest").Mock<import("@vitest/spy").Procedure>;
     };
     member: {
         id: string;
@@ -441,18 +441,18 @@ export declare function createMockStringSelectMenuInteraction(overrides?: Record
             ownerId: string;
             channels: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             members: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             roles: {
                 cache: Map<any, any>;
             };
         };
         permissions: {
-            has: import("vitest").Mock<any, any>;
+            has: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         roles: {
             cache: Map<any, any>;
@@ -462,17 +462,17 @@ export declare function createMockStringSelectMenuInteraction(overrides?: Record
         id: string;
         username: string;
     };
-    reply: import("vitest").Mock<any, any>;
-    deferReply: import("vitest").Mock<any, any>;
-    deferUpdate: import("vitest").Mock<any, any>;
-    update: import("vitest").Mock<any, any>;
+    reply: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    deferReply: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    deferUpdate: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    update: import("vitest").Mock<import("@vitest/spy").Procedure>;
 };
 export declare function createMockModalSubmitInteraction(overrides?: Record<string, any>): {
     id: string;
     customId: string;
     fields: {
-        getTextInputValue: import("vitest").Mock<any, any>;
-        getField: import("vitest").Mock<any, any>;
+        getTextInputValue: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        getField: import("vitest").Mock<import("@vitest/spy").Procedure>;
         fields: any[];
     };
     guild: {
@@ -481,11 +481,11 @@ export declare function createMockModalSubmitInteraction(overrides?: Record<stri
         ownerId: string;
         channels: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         members: {
             cache: Map<any, any>;
-            fetch: import("vitest").Mock<any, any>;
+            fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         roles: {
             cache: Map<any, any>;
@@ -502,21 +502,21 @@ export declare function createMockModalSubmitInteraction(overrides?: Record<stri
             ownerId: string;
             channels: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             members: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             roles: {
                 cache: Map<any, any>;
             };
         };
-        isTextBased: import("vitest").Mock<any, any>;
-        isDMBased: import("vitest").Mock<any, any>;
+        isTextBased: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        isDMBased: import("vitest").Mock<import("@vitest/spy").Procedure>;
         nsfw: boolean;
-        send: import("vitest").Mock<any, any>;
-        permissionsFor: import("vitest").Mock<any, any>;
+        send: import("vitest").Mock<import("@vitest/spy").Procedure>;
+        permissionsFor: import("vitest").Mock<import("@vitest/spy").Procedure>;
     };
     member: {
         id: string;
@@ -530,18 +530,18 @@ export declare function createMockModalSubmitInteraction(overrides?: Record<stri
             ownerId: string;
             channels: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             members: {
                 cache: Map<any, any>;
-                fetch: import("vitest").Mock<any, any>;
+                fetch: import("vitest").Mock<import("@vitest/spy").Procedure>;
             };
             roles: {
                 cache: Map<any, any>;
             };
         };
         permissions: {
-            has: import("vitest").Mock<any, any>;
+            has: import("vitest").Mock<import("@vitest/spy").Procedure>;
         };
         roles: {
             cache: Map<any, any>;
@@ -551,7 +551,7 @@ export declare function createMockModalSubmitInteraction(overrides?: Record<stri
         id: string;
         username: string;
     };
-    reply: import("vitest").Mock<any, any>;
-    deferReply: import("vitest").Mock<any, any>;
-    deferUpdate: import("vitest").Mock<any, any>;
+    reply: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    deferReply: import("vitest").Mock<import("@vitest/spy").Procedure>;
+    deferUpdate: import("vitest").Mock<import("@vitest/spy").Procedure>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zumito-framework",
-  "version": "1.22.1",
+  "version": "1.23.0",
   "description": "Discord.js bot framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,7 +23,7 @@
   "author": "ZumitoTeam",
   "license": "ISC",
   "dependencies": {
-    "@discordjs/rest": "^1.7.0",
+    "@discordjs/rest": "^2.6.1",
     "@types/express": "^4.17.13",
     "autocorrect": "^1.2.0",
     "better-logging": "^5.0.0",
@@ -45,17 +45,17 @@
     "zumito-db": "^2.0.3"
   },
   "devDependencies": {
-    "@types/node": "^18.19.44",
+    "@types/node": "^22.0.0",
     "@typescript-eslint/eslint-plugin": "^5.48.2",
     "@typescript-eslint/parser": "^5.48.2",
-    "@vitest/coverage-v8": "^1.6.1",
+    "@vitest/coverage-v8": "^4.1.9",
     "eslint": "^8.32.0",
     "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-check-file": "^2.2.0",
     "eslint-plugin-prettier": "^4.2.1",
     "prettier": "^2.8.3",
     "typescript": "^5.8.3",
-    "vitest": "^1.6.1"
+    "vitest": "^4.1.9"
   },
   "type": "module",
   "exports": {