@dbcube/cli 1.0.1

package/.lh/.lhignore

@@ -0,0 +1,6 @@
+# list file to not track by the local-history extension. comment line starts with a '#' character
+# each line describe a regular expression pattern (search for 'Javascript regex')
+# it will relate to the workspace directory root. for example:
+# '.*\.txt' ignores any file with 'txt' extension
+# '/test/.*' ignores all the files under the 'test' directory
+# '.*/test/.*' ignores all the files under any 'test' directory (even under sub-folders)

package/.lh/package.json.json

@@ -0,0 +1,26 @@
+{
+    "sourceFile": "package.json",
+    "activeCommit": 0,
+    "commits": [
+        {
+            "activePatchIndex": 2,
+            "patches": [
+                {
+                    "date": 1756705588331,
+                    "content": "Index: \n===================================================================\n--- \n+++ \n"
+                },
+                {
+                    "date": 1756705654448,
+                    "content": "Index: \n===================================================================\n--- \n+++ \n@@ -13,9 +13,8 @@\n   \"author\": \"\",\n   \"license\": \"ISC\",\n   \"description\": \"\",\n   \"dependencies\": {\n-    \"@dbcube/schema-builder\": \"^1.0.0\",\n     \"@inquirer/prompts\": \"^7.4.1\",\n     \"alwait\": \"^1.0.0\",\n     \"chalk\": \"^5.4.1\",\n     \"dotenv\": \"^17.0.1\",\n"
+                },
+                {
+                    "date": 1756706224795,
+                    "content": "Index: \n===================================================================\n--- \n+++ \n@@ -2,9 +2,8 @@\n   \"name\": \"dbcube\",\n   \"version\": \"1.0.1\",\n   \"main\": \"index.js\",\n   \"scripts\": {\n-    \"start\": \"node example.js\",\n     \"dbcube\": \"node src/index.js\"\n   },\n   \"bin\": {\n     \"dbcube\": \"./src/index.js\"\n"
+                }
+            ],
+            "date": 1756705588331,
+            "name": "Commit-0",
+            "content": "{\n  \"name\": \"dbcube\",\n  \"version\": \"1.0.0\",\n  \"main\": \"index.js\",\n  \"scripts\": {\n    \"start\": \"node example.js\",\n    \"dbcube\": \"node src/index.js\"\n  },\n  \"bin\": {\n    \"dbcube\": \"./src/index.js\"\n  },\n  \"keywords\": [],\n  \"author\": \"\",\n  \"license\": \"ISC\",\n  \"description\": \"\",\n  \"dependencies\": {\n    \"@inquirer/prompts\": \"^7.4.1\",\n    \"alwait\": \"^1.0.0\",\n    \"chalk\": \"^5.4.1\",\n    \"dotenv\": \"^17.0.1\",\n    \"fs-extra\": \"^11.3.0\",\n    \"glob\": \"^11.0.1\",\n    \"ora\": \"^8.2.0\"\n  }\n}\n"
+        }
+    ]
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@dbcube/cli",
+  "version": "1.0.1",
+  "main": "index.js",
+  "scripts": {
+    "dbcube": "node src/index.js"
+  },
+  "bin": {
+    "dbcube": "./src/index.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@dbcube/schema-builder": "^1.0.0",
+    "@inquirer/prompts": "^7.8.4",
+    "alwait": "^1.0.0",
+    "chalk": "^5.6.0",
+    "dotenv": "^17.2.1",
+    "fs-extra": "^11.3.1",
+    "glob": "^11.0.3",
+    "ora": "^8.2.0"
+  }
+}

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

