@dbcube/cli 5.2.4 → 5.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbcube/cli",
-  "version": "5.2.4",
+  "version": "5.2.5",
   "main": "src/index.js",
   "scripts": {
     "dbcube": "node src/index.js"
@@ -28,11 +28,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@dbcube/schema-builder": "^5.2.4",
+    "@dbcube/schema-builder": "^5.2.5",
     "@inquirer/prompts": "^8.5.2",
     "alwait": "^1.0.0",
     "chalk": "4.1.2",
-    "dbcube": "^5.2.4",
+    "dbcube": "^5.2.5",
     "dotenv": "^17.4.2",
     "fs-extra": "^11.3.5",
     "glob": "^13.0.6",

package/src/commands/doctor.js

@@ -21,13 +21,14 @@ async function main() {
     if (major >= 16) ok(`Node.js ${process.versions.node}`);
     else { fail(`Node.js ${process.versions.node} — DBCube requires >= 16`); problems++; }
 
-    // 2. Config file
-    const configPath = path.join(process.cwd(), 'dbcube.config.js');
+    // 2. Config file (.js o .cjs — getConfigPath prefiere .cjs en proyectos ESM)
+    const configPath = ConfigFileUtils.getConfigPath();
+    const configName = path.basename(configPath);
     if (!fs.existsSync(configPath)) {
-        fail('dbcube.config.js not found — run: npx dbcube init');
+        fail(`${configName} not found — run: npx dbcube init`);
         problems++;
     } else {
-        ok('dbcube.config.js found');
+        ok(`${configName} found`);
     }
 
     // 3. Configured databases

package/src/commands/init.js

@@ -11,13 +11,14 @@ async function main() {
     const root = process.cwd();
     console.log(`\n💚 ${chalk.green('Initializing DBCube project...')}\n`);
 
-    // 1. dbcube.config.js
-    const configPath = path.join(root, 'dbcube.config.js');
+    // 1. dbcube.config.(js|cjs) — getConfigPath elige .cjs en proyectos ESM
+    const configPath = ConfigFileUtils.getConfigPath();
+    const configName = path.basename(configPath);
     if (fs.existsSync(configPath)) {
-        console.log(`  ${chalk.yellow('•')} dbcube.config.js already exists — skipped`);
+        console.log(`  ${chalk.yellow('•')} ${configName} already exists — skipped`);
     } else {
         ConfigFileUtils.crearArchivoConfig(configPath);
-        console.log(`  ${chalk.green('✓')} dbcube.config.js created`);
+        console.log(`  ${chalk.green('✓')} ${configName} created`);
     }
 
     // 2. dbcube/ directory

package/src/commands/run/database/create/addDatabaseConfig.js

@@ -21,8 +21,7 @@ async function addDatabaseConfiguration(databaseName = null, motor = null) {
             databaseName = await input({
                 message: 'Nombre de referencia a la base de datos:',
                 validate: (value) => {
-                    const rootPath = path.resolve(process.cwd());
-                    const configPath = path.join(rootPath, 'dbcube.config.js');
+                    const configPath = ConfigFileUtils.getConfigPath();
                     const getconfig = require(configPath);
                     const config = new Config();
                     getconfig(config);

package/src/utils/ConfigFileUtils.js

@@ -1,5 +1,22 @@
 const fs = require('fs');
 const path = require('path');
+const EnvLoader = require('./EnvLoader');
+
+/**
+ * Detecta si el proyecto está marcado como ESM ("type": "module" en
+ * package.json), lo que hace que dbcube.config.js (CommonJS) no se pueda
+ * cargar con require(). Devuelve true si es ESM.
+ */
+function projectIsESM() {
+    try {
+        const pkgPath = path.resolve(process.cwd(), 'package.json');
+        if (!fs.existsSync(pkgPath)) return false;
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        return pkg.type === 'module';
+    } catch {
+        return false;
+    }
+}
 
 /**
  * Clase para manejar operaciones sobre el archivo de configuración
@@ -10,10 +27,15 @@ class ConfigFileUtils {
      * @returns {string} - Ruta al archivo de configuración
      */
     static getConfigPath() {
-        // Usar la ruta raíz del proyecto
         const rootPath = path.resolve(process.cwd());
-        const configPath = path.join(rootPath, 'dbcube.config.js');
-        return configPath;
+        const cjsPath = path.join(rootPath, 'dbcube.config.cjs');
+        const jsPath = path.join(rootPath, 'dbcube.config.js');
+        // Si ya existe alguno, ese manda (preferimos .cjs).
+        if (fs.existsSync(cjsPath)) return cjsPath;
+        if (fs.existsSync(jsPath)) return jsPath;
+        // Si no existe ninguno (se va a crear): en proyectos ESM
+        // ("type": "module") debe ser .cjs para poder cargarse con require().
+        return projectIsESM() ? cjsPath : jsPath;
     }
 
     /**
@@ -21,19 +43,16 @@ class ConfigFileUtils {
      * @returns {Promise<Array<string>>} - Array con los nombres de las bases de datos
      */
     static async getConfiguredDatabases() {
-        try {
-            // Ruta al archivo de configuración
-            const configPath = this.getConfigPath();
-            
-            // Comprobar si el archivo existe
-            if (!fs.existsSync(configPath)) {
-                ConfigFileUtils.crearArchivoConfig(configPath);
-            }
-            
-            return this.loadDatabasesFromPath(configPath);
-        } catch (error) {
-            throw new Error('Error al obtener las bases de datos configuradas:', error);
+        // Sin try/catch que oculte el error: loadDatabasesFromPath ya lanza
+        // mensajes explícitos y accionables. (Antes, `new Error('msg', error)`
+        // descartaba el segundo argumento y se perdía la causa real.)
+        const configPath = this.getConfigPath();
+
+        if (!fs.existsSync(configPath)) {
+            ConfigFileUtils.crearArchivoConfig(configPath);
         }
+
+        return this.loadDatabasesFromPath(configPath);
     }
     
     /**
@@ -42,46 +61,91 @@ class ConfigFileUtils {
      * @returns {Array<string>} - Nombres de las bases de datos
      */
     static loadDatabasesFromPath(configPath) {
+        // Carga automática de .env (cargador propio de DBCube): el usuario no
+        // necesita instalar dotenv ni escribir require("dotenv") en su config.
+        EnvLoader.load();
+
+        let config;
         try {
             // Borrar la caché del módulo para asegurarnos de cargar la versión más reciente
             delete require.cache[require.resolve(configPath)];
-            
             // Cargar el archivo de configuración
-            const config = require(configPath);
-            
-            // Crear una instancia temporal de Config para obtener los datos
-            const tempConfig = {
-                databases: {},
-                data: {},
-                set: function(configData) {
-                    this.data = configData;
-                    if (configData.databases) {
-                        this.databases = configData.databases;
-                    }
-                },
-                getAllDatabases: function() {
-                    return this.databases;
+            config = require(configPath);
+        } catch (error) {
+            const missing = (error.message.match(/Cannot find module '([^']+)'/) || [])[1];
+            // ¿El módulo que no se encuentra es el PROPIO config? Entonces el
+            // problema es de carga (típicamente ESM). Si es OTRO módulo, es una
+            // dependencia del config que falta (p. ej. dotenv).
+            const missingIsConfig = missing && (configPath.includes(missing) || missing.includes('dbcube.config'));
+
+            // Caso 1: falta una dependencia que el config requiere.
+            if (error.code === 'MODULE_NOT_FOUND' && missing && !missingIsConfig) {
+                throw new Error(
+                    `dbcube.config.js requiere un módulo que no está instalado: "${missing}".\n` +
+                    `   Instálalo (p. ej. npm install ${missing}).\n` +
+                    `   Nota: DBCube ya carga el .env automáticamente — puedes quitar require("dotenv") de tu config.`
+                );
+            }
+            // Caso 2: proyecto ESM ("type": "module") → require() del config falla
+            // o el .js se interpreta como módulo ES y `module.exports` no aplica.
+            if (projectIsESM() || error.code === 'ERR_REQUIRE_ESM') {
+                throw new Error(
+                    `No se pudo cargar dbcube.config.js porque el proyecto está marcado como ESM ` +
+                    `("type": "module" en package.json), pero la configuración usa CommonJS (module.exports).\n` +
+                    `   Solución: renombra el archivo a "dbcube.config.cjs", o quita "type": "module" de package.json.`
+                );
+            }
+            // Cualquier otro error de carga: mostrarlo tal cual.
+            throw new Error(`No se pudo cargar la configuración desde ${configPath}:\n   ${error.message}`);
+        }
+
+        // Validar que la config exporte una función (firma esperada).
+        if (typeof config !== 'function') {
+            const hint = projectIsESM()
+                ? ` El proyecto es ESM ("type": "module"): renombra el archivo a "dbcube.config.cjs" o quita "type": "module".`
+                : ` Debe exportar una función: module.exports = function (config) { config.set({ databases: {...} }); }.`;
+            throw new Error(`dbcube.config.js no exporta una configuración válida.${hint}`);
+        }
+
+        // Crear una instancia temporal de Config para obtener los datos
+        const tempConfig = {
+            databases: {},
+            data: {},
+            set: function(configData) {
+                this.data = configData;
+                if (configData.databases) {
+                    this.databases = configData.databases;
                 }
-            };
-            
-            // Ejecutar la función de configuración
-            config(tempConfig);
-            
-            // Obtener los nombres de las bases de datos
-            const databaseNames = Object.keys(tempConfig.getAllDatabases());
-            const arrayDatabases = [];
-            for (const database of databaseNames) {
-                arrayDatabases.push({
-                    name: database,
-                    type: tempConfig.getAllDatabases()[database].type
-                });
+            },
+            getAllDatabases: function() {
+                return this.databases;
             }
-            return arrayDatabases;
+        };
+
+        // Ejecutar la función de configuración
+        try {
+            config(tempConfig);
         } catch (error) {
-            // Fallar claro: devolver una DB inventada ocultaría el problema
-            // y haría que los comandos operen contra una base inexistente
-            throw new Error(`No se pudo cargar la configuración desde ${configPath}: ${error.message}`);
+            throw new Error(`dbcube.config.js lanzó un error al evaluarse:\n   ${error.message}`);
+        }
+
+        const allDatabases = tempConfig.getAllDatabases();
+        if (!allDatabases || Object.keys(allDatabases).length === 0) {
+            throw new Error(
+                `dbcube.config.js no define ninguna base de datos.\n` +
+                `   Añade al menos una en config.set({ databases: { miBase: { type, config } } }).`
+            );
         }
+
+        const databaseNames = Object.keys(allDatabases);
+        const arrayDatabases = [];
+        for (const database of databaseNames) {
+            arrayDatabases.push({
+                name: database,
+                type: allDatabases[database].type
+            });
+        }
+        return arrayDatabases;
     }
 
     /**
@@ -271,15 +335,16 @@ class ConfigFileUtils {
      * @param {string} rutaDestino - Ruta completa donde se debe crear el archivo.
      */
     static crearArchivoConfig(rutaDestino) {
-        const contenido = `require('dotenv').config({ quiet: true });
-
-    module.exports = function (config) {
-        config.set({
-            databases: {
-            }
-        });  
-    };
-    `;
+        // DBCube carga el .env automáticamente, así que el template ya NO
+        // necesita require('dotenv') (que además requeriría instalar el paquete).
+        const contenido = `// DBCube carga .env automáticamente — usa process.env.MI_VAR sin dotenv.
+module.exports = function (config) {
+    config.set({
+        databases: {
+        }
+    });
+};
+`;
 
         // Asegurarse de que el directorio existe
         const dir = path.dirname(rutaDestino);

package/src/utils/EnvLoader.js

@@ -0,0 +1,94 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Cargador de variables de entorno propio de DBCube.
+ *
+ * Evita que el usuario tenga que instalar `dotenv` y escribir
+ * `require("dotenv").config()` al inicio de su dbcube.config.js. DBCube carga
+ * el `.env` del proyecto automáticamente ANTES de evaluar la configuración.
+ *
+ * Estrategia:
+ *   1. `process.loadEnvFile()` — nativo de Node 20.6+ (cero dependencias).
+ *   2. Fallback: parser propio mínimo (KEY=VALUE, comillas, comentarios, export).
+ *
+ * No sobrescribe variables ya presentes en process.env (las del shell mandan).
+ */
+class EnvLoader {
+    /**
+     * Carga el archivo .env indicado (o ./.env del cwd) en process.env.
+     * Silencioso si el archivo no existe. Devuelve true si cargó algo.
+     * @param {string} [envPath]
+     * @returns {boolean}
+     */
+    static load(envPath) {
+        const file = envPath || path.resolve(process.cwd(), '.env');
+        if (!fs.existsSync(file)) return false;
+
+        // Camino preferido: cargador nativo de Node (20.6+).
+        if (typeof process.loadEnvFile === 'function') {
+            try {
+                process.loadEnvFile(file);
+                return true;
+            } catch {
+                // Cae al parser propio si el nativo falla por algún motivo.
+            }
+        }
+
+        try {
+            const content = fs.readFileSync(file, 'utf8');
+            const parsed = EnvLoader.parse(content);
+            for (const [key, value] of Object.entries(parsed)) {
+                if (process.env[key] === undefined) {
+                    process.env[key] = value;
+                }
+            }
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Parser mínimo de formato .env. Soporta:
+     *   KEY=value · KEY="value con espacios" · KEY='literal' · export KEY=value
+     *   comentarios con # · líneas en blanco · \n \t en comillas dobles.
+     * @param {string} content
+     * @returns {Record<string,string>}
+     */
+    static parse(content) {
+        const out = {};
+        for (let rawLine of content.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (!line || line.startsWith('#')) continue;
+
+            // Permite el prefijo `export` (estilo shell).
+            const withoutExport = line.startsWith('export ') ? line.slice(7).trim() : line;
+
+            const eq = withoutExport.indexOf('=');
+            if (eq === -1) continue;
+
+            const key = withoutExport.slice(0, eq).trim();
+            if (!key) continue;
+
+            let value = withoutExport.slice(eq + 1).trim();
+
+            // Comillas dobles: interpreta escapes. Comillas simples: literal.
+            if (value.length >= 2 && value[0] === '"' && value[value.length - 1] === '"') {
+                value = value.slice(1, -1).replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\"/g, '"');
+            } else if (value.length >= 2 && value[0] === "'" && value[value.length - 1] === "'") {
+                value = value.slice(1, -1);
+            } else {
+                // Sin comillas: corta un comentario en línea (espacio + #).
+                const hash = value.indexOf(' #');
+                if (hash !== -1) value = value.slice(0, hash).trim();
+            }
+
+            out[key] = value;
+        }
+        return out;
+    }
+}
+
+module.exports = EnvLoader;
+module.exports.EnvLoader = EnvLoader;