zumito-framework 1.21.0 → 1.22.0

package/dist/ZumitoFramework.d.ts

@@ -10,6 +10,7 @@ import { ModuleManager } from './services/managers/ModuleManager.js';
 import { Route } from './definitions/Route.js';
 import { Db } from 'mongodb';
 import { MongoService } from './services/MongoService.js';
+import { DatabaseManager } from 'zumito-db';
 /**
  * @class ZumitoFramework
  * @description The main class of the framework.
@@ -70,15 +71,20 @@ export declare class ZumitoFramework {
     /**
      * The MongoDB service instance.
      * @type {MongoService}
-     * @private
+     * @deprecated Use `framework.db` (DatabaseManager from zumito-db) instead.
      */
     mongoService: MongoService;
     /**
      * The MongoDB database instance (shortcut).
      * @type {Db}
-     * @private
+     * @deprecated Use `framework.db.getRepository(Model).find(...)` instead.
      */
     database: Db;
+    /**
+     * The new zumito-db DatabaseManager instance.
+     * @type {DatabaseManager}
+     */
+    db: DatabaseManager;
     /**
      * The ExpressJS app instance.
      * @type {express.Application}
@@ -162,7 +168,7 @@ export declare class ZumitoFramework {
      *
      * @deprecated
      */
-    getGuildSettings(guildId: string): Promise<import("mongodb").WithId<import("bson").Document>>;
+    getGuildSettings(guildId: string): Promise<any>;
     /**
      * @deprecated
      */

package/dist/ZumitoFramework.js

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import * as url from 'url';
-import { Client, } from 'discord.js';
+import { Client, Events, } from 'discord.js';
 import { ApiResponse } from './definitions/api/ApiResponse.js';
 import { EventEmitter } from "tseep";
 import { StatusManager } from './services/managers/StatusManager.js';
@@ -23,6 +23,7 @@ import { ErrorHandler } from './services/handlers/ErrorHandler.js';
 import { ErrorType } from './definitions/ErrorType.js';
 import { MongoService } from './services/MongoService.js';
 import { registerDefaultExecutionRules } from './modules/core/baseModule/defaultRules.js';
+import { DatabaseManager } from 'zumito-db';
 // import better-logging
 betterLogging(console);
 /**
@@ -85,15 +86,20 @@ export class ZumitoFramework {
     /**
      * The MongoDB service instance.
      * @type {MongoService}
-     * @private
+     * @deprecated Use `framework.db` (DatabaseManager from zumito-db) instead.
      */
     mongoService;
     /**
      * The MongoDB database instance (shortcut).
      * @type {Db}
-     * @private
+     * @deprecated Use `framework.db.getRepository(Model).find(...)` instead.
      */
     database;
