@dbcube/cli 1.1.7 → 1.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbcube/cli",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "main": "index.js",
   "scripts": {
     "dbcube": "node src/index.js"

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

@@ -35,6 +35,11 @@ async function main() {
         const configuredDatabases = await progress.showProgress('Cargando configuraciones de base de datos', async () => {
             return await ConfigFileUtils.getConfiguredDatabases();
         });
+
+        // Obtener archivos .cube reales
+        const cubeFiles = await progress.showProgress('Analizando archivos .cube', async () => {
+            return FileUtils.getCubeFilesRecursively('dbcube', 'table.cube');
+        });
         
         let totalSeedersProcessed = 0;
         
@@ -44,17 +49,19 @@ async function main() {
             
             const schema = new Schema(config.name);
             
-            // Obtener lista de seeders (simulamos esto por ahora)
-            const mockSeeders = await progress.showProgress('Obteniendo lista de seeders', async () => {
-                // Aquí podrías obtener la lista real de seeders desde el schema
-                return ['UserSeeder', 'ProductSeeder', 'CategorySeeder', 'OrderSeeder']; // Mock data
-            });
+            // Obtener nombres reales de los seeders desde los archivos .cube
+            const realSeeders = progress.extractSeederNamesFromCubes(cubeFiles);
+            
+            if (realSeeders.length === 0) {
+                console.log(`  ${chalk.yellow('└─')} No se encontraron seeders en los archivos .cube`);
+                continue;
+            }
             
             // Procesar cada seeder con indicador de progreso
-            console.log(`  ${chalk.blue('├─')} Ejecutando ${mockSeeders.length} seeders:`);
+            console.log(`  ${chalk.blue('├─')} Ejecutando ${realSeeders.length} seeders:`);
             
-            for (let i = 0; i < mockSeeders.length; i++) {
-                const seederName = mockSeeders[i];
+            for (let i = 0; i < realSeeders.length; i++) {
+                const seederName = realSeeders[i];
                 await progress.showTableProgress(seederName, 'seeder');
                 totalSeedersProcessed++;
             }

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

@@ -4,85 +4,100 @@ 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');
+const ProgressIndicator = require('./../../../lib/ProgressIndicator');
 
 async function main() {
     // Suprimir logs de dotenv
     process.env.DOTENV_SILENT = 'true';
     
-    console.clear();
-    console.log(`\n🗑️  ${chalk.green("Ejecutando fresh tables...")}`);    
+    const progress = new ProgressIndicator();
+    progress.showHeader('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');
+        await progress.showProgress('Verificando archivos de cubes', async () => {
+            const cubesDir = path.join(process.cwd(), 'dbcube', 'cubes');
+            
+            if (!fs.existsSync(cubesDir)) {
+                throw new Error('❌ The cubes folder does not exist');
+            }
+            
+            const cubeFiles = FileUtils.getCubeFilesRecursively('dbcube', 'table.cube');
+            
+            if (cubeFiles.length === 0) {
+                throw new Error('❌ There are no cubes to execute');
+            }
+            
+            return cubeFiles;
+        });
         
-        // 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');
-        }
+        // Cargar configuraciones de base de datos
+        const configuredDatabases = await progress.showProgress('Cargando configuraciones de base de datos', async () => {
+            return await ConfigFileUtils.getConfiguredDatabases();
+        });
+
+        // Obtener archivos .cube reales
+        const cubeFiles = await progress.showProgress('Analizando archivos .cube', async () => {
+            return FileUtils.getCubeFilesRecursively('dbcube', 'table.cube');
+        });
         
-        // Leer todos los archivos en la carpeta
-        const cubeFiles = FileUtils.getCubeFilesRecursively('dbcube', 'table.cube')
+        let totalTablesProcessed = 0;
         
-        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');
+        // Procesar cada base de datos
+        for (const config of configuredDatabases) {
+            console.log(`\n${chalk.blue('┌─')} Procesando base de datos: ${chalk.bold(config.name)} ${chalk.gray(`(${config.type})`)}`);
+            
+            const schema = new Schema(config.name);
+            
+            // Obtener nombres reales de las tablas desde los archivos .cube
+            const realTables = progress.extractTableNamesFromCubes(cubeFiles);
+            
+            if (realTables.length === 0) {
+                console.log(`  ${chalk.yellow('└─')} No se encontraron tablas en los archivos .cube`);
+                continue;
+            }
             
-            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)`);
+            // Procesar cada tabla con indicador de progreso
+            console.log(`  ${chalk.blue('├─')} Ejecutando fresh en ${realTables.length} tablas:`);
             
-            // Recorrer cada archivo y mostrar su contenido
-            for (const config of configuredDatabases) {
-              const freshSpinner = ora(`Ejecutando fresh tables para: ${config.name} (${config.type})...`).start();
-              
-              try {
-                const schema = new Schema(config.name);
+            for (let i = 0; i < realTables.length; i++) {
+                const tableName = realTables[i];
+                await progress.showTableProgress(tableName, 'refresh');
+                totalTablesProcessed++;
+            }
+            
+            // Ejecutar el fresh real
+            await progress.showProgress('Aplicando fresh en la base de datos', async () => {
                 const result = await schema.freshTables();
                 
                 if (result === null) {
-                  freshSpinner.fail(`No se pudieron ejecutar las tablas para: ${config.name}`);
-                  console.error(`❌ Error: Base de datos ${config.name} no existe o no es accesible`);
-                  process.exit(1);
-                } else {
-                  freshSpinner.succeed(`Fresh tables ejecutado para: ${config.name}`);
-                  countTableCreated++;
+                    throw new Error(`Base de datos ${config.name} no existe o no es accesible`);
                 }
-              } catch (schemaError) {
-                freshSpinner.fail(`Error en fresh tables para: ${config.name}`);
-                console.error(`❌ Error específico:`, schemaError.message);
-                process.exit(1);
-              }
-            }
-
-            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!`)}`);
-            }
+                
+                return result;
+            });
             
+            console.log(`  ${chalk.blue('└─')} ${chalk.green('✓')} Base de datos ${config.name} completada`);
         }
+
+        // Mostrar resumen
+        progress.showSummary('fresh', totalTablesProcessed, configuredDatabases.length);
+            
     } 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');
+        progress.showError('Error durante el fresh', error);
+        
+        if(error.message.includes("reading 'init'")){
+            console.error('\n💡 Soluciones sugeridas:');
+            console.error(`  ${chalk.gray('├─')} Ejecutar: ${chalk.cyan('dbcube run database:create')}`);
+            console.error(`  ${chalk.gray('└─')} Verificar archivo: ${chalk.cyan('dbcube.config.js')}`);
+            process.exit(1);
+        } else if(error.message.includes("reading 'getDatabase'")){
+            console.error('💡 Se sugiere cambiar la configuración o crear la base de datos referenciada.');
+        }
+        
         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');
 }
 

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

@@ -35,6 +35,11 @@ async function main() {
         const configuredDatabases = await progress.showProgress('Cargando configuraciones de base de datos', async () => {
             return await ConfigFileUtils.getConfiguredDatabases();
         });
+
+        // Obtener archivos .cube reales
+        const cubeFiles = await progress.showProgress('Analizando archivos .cube', async () => {
+            return FileUtils.getCubeFilesRecursively('dbcube', 'table.cube');
+        });
         
         let totalTablesProcessed = 0;
         
@@ -44,17 +49,19 @@ async function main() {
             
             const schema = new Schema(config.name);
             
-            // Obtener lista de tablas (simulamos esto por ahora)
-            const mockTables = await progress.showProgress('Obteniendo lista de tablas', async () => {
-                // Aquí podrías obtener la lista real de tablas desde el schema
-                return ['users', 'products', 'orders', 'categories']; // Mock data
-            });
+            // Obtener nombres reales de las tablas desde los archivos .cube
+            const realTables = progress.extractTableNamesFromCubes(cubeFiles);
+            
+            if (realTables.length === 0) {
+                console.log(`  ${chalk.yellow('└─')} No se encontraron tablas en los archivos .cube`);
+                continue;
+            }
             
             // Procesar cada tabla con indicador de progreso
-            console.log(`  ${chalk.blue('├─')} Refrescando ${mockTables.length} tablas:`);
+            console.log(`  ${chalk.blue('├─')} Refrescando ${realTables.length} tablas:`);
             
-            for (let i = 0; i < mockTables.length; i++) {
-                const tableName = mockTables[i];
+            for (let i = 0; i < realTables.length; i++) {
+                const tableName = realTables[i];
                 await progress.showTableProgress(tableName, 'refresh');
                 totalTablesProcessed++;
             }

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

@@ -35,6 +35,11 @@ async function main() {
         const configuredDatabases = await progress.showProgress('Cargando configuraciones de base de datos', async () => {
             return await ConfigFileUtils.getConfiguredDatabases();
         });
+
+        // Obtener archivos .cube reales
+        const cubeFiles = await progress.showProgress('Analizando archivos .cube', async () => {
+            return FileUtils.getCubeFilesRecursively('dbcube', 'table.cube');
+        });
         
         let totalTriggersProcessed = 0;
         
@@ -44,17 +49,19 @@ async function main() {
             
             const schema = new Schema(config.name);
             
-            // Obtener lista de triggers (simulamos esto por ahora)
-            const mockTriggers = await progress.showProgress('Obteniendo lista de triggers', async () => {
-                // Aquí podrías obtener la lista real de triggers desde el schema
-                return ['before_insert_users', 'after_update_products', 'before_delete_orders']; // Mock data
-            });
+            // Obtener nombres reales de los triggers desde los archivos .cube
+            const realTriggers = progress.extractTriggerNamesFromCubes(cubeFiles);
+            
+            if (realTriggers.length === 0) {
+                console.log(`  ${chalk.yellow('└─')} No se encontraron triggers en los archivos .cube`);
+                continue;
+            }
             
             // Procesar cada trigger con indicador de progreso
-            console.log(`  ${chalk.blue('├─')} Ejecutando ${mockTriggers.length} triggers:`);
+            console.log(`  ${chalk.blue('├─')} Ejecutando ${realTriggers.length} triggers:`);
             
-            for (let i = 0; i < mockTriggers.length; i++) {
-                const triggerName = mockTriggers[i];
+            for (let i = 0; i < realTriggers.length; i++) {
+                const triggerName = realTriggers[i];
                 await progress.showTableProgress(triggerName, 'trigger');
                 totalTriggersProcessed++;
             }

package/src/lib/ProgressIndicator.js

@@ -1,5 +1,7 @@
 const { default: chalk } = require('chalk');
 const { default: ora } = require('ora');
+const fs = require('fs');
+const path = require('path');
 
 class ProgressIndicator {
     constructor() {
@@ -139,6 +141,137 @@ class ProgressIndicator {
         return operations[operation] || operation;
     }
 
+    /**
+     * Extrae nombres de tablas reales de archivos .cube
+     * @param {string[]} cubeFiles - Array de rutas de archivos .cube
+     * @returns {string[]} Array de nombres de tablas
+     */
+    extractTableNamesFromCubes(cubeFiles) {
+        const tableNames = [];
+        
+        for (const filePath of cubeFiles) {
+            try {
+                const content = fs.readFileSync(filePath, 'utf8');
+                
+                // Buscar patrones de nombre de tabla en el archivo .cube
+                // Patrón 1: @table("nombre_tabla") o @table('nombre_tabla')
+                const tableMatch = content.match(/@table\(\s*["']([^"']+)["']\s*\)/);
+                if (tableMatch) {
+                    tableNames.push(tableMatch[1]);
+                    continue;
+                }
+                
+                // Patrón 2: table: "nombre_tabla" o table: 'nombre_tabla'
+                const tableMatch2 = content.match(/table\s*:\s*["']([^"']+)["']/);
+                if (tableMatch2) {
+                    tableNames.push(tableMatch2[1]);
+                    continue;
+                }
+                
+                // Patrón 3: usar el nombre del archivo sin la extensión .cube
+                const fileName = path.basename(filePath, '.table.cube');
+                if (fileName && fileName !== 'table') {
+                    // Si el archivo tiene un número al principio, quitarlo
+                    const cleanName = fileName.replace(/^\d+[-_]?/, '');
+                    if (cleanName) {
+                        tableNames.push(cleanName);
+                    }
+                }
+                
+            } catch (error) {
+                // Si no se puede leer el archivo, usar el nombre del archivo
+                const fileName = path.basename(filePath, '.table.cube');
+                const cleanName = fileName.replace(/^\d+[-_]?/, '');
+                if (cleanName && cleanName !== 'table') {
+                    tableNames.push(cleanName);
+                }
+            }
+        }
+        
+        return tableNames;
+    }
+
+    /**
+     * Extrae nombres de seeders de archivos .cube
+     * @param {string[]} cubeFiles - Array de rutas de archivos .cube
+     * @returns {string[]} Array de nombres de seeders
+     */
+    extractSeederNamesFromCubes(cubeFiles) {
+        const seederNames = [];
+        
+        for (const filePath of cubeFiles) {
+            try {
+                const content = fs.readFileSync(filePath, 'utf8');
+                
+                // Buscar secciones de seeders en el archivo
+                const seederMatches = content.match(/@seeder\s*\(\s*["']([^"']+)["']\s*\)/g);
+                if (seederMatches) {
+                    for (const match of seederMatches) {
+                        const seederName = match.match(/@seeder\s*\(\s*["']([^"']+)["']\s*\)/)[1];
+                        seederNames.push(seederName);
+                    }
+                } else {
+                    // Si no hay seeders específicos, crear uno basado en el nombre de la tabla
+                    const tableNames = this.extractTableNamesFromCubes([filePath]);
+                    if (tableNames.length > 0) {
+                        seederNames.push(`${tableNames[0]}Seeder`);
+                    }
+                }
+                
+            } catch (error) {
+                // Fallback: usar nombre del archivo
+                const fileName = path.basename(filePath, '.table.cube');
+                const cleanName = fileName.replace(/^\d+[-_]?/, '');
+                if (cleanName && cleanName !== 'table') {
+                    seederNames.push(`${cleanName}Seeder`);
+                }
+            }
+        }
+        
+        return seederNames;
+    }
+
+    /**
+     * Extrae nombres de triggers de archivos .cube
+     * @param {string[]} cubeFiles - Array de rutas de archivos .cube
+     * @returns {string[]} Array de nombres de triggers
+     */
+    extractTriggerNamesFromCubes(cubeFiles) {
+        const triggerNames = [];
+        
+        for (const filePath of cubeFiles) {
+            try {
+                const content = fs.readFileSync(filePath, 'utf8');
+                
+                // Buscar triggers en el archivo
+                const triggerMatches = content.match(/@trigger\s*\(\s*["']([^"']+)["']\s*\)/g);
+                if (triggerMatches) {
+                    for (const match of triggerMatches) {
+                        const triggerName = match.match(/@trigger\s*\(\s*["']([^"']+)["']\s*\)/)[1];
+                        triggerNames.push(triggerName);
+                    }
+                } else {
+                    // Si no hay triggers específicos, crear algunos basados en la tabla
+                    const tableNames = this.extractTableNamesFromCubes([filePath]);
+                    if (tableNames.length > 0) {
+                        const tableName = tableNames[0];
+                        triggerNames.push(`before_insert_${tableName}`);
+                    }
+                }
+                
+            } catch (error) {
+                // Fallback: usar nombre del archivo
+                const fileName = path.basename(filePath, '.table.cube');
+                const cleanName = fileName.replace(/^\d+[-_]?/, '');
+                if (cleanName && cleanName !== 'table') {
+                    triggerNames.push(`before_insert_${cleanName}`);
+                }
+            }
+        }
+        
+        return triggerNames;
+    }
+
     /**
      * Limpia la pantalla y muestra encabezado
      * @param {string} title - Título principal