@@ -0,0 +1,193 @@
+const { default: chalk } = require('chalk');
+const { default: alwait } = require('alwait');
+const ConfigFileUtils = require('../../../../utils/ConfigFileUtils');
+const path = require('path');
+
+// Importar las funciones de @inquirer/prompts
+const { select, input, password, confirm, Separator } = require('@inquirer/prompts');
+const { default: ora } = require('ora');
+const Config = require('../../../../utils/Config');
+
+// Obtener los argumentos pasados al comando
+const args = process.argv.slice(2);
+
+/**
+ * Función para crear y agregar configuración de base de datos
+ */
+async function addDatabaseConfiguration(databaseName = null, motor = null) {
+    try {
+        // Si no se proporciona nombre, solicitarlo
+        if (!databaseName) {
+            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 getconfig = require(configPath);
+                    const config = new Config();
+                    getconfig(config);
+                    const databases = Object.keys(config.getAllDatabases());
+                    
+                    for (const database of databases) {
+                        if(database === value){
+                            return 'El nombre de la base de datos ya existe';
+                        }
+                    }
+
+                    if(value.trim() === ''){
+                        return 'Debe especificar un nombre de referencia para la base de datos';
+                    }
+
+                    return true;
+                }
+            });
+        }
+        
+        // Si no se proporciona motor, solicitarlo
+        if (!motor) {
+            motor = await select({
+                message: 'Seleccione el motor de base de datos:',
+                choices: [
+                    {
+                        name: 'MySQL',
+                        value: 'mysql',
+                        description: `⚡${chalk.white("MySQL es un sistema de gestión de bases de datos relacional")}`
+                    },
+                    {
+                        name: 'PostgreSQL',
+                        value: 'postgresql',
+                        description: `⚡${chalk.white("PostgreSQL es un sistema de gestión de bases de datos relacional orientado a objetos")}`
+                    },
+                    {
+                        name: 'SQLite',
+                        value: 'sqlite',
+                        description: `⚡${chalk.white("SQLite es un sistema de gestión de bases de datos relacional ligero")}`
+                    },
+                    {
+                        name: 'MongoDB\n',
+                        value: 'mongodb',
+                        description: `⚡${chalk.white("MongoDB es un sistema de base de datos NoSQL orientado a documentos")}`
+                    }
+                ]
+            });
+        }
+        
+        let HOST = "localhost";
+        let PORT = 0;
+        let USER = "root";
+        let PASSWORD = "";
+        
+        if(motor != "sqlite"){
+            HOST = await input({ 
+                message: 'Digite el nombre del host:',
+                placeholder: 'localhost',
+                default: 'localhost',
+            });
+            PORT = await input({ 
+                message: 'Digite el puerto:',
+                placeholder: motor=="mysql" ? "3306" : motor=="postgresql" ? "5432" : "27017",
+                default: motor=="mysql" ? 3306 : motor=="postgresql" ? 5432 : 27017,
+                validate: (value) => {
+                    if (value === undefined || value === null || value === '') return true;
+                
+                    const port = parseInt(value);
+                    return !isNaN(port) && port >= 0 && port < 65536
+                        ? true
+                        : 'Debe ser un número de puerto válido (1-65535)';
+                }
+            });
+            USER = await input({ 
+                message: 'Digite el nombre de usuario:',
+                placeholder: 'root',
+                default: 'root',
+            });
+            PASSWORD = await password({ 
+                message: 'Digite la contraseña:',
+                placeholder: 'root',
+                default: 'root',
+            });
+        }
+        
+        const DATABASE = await input({ 
+            message: 'Digite el nombre de la base de datos:',
+            default: databaseName,
+            placeholder: databaseName,
+            validate: (value) => value.trim() !== '' ? true : 'Debe especificar un nombre de la base de datos'
+        });
+        
+        // Crear el objeto de configuración
+        const configAnswers = {
+            HOST, USER, PASSWORD, DATABASE, PORT
+        };
+        
+        console.log('\n')
+        const spinner2 = ora('Agregando configuración al archivo...').start();
+        
+        // Agregar la nueva configuración al archivo
+        const result = await ConfigFileUtils.addDatabaseConfig(databaseName, motor, configAnswers);
+        
+        if (!result) {
+            console.log('\n')
+            spinner2.fail('Hubo un error al agregar la configuración.');
+            process.exit(1);
+        }
+        
+        await alwait(1000);
+        spinner2.succeed("Configuración agregada correctamente!\n");
+        
+        console.log(`✅ Configuración para '${databaseName}' creada exitosamente`);
+        
+        // Escribir el nombre a un archivo temporal para el siguiente proceso
+        const fs = require('fs');
+        const tempFile = path.join(__dirname, '.temp_db_name');
+        fs.writeFileSync(tempFile, databaseName);
+        
+        return databaseName;
+
+    } catch (error) {
+        console.error('Error al agregar la configuración:', error);
+        process.exit(1);
+    }
+}
+
+// Procesar argumentos de línea de comandos
+function parseArguments(args) {
+    const parsedArgs = {};
+    
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        
+        if (arg.startsWith('--name=')) {
+            parsedArgs.name = arg.split('=')[1];
+        } else if (arg === '--name' || arg === '-n') {
+            parsedArgs.name = args[i + 1];
+            i++; // Saltar el siguiente argumento
+        } else if (arg.startsWith('--motor=') || arg.startsWith('--engine=')) {
+            parsedArgs.motor = arg.split('=')[1];
+        } else if (arg === '--motor' || arg === '--engine' || arg === '-m') {
+            parsedArgs.motor = args[i + 1];
+            i++; // Saltar el siguiente argumento
+        }
+    }
+    
+    return parsedArgs;
+}
+
+// Función principal
+async function main() {
+    console.log(`\n💚 ${chalk.green("Agregando configuración de base de datos...")}`);
+    
+    try {
+        const parsedArgs = parseArguments(args);
+        await addDatabaseConfiguration(parsedArgs.name, parsedArgs.motor);
+    } catch (error) {
+        console.error('Error inesperado:', error);
+        process.exit(1);
+    }
+}
+
+// Ejecutar el comando
+main().catch(error => {
+    console.error('Error fatal:', error);
+    process.exit(1);
+});

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