+    /**
+     * The new zumito-db DatabaseManager instance.
+     * @type {DatabaseManager}
+     */
+    db;
     /**
      * The ExpressJS app instance.
      * @type {express.Application}
@@ -140,6 +146,7 @@ export class ZumitoFramework {
         ServiceContainer.addService(TranslationManager, [], true, this.translations);
         ServiceContainer.addService(CommandManager, [], true, this.commands);
         ServiceContainer.addService(EventManager, [], true, this.eventManager);
+        ServiceContainer.addService(SlashCommandRefresher, [], true, new SlashCommandRefresher(this));
         if (settings.logLevel) {
             console.logLevel = settings.logLevel;
         }
@@ -167,6 +174,8 @@ export class ZumitoFramework {
         this.eventManager.addEventEmitter('framework', this.eventEmitter);
         await this.registerModules();
         registerDefaultExecutionRules();
+        // Ensure all model schemas (from config + module auto-load) are created
+        await this.db.ensureSchemas();
         await this.refreshSlashCommands();
         this.startApiServer();
         if (this.settings.statusOptions) {
@@ -179,23 +188,54 @@ export class ZumitoFramework {
     }
     async initializeDatabase() {
         const mongoUri = this.settings?.mongoQueryString || process.env.MONGO_URI;
-        if (!mongoUri) {
-            console.error('[🗄️🔴] MongoDB connection string not provided.');
+        const dbSettings = this.settings.database;
+        let config;
+        if (dbSettings?.default) {
+            config = {
+                default: dbSettings.default,
+                drivers: dbSettings.drivers || {},
+            };
+        }
+        else if (mongoUri) {
+            const match = mongoUri.match(/\/([^/?]+)(\?|$)/);
+            const dbName = match ? match[1] : 'zumito';
+            config = {
+                default: 'mongo',
+                drivers: { mongo: { uri: mongoUri, database: dbName } },
+            };
+        }
+        else {
+            console.error('[🗄️🔴] No database configured.');
+            console.error('  Set database.default in zumito.config.ts (memory, tingo, mongo, sqlite)');
+            console.error('  or set MONGO_URI / mongoQueryString for MongoDB.');
             process.exit(1);
         }
-        // Extract dbName from URI or fallback
-        const match = mongoUri.match(/\/([^/?]+)(\?|$)/);
-        const dbName = match ? match[1] : 'zumito';
-        this.mongoService = new MongoService(mongoUri, dbName);
+        if (this.settings.models) {
+            config.models = this.settings.models;
+        }
+        this.db = new DatabaseManager();
         try {
-            await this.mongoService.connect();
-            this.database = this.mongoService.db;
-            console.log('[🗄️🟢] MongoDB connection successful!');
+            await this.db.connect(config);
+            ServiceContainer.addService(DatabaseManager, [], true, this.db);
+            console.log(`[🗄️🟢] Database connected (driver: ${config.default})`);
         }
         catch (err) {
-            console.error('[🗄️🔴] MongoDB connection error:', err.message);
+            console.error(`[🗄️🔴] Database connection error: ${err.message}`);
             process.exit(1);
         }
+        // Backward compat: only set up mongoService for mongo driver
+        if (config.default === 'mongo' && mongoUri) {
+            const driver = this.db.getDriver();
+            this.database = driver.raw;
+            const dbName = config.drivers.mongo?.database || 'zumito';
+            this.mongoService = new MongoService(mongoUri, dbName);
+            this.mongoService.db = this.database;
+            this.mongoService.client = driver.client;
+        }
+        // Apply migrations if configured
+        if (this.settings.database?.migrations && this.settings.database.migrations.length > 0) {
+            await this.db.migrator.latest(this.settings.database.migrations);
+        }
     }
     /**
      * Initializes and starts the API server using ExpressJS.
@@ -306,7 +346,6 @@ export class ZumitoFramework {
         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);
         await this.modules.instanceModule(bundle, bundlePath, bundleName, bundleOptions);
@@ -323,7 +362,7 @@ export class ZumitoFramework {
         this.client.login(this.settings.discordClientOptions.token);
         ServiceContainer.addService(Client, [], true, this.client);
         await new Promise((resolve) => {
-            this.client.on('ready', () => {
+            this.client.on(Events.ClientReady, () => {
                 // Bot emoji
                 console.log('[🤖🟢] Discord client ready');
                 resolve();

package/dist/definitions/Module.d.ts

@@ -1,7 +1,6 @@
 import { ZumitoFramework } from '../ZumitoFramework.js';
 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 = {
@@ -13,10 +12,8 @@ export declare abstract class Module {
     protected path: string;
     protected parameters: ModuleParameters;
     protected framework: ZumitoFramework;
-    protected commands: CommandManager;
     protected events: Map<string, FrameworkEvent>;
     static requeriments: ModuleRequeriments;
-    protected commandManager: CommandManager;
     protected errorHandler: ErrorHandler;
     constructor(path: any, parameters?: ModuleParameters);
     initialize(): Promise<void>;
@@ -29,6 +26,7 @@ export declare abstract class Module {
     parseEventArgs(args: any[]): any;
     getEvents(): Map<string, FrameworkEvent>;
     registerTranslations(subpath?: string): Promise<void>;
+    registerModels(): Promise<void>;
     registerRoutes(): Promise<void>;
     registerRoutesFolder(folder: string): Promise<void>;
 }

package/dist/definitions/Module.js

@@ -2,24 +2,21 @@ import { ZumitoFramework } from '../ZumitoFramework.js';
 import * as fs from 'fs';
 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';
+import { getModelMetadata } from 'zumito-db';
 export class Module {
     path;
     parameters;
     framework;
-    commands;
     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() {
@@ -27,26 +24,21 @@ export class Module {
         await this.registerEvents();
         await this.registerTranslations();
         await this.registerRoutes();
+        await this.registerModels();
     }
     async onAllReady() {
     }
     async registerCommands() {
         const commandsFolder = path.join(this.path, 'commands');
         if (fs.existsSync(commandsFolder)) {
-            await this.commands.loadCommandsFolder(commandsFolder);
-            // register watcher
+            await this.framework.commands.loadCommandsFolder(commandsFolder);
             if (process.env.DEBUG) {
-                /*
-                    Debug only cause in prod environment commands should't be changed.
-                    Appart from that, esm module cache invalidation is not working properly
-                    and can cause memory leaks and crashes.
-                */
-                this.commands.watchCommandsFolder(commandsFolder);
+                this.framework.commands.watchCommandsFolder(commandsFolder);
             }
         }
     }
     getCommands() {
-        return this.commands.getAll();
+        return this.framework.commands.getAll();
     }
     async registerEvents() {
         if (!fs.existsSync(path.join(this.path, 'events')))
@@ -55,7 +47,6 @@ export class Module {
         for (const file of files) {
             // if file is folder
             if (fs.lstatSync(path.join(this.path, 'events', file)).isDirectory()) {
-                console.log('registering events folder ' + file);
                 this.registerEventsFolder(file);
             }
         }
@@ -115,6 +106,35 @@ export class Module {
             return;
         this.framework.translations.registerTranslationsFromFolder(path.join(this.path, 'translations', subpath), '', process.env.DEBUG ? true : false);
     }
+    async registerModels() {
+        const modelsFolder = path.join(this.path, 'models');
+        if (!fs.existsSync(modelsFolder))
+            return;
+        const db = this.framework.db;
+        if (!db)
+            return;
+        const files = fs.readdirSync(modelsFolder);
+        for (const file of files) {
+            if (file.endsWith('.d.ts'))
+                continue;
+            if (file.endsWith('.js') || file.endsWith('.ts')) {
+                const mod = await import('file://' + path.join(modelsFolder, file)).catch((e) => {
+                    this.errorHandler.handleError(e, {
+                        type: ErrorType.ModuleLoad,
+                        moduleName: this.constructor.name,
+                    });
+                });
+                if (!mod)
+                    continue;
+                // Register every exported class that has @Collection metadata
+                for (const exportValue of Object.values(mod)) {
+                    if (typeof exportValue === 'function' && getModelMetadata(exportValue)) {
+                        db.registerModel(exportValue);
+                    }
+                }
+            }
+        }
+    }
     async registerRoutes() {
         const folderPath = path.join(this.path, 'routes');
         if (fs.existsSync(folderPath)) {

package/dist/definitions/settings/FrameworkSettings.d.ts

@@ -1,7 +1,8 @@
 import { ModuleParameters } from "../parameters/ModuleParameters";
 import { StatusManagerOptions } from "../StatusManagerOptions";
+import type { DatabaseConfig } from 'zumito-db';
 export interface FrameworkSettings {
-    mongoQueryString: string;
+    mongoQueryString?: string;
     logLevel?: number;
     debug?: boolean;
     discordClientOptions: {
@@ -25,4 +26,15 @@ export interface FrameworkSettings {
         port?: number;
         disableNotFoundHandler?: boolean;
     };
+    /**
+     * New database configuration for zumito-db.
+     * If omitted, falls back to `mongoQueryString` with MongoDB driver.
+     */
+    database?: Partial<DatabaseConfig> & {
+        migrations?: any[];
+    };
+    /**
+     * Model classes to register with zumito-db.
+     */
+    models?: any[];
 }

package/dist/index.d.ts

@@ -32,10 +32,14 @@ import { ErrorType } from './definitions/ErrorType.js';
 import { InviteUrlGenerator } from './services/utilities/InviteUrlGenerator.js';
 import { PrefixResolver } from './services/utilities/PrefixResolver.js';
 import { CommandExecutionChecker } from './services/CommandExecutionChecker.js';
+import { DatabaseManager } from 'zumito-db';
+export { Collection, Field, HasMany, BelongsTo, HasOne, Migration, Repository, QueryBuilder } from 'zumito-db';
+export type { CollectionOptions, FieldOptions, HasManyOptions, BelongsToOptions, HasOneOptions } from 'zumito-db';
+export type { FieldType, Operator, WhereClause, SortClause, QueryIR, FieldMetadata, RelationMetadata, ModelMetadata, DriverConfig, DatabaseConfig, DatabaseDriver } from 'zumito-db';
 export type { CommandExecutionRule, CommandExecutionContext, CommandExecutionCheck, CommandExecutionType } from './definitions/CommandExecutionRule.js';
 export { ModalSubmitParameters } from './definitions/parameters/ModalSubmitParameters.js';
 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, };
+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, };

package/dist/index.js

@@ -25,6 +25,8 @@ import { ErrorType } from './definitions/ErrorType.js';
 import { InviteUrlGenerator } from './services/utilities/InviteUrlGenerator.js';
 import { PrefixResolver } from './services/utilities/PrefixResolver.js';
 import { CommandExecutionChecker } from './services/CommandExecutionChecker.js';
+import { DatabaseManager } from 'zumito-db';
+export { Collection, Field, HasMany, BelongsTo, HasOne, Migration, Repository, QueryBuilder } from 'zumito-db';
 export { Injectable } from './definitions/decorators/Injectable.decorator.js';
 ServiceContainer.addService(TextFormatter, []);
 ServiceContainer.addService(EmojiFallback, [discord.Client.name, TranslationManager.name]);
@@ -37,4 +39,4 @@ ServiceContainer.addService(InviteUrlGenerator, []);
 ServiceContainer.addService(PrefixResolver, []);
 ServiceContainer.addService(CommandExecutionChecker, [], true);
 ServiceContainer.addService(ErrorHandler, ['ZumitoFramework']);
-export { ZumitoFramework, Command, Module, CommandArguments, FrameworkEvent, Translation, TranslationManager, ApiResponse, CommandType, ButtonPressed, TextFormatter, EmojiFallback, DatabaseConfigLoader, discord, ServiceContainer, GuildDataGetter, SlashCommandRefresher, CommandParser, ErrorHandler, ErrorType, Route, RouteMethod, InteractionHandler, CommandManager, InviteUrlGenerator, PrefixResolver, CommandExecutionChecker, };
+export { ZumitoFramework, Command, Module, CommandArguments, FrameworkEvent, Translation, TranslationManager, ApiResponse, CommandType, ButtonPressed, TextFormatter, EmojiFallback, DatabaseConfigLoader, discord, ServiceContainer, GuildDataGetter, SlashCommandRefresher, CommandParser, ErrorHandler, ErrorType, Route, RouteMethod, InteractionHandler, CommandManager, InviteUrlGenerator, PrefixResolver, CommandExecutionChecker, DatabaseManager, };

package/dist/launcher.js

@@ -12,7 +12,6 @@ dotenv.config();
 const REQUIRED_ENV_VARS = {
     DISCORD_TOKEN: 'Discord Bot Token',
     DISCORD_CLIENT_ID: 'Discord Client ID',
-    MONGO_URI: 'MongoDB connection URI',
 };
 EnvValidator.validate(REQUIRED_ENV_VARS);
 const defaultConfig = {
@@ -22,7 +21,6 @@ const defaultConfig = {
         clientId: process.env.DISCORD_CLIENT_ID,
     },
     defaultPrefix: process.env.BOT_PREFIX || "z-",
-    mongoQueryString: process.env.MONGO_URI,
     logLevel: parseInt(process.env.LOGLEVEL || "3"),
 };
 const configFilePath = path.join(process.cwd(), 'zumito.config.ts');

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

@@ -7,6 +7,7 @@ export declare class CommandManager {
     protected commands: Map<string, Command>;
     protected framework: ZumitoFramework;
     protected errorHandler: ErrorHandler;
+    private importCounters;
     constructor(framework: any);
     set(name: string, command: Command): void;
     get(name: string): Command;
@@ -22,7 +23,7 @@ export declare class CommandManager {
      * @param filePath - Absolute path to command file
      * @returns {Promise<Command>}
      */
-    loadCommandFile(filePath: string): Promise<any>;
+    loadCommandFile(filePath: string, silent?: boolean): Promise<any>;
     /**
      * Load all command files from a folder
      * @async
@@ -40,5 +41,4 @@ export declare class CommandManager {
      * @returns {Promise<Map<string, Command>>}
      */
     watchCommandsFolder(folderPath: string): void;
-    refreshSlashCommands(): Promise<void>;
 }

package/dist/services/managers/CommandManager.js

@@ -1,18 +1,16 @@
 import chalk from "chalk";
-import * as chokidar from 'chokidar';
 import path from "path";
-import boxen from "boxen";
 import fs from 'fs';
-import { REST, Routes, SlashCommandBuilder } from "discord.js";
-import { CommandType } from "../../definitions/commands/CommandType.js";
 import { ErrorHandler } from "../handlers/ErrorHandler";
 import { ServiceContainer } from "../ServiceContainer";
 import { ErrorType } from "../../definitions/ErrorType";
+import { FileWatcher } from "../utilities/FileWatcher.js";
 import 'reflect-metadata';
 export class CommandManager {
     commands;
     framework;
     errorHandler;
+    importCounters = new Map();
     constructor(framework) {
         this.commands = new Map;
         this.errorHandler = ServiceContainer.getService(ErrorHandler);
@@ -40,15 +38,15 @@ export class CommandManager {
      * @param filePath - Absolute path to command file
      * @returns {Promise<Command>}
      */
-    async loadCommandFile(filePath) {
-        let loaded = false;
-        // Validate file has .ts or .js extension
+    async loadCommandFile(filePath, silent = false) {
         if (!filePath.endsWith('.js') && !filePath.endsWith('.ts')) {
-            throw new Error("File must be a .ts or .js");
+            return;
         }
-        // import file
-        let command = await import('file://' + filePath + '?update=' + Date.now().toString()).catch(e => {
-            console.error('[🆕🔴 ] Error loading command ' + chalk.blue(filePath.toString().replace(/^.*[\\\/]/, '').split('.').slice(0, -1).join('.')));
+        const counter = (this.importCounters.get(filePath) || 0) + 1;
+        this.importCounters.set(filePath, counter);
+        const baseName = path.basename(filePath).split('.').slice(0, -1).join('.');
+        let command = await import('file://' + filePath + '?v=' + counter).catch(e => {
+            console.error('[🆕🔴 ] Error loading command ' + chalk.blue(baseName));
             console.log(e + '\n' + e.name + '\n' + e.stack);
         });
         if (!command)
@@ -56,9 +54,12 @@ export class CommandManager {
         command = Object.values(command)[0];
         try {
             command = new command();
-            this.framework.commands.set(command.constructor.name.toLowerCase(), command);
-            console.debug('[🆕🟢 ] Command ' + chalk.blue(filePath.toString().replace(/^.*[\\\/]/, '').split('.').slice(0, -1).join('.')) + ' loaded');
-            loaded = true;
+            const commandName = command.constructor.name.toLowerCase();
+            this.commands.set(commandName, command);
+            if (!silent) {
+                console.debug('[🆕🟢 ] Command ' + chalk.blue(baseName) + ' loaded');
+            }
+            return command;
         }
         catch (error) {
             this.errorHandler.handleError(error, {
@@ -66,8 +67,6 @@ export class CommandManager {
                 command: command,
             });
         }
-        if (loaded)
-            return command;
     }
     /**
      * Load all command files from a folder
@@ -82,7 +81,7 @@ export class CommandManager {
             if (file.endsWith('.d.ts'))
                 continue;
             if (file.endsWith('.js') || file.endsWith('.ts')) {
-                const command = await this.loadCommandFile(path.join(folderPath, file));
+                const command = await this.loadCommandFile(path.join(folderPath, file), true);
                 if (command) {
                     const commandName = command.constructor.name.toLowerCase();
                     if (options?.blacklist && options.blacklist.includes(commandName))
@@ -104,87 +103,20 @@ export class CommandManager {
      * @returns {Promise<Map<string, Command>>}
      */
     watchCommandsFolder(folderPath) {
-        chokidar
-            .watch(path.resolve(folderPath), {
-            ignored: /^\./,
-            persistent: true,
-            ignoreInitial: true,
-        })
-            .on('add', (filePath) => {
-            this.loadCommandFile(filePath);
-        })
-            .on('change', (filePath) => {
-            this.loadCommandFile(filePath);
-        })
-            .on('error', (error) => {
-            console.error('[🔄🔴 ] Error reloading command');
-            console.log(boxen(error + '\n' + error.stack, { padding: 1 }));
-        });
-        // TODO: Handle file removal
-        //.on('unlink', function(path) {console.log('File', path, 'has been removed');})
-    }
-    async refreshSlashCommands() {
-        const rest = new REST({ version: '10' }).setToken(this.framework.settings.discordClientOptions.token);
-        const commands = Array.from(this.commands.values())
-            .filter((command) => (command.type == CommandType.slash ||
-            command.type == CommandType.separated ||
-            command.type == CommandType.any) &&
-            !command.parent)
-            .map((command) => {
-            const slashCommand = new SlashCommandBuilder()
-                .setName(command.name)
-                .setDescription(this.framework.translations.get('command.' + command.name + '.description', 'en'));
-            if (command.args) {
-                command.args.forEach((arg) => {
-                    let method;
-                    switch (arg.type) {
-                        case 'string':
-                            method = 'addStringOption';
-                            break;
-                        case 'number':
-                            method = 'addNumberOption';
-                            break;
-                        case 'user':
-                        case 'member':
-                            method = 'addUserOption';
-                            break;
-                        case 'channel':
-                            method = 'addChannelOption';
-                            break;
-                        case 'role':
-                            method = 'addRoleOption';
-                            break;
-                        default:
-                            throw new Error(`Invalid argument type ${arg.type} in command ${command.name} for argument ${arg.name}`);
-                    }
-                    slashCommand[method]((option) => {
-                        option.setName(arg.name);
-                        option.setDescription(this.framework.translations.get('command.' +
-                            command.name +
-                            '.args.' +
-                            arg.name +
-                            '.description', 'en'));
-                        option.setRequired(!arg.optional);
-                        if (arg.choices) {
-                            // if arg.choices is function, call it
-                            if (typeof arg.choices == 'function') {
-                                arg.choices =
-                                    arg.choices();
-                            }
-                            arg.choices.forEach((choice) => {
-                                option.addChoices({
-                                    name: choice.name,
-                                    value: choice.value,
-                                });
-                            });
-                        }
-                        return option;
-                    });
-                });
-            }
-            return slashCommand.toJSON();
-        });
-        const data = await rest.put(Routes.applicationCommands(this.framework.settings.discordClientOptions.clientId), { body: commands });
-        console.debug(`Successfully reloaded ${data.length} of ${commands.length} application (/) commands.`);
+        new FileWatcher().watch(folderPath, {
+            onAdd: (filePath) => {
+                this.loadCommandFile(filePath);
+            },
+            onChange: (filePath) => {
+                this.loadCommandFile(filePath);
+            },
+            onUnlink: (filePath) => {
+                const fileName = path.basename(filePath).split('.').slice(0, -1).join('.');
+                const commandName = fileName.toLowerCase();
+                this.commands.delete(commandName);
+                this.importCounters.delete(filePath);
+                console.debug('[🔄🟡] Command ' + chalk.blue(fileName) + ' removed');
+            },
+        }, 'command');
     }
 }

package/dist/services/managers/ModuleManager.js

@@ -49,21 +49,8 @@ export class ModuleManager {
         return moduleClass || exports[0];
     }
     registerModule(module) {
-        // Register module commands
-        if (module.getCommands()) {
-            module.getCommands().forEach((command) => {
-                this.framework.commands.set(command.name, command);
-            });
-        }
         // Register module events
         this.framework.events = new Map([...this.framework.events, ...module.getEvents()]);
-        // Register models (eliminado, migración a MongoDB)
-        /*
-
-        // Register module routes
-        this.routes = new Map([...this.routes, ...moduleInstance.getRoutes()]);
-
-        */
     }
     async instanceModule(module, rootPath, name, options) {
         // Comprobar requerimientos del módulo

package/dist/services/managers/TranslationManager.js

@@ -1,9 +1,8 @@
 import { Translation } from '../../definitions/Translation.js';
 import fs from 'fs';
 import path from 'path';
-import * as chokidar from 'chokidar';
-import boxen from 'boxen';
 import chalk from "chalk";
+import { FileWatcher } from '../utilities/FileWatcher.js';
 export class TranslationManager {
     translations = new Map();
     defaultLanguage = 'en';
@@ -94,30 +93,23 @@ export class TranslationManager {
         }
     }
     watchTranslationFolder(folderPath, baseKey) {
-        chokidar
-            .watch(path.resolve(folderPath), {
-            ignored: /^\./,
-            persistent: true,
-            ignoreInitial: true,
-        })
-            .on('add', async (filePath) => {
-            const json = await this.loadTranslationFile(filePath);
-            const lang = filePath.replace(/^.*[\\/]/, '').slice(0, -5);
-            this.importTranslationsJson(baseKey, lang, json);
-            console.debug('[🆕🟢 ] Translations file ' + chalk.blue(filePath) + ' loaded');
-        })
-            .on('change', async (filePath) => {
-            const json = await this.loadTranslationFile(filePath);
-            const lang = filePath.replace(/^.*[\\/]/, '').slice(0, -5);
-            this.importTranslationsJson(baseKey, lang, json);
-            console.debug('[🆕🟢 ] Translations file ' + chalk.blue(filePath) + ' loaded');
-        })
-            .on('error', (error) => {
-            console.error('[🔄🔴 ] Error reloading translation file');
-            console.log(boxen(error + '\n' + error.stack, { padding: 1 }));
-        });
-        // TODO: Handle file removal
-        //.on('unlink', function(path) {console.log('File', path, 'has been removed');})
+        new FileWatcher().watch(folderPath, {
+            onAdd: async (filePath) => {
+                const json = await this.loadTranslationFile(filePath);
+                const lang = filePath.replace(/^.*[\\/]/, '').slice(0, -5);
+                this.importTranslationsJson(baseKey, lang, json);
+                console.debug('[🆕🟢 ] Translations file ' + chalk.blue(filePath) + ' loaded');
+            },
+            onChange: async (filePath) => {
+                const json = await this.loadTranslationFile(filePath);
+                const lang = filePath.replace(/^.*[\\/]/, '').slice(0, -5);
+                this.importTranslationsJson(baseKey, lang, json);
+                console.debug('[🆕🟢 ] Translations file ' + chalk.blue(filePath) + ' loaded');
+            },
+            onUnlink: (filePath) => {
+                console.debug('[🔄🟡] Translations file ' + chalk.blue(filePath) + ' removed');
+            },
+        }, 'translation');
     }
     getShortHandMethod(keyPrefix, language) {
         return (key, params, lang) => {

package/dist/services/utilities/EnvValidator.js

@@ -23,7 +23,8 @@ export class EnvValidator {
         const divider = chalk.yellow('━'.repeat(54));
         const envPath = path.join(process.cwd(), '.env');
         const hasEnvFile = fs.existsSync(envPath);
-        console.error(`\n${divider}`);
+        console.error('');
+        console.error(divider);
         console.error(`  ${chalk.bold.red('CONFIGURATION ERROR')} — Missing environment variables`);
         console.error(divider);
         for (const key of present) {
@@ -44,7 +45,8 @@ export class EnvValidator {
         else {
             console.error(`  ${chalk.dim('.env file found but missing required variables.')}`);
         }
-        console.error(divider + '\n');
+        console.error(divider);
+        console.error('');
         process.exit(1);
     }
 }

package/dist/services/utilities/FileWatcher.d.ts

@@ -0,0 +1,10 @@
+import * as chokidar from 'chokidar';
+export type FileWatcherCallbacks = {
+    onAdd?: (filePath: string) => void | Promise<void>;
+    onChange?: (filePath: string) => void | Promise<void>;
+    onUnlink?: (filePath: string) => void | Promise<void>;
+    onError?: (error: Error) => void;
+};
+export declare class FileWatcher {
+    watch(folderPath: string, callbacks: FileWatcherCallbacks, label?: string): chokidar.FSWatcher;
+}

package/dist/services/utilities/FileWatcher.js

@@ -0,0 +1,32 @@
+import * as chokidar from 'chokidar';
+import path from 'path';
+import boxen from 'boxen';
+export class FileWatcher {
+    watch(folderPath, callbacks, label = 'file') {
+        const watcher = chokidar
+            .watch(path.resolve(folderPath), {
+            ignored: /^\./,
+            persistent: true,
+            ignoreInitial: true,
+        })
+            .on('add', (filePath) => {
+            callbacks.onAdd?.(filePath);
+        })
+            .on('change', (filePath) => {
+            callbacks.onChange?.(filePath);
+        })
+            .on('unlink', (filePath) => {
+            callbacks.onUnlink?.(filePath);
+        })
+            .on('error', (error) => {
+            if (callbacks.onError) {
+                callbacks.onError(error);
+            }
+            else {
+                console.error(`[🔄🔴 ] Error watching ${label}`);
+                console.log(boxen(error + '\n' + error.stack, { padding: 1 }));
+            }
+        });
+        return watcher;
+    }
+}

package/dist/services/utilities/GuildDataGetter.d.ts

@@ -25,5 +25,5 @@ export declare class GuildDataGetter {
      * // returns the guild settings
      * getGuildSettings(interaction.guildId);
      */
-    getGuildSettings(guildId: string): Promise<import("mongodb").WithId<import("bson").Document>>;
+    getGuildSettings(guildId: string): Promise<any>;
 }

package/dist/services/utilities/GuildDataGetter.js

@@ -1,4 +1,6 @@
+import { ServiceContainer } from "../ServiceContainer";
 import { ObjectId } from "mongodb";
+import { DatabaseManager } from 'zumito-db';
 export class GuildDataGetter {
     framework;
     constructor(framework) {
@@ -28,6 +30,30 @@ export class GuildDataGetter {
      * getGuildSettings(interaction.guildId);
      */
     async getGuildSettings(guildId) {
+        // Use new zumito-db DatabaseManager if available
+        const db = ServiceContainer.getService(DatabaseManager);
+        if (db) {
+            const driver = db.getDriver();
+            const results = await driver.find('guilds', {
+                collection: 'guilds',
+                type: 'findOne',
+                where: [{ field: 'guild_id', operator: 'eq', value: guildId, logic: 'and' }],
+            });
+            let guild = results && results.length > 0 ? results[0] : null;
+            if (!guild) {
+                guild = {
+                    guild_id: guildId,
+                    lang: 'en',
+                    prefix: null,
+                    public: false,
+                    deleteCommands: false
+                };
+                await driver.insert('guilds', guild);
+            }
+            return guild;
+        }
+        // Fallback to deprecated raw MongoDB access
+        console.warn('[🗄️⚠️] GuildDataGetter is using deprecated raw MongoDB access. Please update to zumito-db.');
         const collection = this.framework.database.collection('guilds');
         let guild = await collection.findOne({ guild_id: guildId });
         if (!guild) {

package/dist/testing/createTestFramework.d.ts

@@ -27,4 +27,5 @@ export declare function createTestFramework(overrides?: Record<string, any>): {
         options: {};
     };
     eventEmitter: EventEmitter<import("tseep").DefaultEventMap>;
+    db: any;
 };

package/dist/testing/createTestFramework.js

@@ -6,6 +6,51 @@ export function createTestFramework(overrides = {}) {
     ServiceContainer.services.clear();
     const mockClient = createMockClient(overrides.client);
     const eventEmitter = new EventEmitter();
+    const mockDb = {
+        getDriver: vi.fn().mockReturnValue({
+            find: vi.fn().mockResolvedValue([]),
+            findOne: vi.fn().mockResolvedValue(null),
+            insert: vi.fn().mockResolvedValue({}),
+            update: vi.fn().mockResolvedValue(0),
+            delete: vi.fn().mockResolvedValue(0),
+            count: vi.fn().mockResolvedValue(0),
+            ensureSchema: vi.fn().mockResolvedValue(undefined),
+            dropCollection: vi.fn().mockResolvedValue(undefined),
+            raw: {},
+            disconnect: vi.fn().mockResolvedValue(undefined),
+        }),
+        getRepository: vi.fn().mockReturnValue({
+            find: vi.fn().mockResolvedValue([]),
+            findOne: vi.fn().mockResolvedValue(null),
+            insert: vi.fn().mockResolvedValue({}),
+            update: vi.fn().mockResolvedValue(0),
+            delete: vi.fn().mockResolvedValue(0),
+            count: vi.fn().mockResolvedValue(0),
+            query: vi.fn().mockReturnValue({
+                where: vi.fn().mockReturnThis(),
+                andWhere: vi.fn().mockReturnThis(),
+                orWhere: vi.fn().mockReturnThis(),
+                select: vi.fn().mockReturnThis(),
+                sort: vi.fn().mockReturnThis(),
+                limit: vi.fn().mockReturnThis(),
+                offset: vi.fn().mockReturnThis(),
+                exec: vi.fn().mockResolvedValue([]),
+                first: vi.fn().mockResolvedValue(null),
+                count: vi.fn().mockResolvedValue(0),
+            }),
+            collection: 'test',
+        }),
+        registerModel: vi.fn(),
+        ensureSchemas: vi.fn().mockResolvedValue(undefined),
+        connect: vi.fn().mockResolvedValue(undefined),
+        disconnect: vi.fn().mockResolvedValue(undefined),
+        migrator: {
+            latest: vi.fn().mockResolvedValue([]),
+            rollback: vi.fn().mockResolvedValue([]),
+            status: vi.fn().mockResolvedValue([]),
+        },
+        ...overrides.db,
+    };
     const mockFramework = {
         client: mockClient,
         commands: {
@@ -39,10 +84,13 @@ export function createTestFramework(overrides = {}) {
             getAll: vi.fn().mockReturnValue(new Map()),
             size: 0,
         },
+        db: mockDb,
         ...overrides.framework,
     };
     ServiceContainer.addService(class ZumitoFramework {
     }, [], true, mockFramework);
+    ServiceContainer.addService(class DatabaseManager {
+    }, [], true, mockDb);
     class MockErrorHandler {
         handleError = vi.fn();
     }
@@ -52,5 +100,6 @@ export function createTestFramework(overrides = {}) {
         framework: mockFramework,
         client: mockClient,
         eventEmitter,
+        db: mockDb,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zumito-framework",
-  "version": "1.21.0",
+  "version": "1.22.0",
   "description": "Discord.js bot framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,12 +37,12 @@
     "error-stack-parser": "^2.1.4",
     "express": "^4.18.1",
     "leven": "^4.0.0",
-    "mongoose": "^6.6.5",
+    "mongodb": "^6.3.0",
     "reflect-metadata": "^0.2.2",
     "source-fragment": "^1.1.0",
     "tingodb": "^0.6.1",
     "tseep": "^1.2.2",
-    "zumito-db": "1.0.1"
+    "zumito-db": "^2.0.3"
   },
   "devDependencies": {
     "@types/node": "^18.19.44",