@@ -0,0 +1,88 @@
+const { default: chalk } = require('chalk');
+const { default: alwait } = require('alwait');
+const { default: ora } = require('ora');
+const { default: Schema } = require('@dbcube/schema-builder');
+
+// Obtener los argumentos pasados al comando
+const args = process.argv.slice(2);
+
+/**
+ * Función para crear la base de datos física
+ */
+async function createDatabasePhysically(databaseName) {
+    try {
+        if (!databaseName) {
+            console.error('❌ Error: Debe proporcionar el nombre de la base de datos');
+            console.log('Uso: node createDatabase.js --name=<nombre> | -n <nombre>');
+            process.exit(1);
+        }
+
+        console.log('\n')
+        const spinner = ora(`Creando base de datos '${databaseName}'...`).start();
+        
+        console.log("\n")
+        console.log(`Inicializando Schema para: ${databaseName}`)
+        const schema = new Schema(databaseName);
+        console.log(`Creando base de datos: ${databaseName}`)
+        await schema.createDatabase();
+        
+        await alwait(1000);
+        spinner.succeed(`Base de datos '${databaseName}' creada correctamente!\n`);
+        
+        console.log(`✅ Base de datos '${databaseName}' creada exitosamente`);
+        
+    } catch (error) {
+        console.log('\n')
+        console.error('❌ Error al crear la base de datos:', error.message || error);
+        process.exit(1);
+    }
+}
+
+// Procesar argumentos de línea de comandos
+function parseArguments(args) {
+    const parsedArgs = {};
+    
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        
+        if (arg.startsWith('--name=')) {
+            parsedArgs.name = arg.split('=')[1];
+        } else if (arg === '--name' || arg === '-n') {
+            parsedArgs.name = args[i + 1];
+            i++; // Saltar el siguiente argumento
+        } else if (arg.startsWith('--database=') || arg.startsWith('--db=')) {
+            parsedArgs.name = arg.split('=')[1];
+        } else if (arg === '--database' || arg === '--db' || arg === '-d') {
+            parsedArgs.name = args[i + 1];
+            i++; // Saltar el siguiente argumento
+        }
+    }
+    
+    return parsedArgs;
+}
+
+// Función principal
+async function main() {
+    console.log(`\n💚 ${chalk.green("Creando base de datos...")}`);
+    
+    try {
+        const parsedArgs = parseArguments(args);
+        
+        if (!parsedArgs.name) {
+            console.error('❌ Error: Debe proporcionar el nombre de la base de datos');
+            console.log('Uso: --name=<nombre> | -n <nombre> | --database=<nombre> | -d <nombre>');
+            process.exit(1);
+        }
+        
+        await createDatabasePhysically(parsedArgs.name);
+    } catch (error) {
+        console.error('Error inesperado:', error);
+        process.exit(1);
+    }
+}
+
+// Ejecutar el comando
+main().catch(error => {
+    console.error('Error fatal:', error);
+    process.exit(1);
+});

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

@@ -0,0 +1,157 @@
+const { default: chalk } = require('chalk');
+const { default: alwait } = require('alwait');
+const ConfigFileUtils = require('../../../../utils/ConfigFileUtils');
+const { select, input } = require('@inquirer/prompts');
+const { default: ora } = require('ora');
+const { execSync } = require('child_process');
+const path = require('path');
+
+/**
+ * Función para crear una nueva base de datos con configuración (Proceso completo en dos fases)
+ */
+async function createNewDatabase() {
+    try {
+        console.log(`\n💚 ${chalk.green("Proceso de creación de base de datos...")}`);
+        console.log('📋 Fase 1: Configuración');
+        console.log('🏗️  Fase 2: Creación física\n');
+        
+        // Fase 1: Ejecutar addDatabaseConfig.js
+        console.log('🔧 Iniciando configuración de base de datos...');
+        const configCommand = `node "${path.join(__dirname, 'addDatabaseConfig.js')}"`;
+        
+        try {
+            execSync(configCommand, { 
+                stdio: 'inherit',
+                cwd: process.cwd()
+            });
+        } catch (error) {
+            console.error('❌ Error en la fase de configuración:', error.message);
+            process.exit(1);
+        }
+        
+        // Leer el nombre de la base de datos del archivo temporal
+        const fs = require('fs');
+        const tempFile = path.join(__dirname, '.temp_db_name');
+        let databaseName;
+        
+        try {
+            databaseName = fs.readFileSync(tempFile, 'utf8');
+            // Limpiar el archivo temporal
+            fs.unlinkSync(tempFile);
+        } catch (error) {
+            console.error('❌ Error: No se pudo obtener el nombre de la base de datos configurada');
+            process.exit(1);
+        }
+        
+        console.log('\n🏗️ Iniciando creación física de la base de datos...');
+        
+        // Fase 2: Ejecutar createDatabase.js
+        const createCommand = `node "${path.join(__dirname, 'createDatabase.js')}" --name="${databaseName}"`;
+        
+        try {
+            execSync(createCommand, { 
+                stdio: 'inherit',
+                cwd: process.cwd()
+            });
+        } catch (error) {
+            console.error('❌ Error en la fase de creación:', error.message);
+            process.exit(1);
+        }
+        
+        console.log(`\n🎉 ${chalk.green("¡Base de datos creada exitosamente!")}`);
+        console.log(`✅ Configuración y creación de '${databaseName}' completadas\n`);
+
+    } catch (error) {
+        console.error('Error al crear la base de datos:', error);
+        process.exit(1);
+    }
+}
+
+/**
+ * Función para usar una base de datos ya configurada
+ * @param {string} databaseName - Nombre de la base de datos a usar
+ */
+async function useExistingDatabase(databaseName) {
+    console.log(`\n=== Usando base de datos: ${databaseName} ===\n`);
+    
+    console.log('📋 Usando configuración existente para crear la base de datos...\n');
+    
+    try {
+        // Ejecutar createDatabase.js con el nombre de la base de datos existente
+        const createCommand = `node "${path.join(__dirname, 'createDatabase.js')}" --name="${databaseName}"`;
+        
+        try {
+            execSync(createCommand, { 
+                stdio: 'inherit',
+                cwd: process.cwd()
+            });
+        } catch (error) {
+            console.error('❌ Error al crear la base de datos:', error.message);
+            process.exit(1);
+        }
+        
+        console.log(`\n🎉 ${chalk.green("¡Base de datos lista para usar!")}`);
+        console.log(`✅ Base de datos '${databaseName}' creada usando configuración existente\n`);
+        
+    } catch (error) {
+        console.log('❌ Error al crear la base de datos:', error);
+        process.exit(1);
+    }
+}
+
+async function main() {
+    //const dbcubelog = new DBCubeLogger(`❤️ ${chalk.green("Creemos una base de datos...")}\n`);
+    console.log(`\n💚 ${chalk.green("Creemos una base de datos...")}`);
+    
+    try {
+        // Obtener las bases de datos configuradas
+        const spinner = ora('Cargando bases de datos configuradas...').start();
+        const configuredDatabases = await ConfigFileUtils.getConfiguredDatabases();
+        await alwait(1000);
+        spinner.succeed(`¡Configuracion de bases de datos cargada!\n`);
+        
+        // Preparar las opciones para el menú
+        const choices = [];
+        
+        // Agregar las bases de datos configuradas
+        configuredDatabases.forEach(element => {
+            choices.push({
+                name: `${element.name} (${element.type})`,
+                value: element.name,
+                description: `${chalk.white(` Usar la configuración para la base de datos: \n 📦 ${element.name}`)}`
+            });
+        });
+        let selected = 'create';
+        if(choices.length > 0){
+            // Agregar opción para crear nueva base de datos
+            choices.push({
+                name: 'Crear nueva configuración\n',
+                value: 'create',
+                description: `📦 ${chalk.white(" Crear una nueva configuración de base de datos")}`
+            });
+            // Mostrar menú de selección con inquirer
+            selected = await select({
+                message: 'Seleccione una base de datos o cree una nueva:',
+                choices: choices
+            });
+        }
+        
+        console.clear();
+        console.log(`\n💚 ${chalk.green("Creemos una base de datos...")}`);
+        if (selected === 'create') {
+            // El usuario quiere crear una nueva base de datos
+            await createNewDatabase();
+        } else {
+            // El usuario quiere usar una base de datos existente
+            await useExistingDatabase(selected);
+        }
+    } catch (error) {
+        console.error('Error inesperado:', error);
+    }
+}
+  
+// Ejecutar el ejemplo
+main().catch(error => {
+    console.error('Error fatal:', error);
+    process.exit(1);
+});

package/src/commands/run/seeder/add.js

@@ -0,0 +1,76 @@
+const { default: Schema } = require('@dbcube/schema-builder');
+const ConfigFileUtils = require('./../../../utils/ConfigFileUtils');
+const fs = require('fs');
+const path = require('path');
+const FileUtils = require('./../../../utils/FileUtils');
+const { default: chalk } = require('chalk');
+const { default: ora } = require('ora');
+const { default: alwait } = require('alwait');
+
+async function main() {
+    // Suprimir logs de dotenv
+    process.env.DOTENV_SILENT = 'true';
+    
+    console.clear();
+    console.log(`\n🌱 ${chalk.green("Ejecutando seeders...")}`);    
+    try {        
+        // Verificar y leer archivos de la carpeta cubes
+        const spinner = ora('Preparando ejecución de seeders...').start();
+        await alwait(500);
+        const cubesDir = path.join(process.cwd(), 'dbcube', 'cubes');
+        
+        // Verificar si la carpeta existe
+        if (!fs.existsSync(cubesDir)) {
+            spinner.fail('Carpeta de cubes no encontrada');
+            throw new Error('❌ The cubes folder does not exist');
+        }
+        
+        // Leer todos los archivos en la carpeta
+        const cubeFiles = FileUtils.getCubeFilesRecursively('dbcube', 'table.cube')
+        
+        if (cubeFiles.length === 0) {
+            spinner.fail('No hay cubes para ejecutar');
+            throw new Error('❌ There are no cubes to execute');
+        } else {            
+            spinner.succeed('Cubes encontrados correctamente');
+            
+            const loadingSpinner = ora('Cargando configuraciones de base de datos...').start();
+            let countTableCreated = 0;
+            const configuredDatabases = await ConfigFileUtils.getConfiguredDatabases();
+            loadingSpinner.succeed(`Configuraciones cargadas (${configuredDatabases.length} bases de datos)`);
+            
+            // Recorrer cada archivo y mostrar su contenido
+            for (const config of configuredDatabases) {
+              const seederSpinner = ora(`Ejecutando seeders para: ${config.name} (${config.type})...`).start();
+              const schema = new Schema(config.name);
+              await schema.executeSeeders();
+              seederSpinner.succeed(`Seeders ejecutados para: ${config.name}`);
+              countTableCreated++;
+            }
+
+            if(countTableCreated==0) {
+                console.log(`\n⚠️  ${chalk.yellow('No hay seeders para ejecutar.')}`);  
+            } else {
+                console.log(`\n🎉 ${chalk.green(`Seeders ejecutados exitosamente en ${countTableCreated} base(s) de datos!`)}`);
+            }
+            
+        }
+    } catch (error) {
+      if(error.message.includes("reading 'init'")){
+        console.error('❌ Configuracion de base de datos no encontrada\n');
+        console.error('Ejecute el comando para crear una nueva base de datos:');
+        console.error(`\tdbcube run create:database`);
+        console.error('\nO verifique que la base de datos este configurada en el archivo dbcube.config.js\n');
+        process.exit(1);
+      } else if(error.message.includes("reading 'getDatabase'")){
+        console.error('- Se sugiere cambiar el linea o crear la base de datos a la que se hace referencia.');
+      }else{
+        console.error('Error aqui:', error);
+        console.error('Error aqui:', error.message);
+      }
+    }
+    console.log('\n');
+}
+
+// Ejecutar el ejemplo
+main().catch(console.error);

package/src/commands/run/table/fresh.js

@@ -0,0 +1,76 @@
+const { default: Schema } = require('@dbcube/schema-builder');
+const ConfigFileUtils = require('./../../../utils/ConfigFileUtils');
+const fs = require('fs');
+const path = require('path');
+const FileUtils = require('./../../../utils/FileUtils');
+const { default: chalk } = require('chalk');
+const { default: ora } = require('ora');
+const { default: alwait } = require('alwait');
+
+async function main() {
+    // Suprimir logs de dotenv
+    process.env.DOTENV_SILENT = 'true';
+    
+    console.clear();
+    console.log(`\n🗑️  ${chalk.green("Ejecutando fresh tables...")}`);    
+    try {        
+        // Verificar y leer archivos de la carpeta cubes
+        const spinner = ora('Preparando ejecución fresh de tablas...').start();
+        await alwait(500);
+        const cubesDir = path.join(process.cwd(), 'dbcube', 'cubes');
+        
+        // Verificar si la carpeta existe
+        if (!fs.existsSync(cubesDir)) {
+            spinner.fail('Carpeta de cubes no encontrada');
+            throw new Error('❌ The cubes folder does not exist');
+        }
+        
+        // Leer todos los archivos en la carpeta
+        const cubeFiles = FileUtils.getCubeFilesRecursively('dbcube', 'table.cube')
+        
+        if (cubeFiles.length === 0) {
+            spinner.fail('No hay cubes para ejecutar');
+            throw new Error('❌ There are no cubes to execute');
+        } else {            
+            spinner.succeed('Cubes encontrados correctamente');
+            
+            const loadingSpinner = ora('Cargando configuraciones de base de datos...').start();
+            let countTableCreated = 0;
+            const configuredDatabases = await ConfigFileUtils.getConfiguredDatabases();
+            loadingSpinner.succeed(`Configuraciones cargadas (${configuredDatabases.length} bases de datos)`);
+            
+            // Recorrer cada archivo y mostrar su contenido
+            for (const config of configuredDatabases) {
+              const freshSpinner = ora(`Ejecutando fresh tables para: ${config.name} (${config.type})...`).start();
+              const schema = new Schema(config.name);
+              await schema.freshTables();
+              freshSpinner.succeed(`Fresh tables ejecutado para: ${config.name}`);
+              countTableCreated++;
+            }
+
+            if(countTableCreated==0) {
+                console.log(`\n⚠️  ${chalk.yellow('No hay tablas para procesar.')}`);  
+            } else {
+                console.log(`\n🎉 ${chalk.green(`Fresh tables ejecutado exitosamente en ${countTableCreated} base(s) de datos!`)}`);
+            }
+            
+        }
+    } catch (error) {
+      if(error.message.includes("reading 'init'")){
+        console.error('❌ Configuracion de base de datos no encontrada\n');
+        console.error('Ejecute el comando para crear una nueva base de datos:');
+        console.error(`\tdbcube run create:database`);
+        console.error('\nO verifique que la base de datos este configurada en el archivo dbcube.config.js\n');
+        process.exit(1);
+      } else if(error.message.includes("reading 'getDatabase'")){
+        console.error('- Se sugiere cambiar el linea o crear la base de datos a la que se hace referencia.');
+      }else{
+        console.error('Error aqui:', error);
+        console.error('Error aqui:', error.message);
+      }
+    }
+    console.log('\n');
+}
+
+// Ejecutar el ejemplo
+main().catch(console.error);