@dbcube/cli 1.1.6 → 1.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbcube/cli",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "main": "index.js",
   "scripts": {
     "dbcube": "node src/index.js"
@@ -13,7 +13,7 @@
   "license": "ISC",
   "description": "",
   "dependencies": {
-    "@dbcube/schema-builder": "^1.0.6",
+    "@dbcube/schema-builder": "^1.0.7",
     "@inquirer/prompts": "^7.8.4",
     "alwait": "^1.0.0",
     "chalk": "^5.6.0",

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

@@ -4,71 +4,87 @@ 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 seeders...")}`);    
+    const progress = new ProgressIndicator();
+    progress.showHeader('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');
+        await progress.showProgress('Verificando archivos de seeders', 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();
+        });
         
-        // Leer todos los archivos en la carpeta
-        const cubeFiles = FileUtils.getCubeFilesRecursively('dbcube', 'table.cube')
+        let totalSeedersProcessed = 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 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)`);
+            const schema = new Schema(config.name);
             
-            // 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!`)}`);
+            // 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
+            });
+            
+            // Procesar cada seeder con indicador de progreso
+            console.log(`  ${chalk.blue('├─')} Ejecutando ${mockSeeders.length} seeders:`);
+            
+            for (let i = 0; i < mockSeeders.length; i++) {
+                const seederName = mockSeeders[i];
+                await progress.showTableProgress(seederName, 'seeder');
+                totalSeedersProcessed++;
             }
             
+            // Ejecutar los seeders reales
+            await progress.showProgress('Insertando datos de prueba', async () => {
+                await schema.executeSeeders();
+            });
+            
+            console.log(`  ${chalk.blue('└─')} ${chalk.green('✓')} Base de datos ${config.name} completada`);
         }
+
+        // Mostrar resumen
+        progress.showSummary('seeder', totalSeedersProcessed, 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 la ejecución de seeders', 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/fresh.js

@@ -42,10 +42,24 @@ async function main() {
             // 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++;
+              
+              try {
+                const schema = new Schema(config.name);
+                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++;
+                }
+              } catch (schemaError) {
+                freshSpinner.fail(`Error en fresh tables para: ${config.name}`);
+                console.error(`❌ Error específico:`, schemaError.message);
+                process.exit(1);
+              }
             }
 
             if(countTableCreated==0) {

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

@@ -4,71 +4,87 @@ 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 refresh tables...")}`);    
+    const progress = new ProgressIndicator();
+    progress.showHeader('Ejecutando refresh tables...', '🔄');
+    
     try {        
         // Verificar y leer archivos de la carpeta cubes
-        const spinner = ora('Preparando refresh 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();
+        });
         
-        // 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 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)`);
+            const schema = new Schema(config.name);
             
-            // Recorrer cada archivo y mostrar su contenido
-            for (const config of configuredDatabases) {
-              const refreshSpinner = ora(`Ejecutando refresh tables para: ${config.name} (${config.type})...`).start();
-              const schema = new Schema(config.name);
-              await schema.refreshTables();
-              refreshSpinner.succeed(`Refresh tables ejecutado para: ${config.name}`);
-              countTableCreated++;
-            }
-
-            if(countTableCreated==0) {
-                console.log(`\n⚠️  ${chalk.yellow('No hay tablas para refrescar.')}`);  
-            } else {
-                console.log(`\n🎉 ${chalk.green(`Refresh tables ejecutado exitosamente en ${countTableCreated} base(s) de datos!`)}`);
+            // 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
+            });
+            
+            // Procesar cada tabla con indicador de progreso
+            console.log(`  ${chalk.blue('├─')} Refrescando ${mockTables.length} tablas:`);
+            
+            for (let i = 0; i < mockTables.length; i++) {
+                const tableName = mockTables[i];
+                await progress.showTableProgress(tableName, 'refresh');
+                totalTablesProcessed++;
             }
             
+            // Ejecutar el refresh real
+            await progress.showProgress('Aplicando cambios en la base de datos', async () => {
+                await schema.refreshTables();
+            });
+            
+            console.log(`  ${chalk.blue('└─')} ${chalk.green('✓')} Base de datos ${config.name} completada`);
         }
+
+        // Mostrar resumen
+        progress.showSummary('refresh', 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 refresh', 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/trigger/fresh.js

@@ -4,71 +4,87 @@ 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 triggers...")}`);    
+    const progress = new ProgressIndicator();
+    progress.showHeader('Ejecutando triggers...', '⚡');
+    
     try {        
         // Verificar y leer archivos de la carpeta cubes
-        const spinner = ora('Preparando ejecución de triggers...').start();
-        await alwait(500);
-        const cubesDir = path.join(process.cwd(), 'dbcube', 'cubes');
+        await progress.showProgress('Verificando archivos de triggers', 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();
+        });
         
-        // Leer todos los archivos en la carpeta
-        const cubeFiles = FileUtils.getCubeFilesRecursively('dbcube', 'table.cube')
+        let totalTriggersProcessed = 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 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)`);
+            const schema = new Schema(config.name);
             
-            // Recorrer cada archivo y mostrar su contenido
-            for (const config of configuredDatabases) {
-              const triggerSpinner = ora(`Ejecutando triggers para: ${config.name} (${config.type})...`).start();
-              const schema = new Schema(config.name);
-              await schema.executeTriggers();
-              triggerSpinner.succeed(`Triggers ejecutados para: ${config.name}`);
-              countTableCreated++;
-            }
-
-            if(countTableCreated==0) {
-                console.log(`\n⚠️  ${chalk.yellow('No hay triggers para ejecutar.')}`);  
-            } else {
-                console.log(`\n🎉 ${chalk.green(`Triggers ejecutados exitosamente en ${countTableCreated} base(s) de datos!`)}`);
+            // 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
+            });
+            
+            // Procesar cada trigger con indicador de progreso
+            console.log(`  ${chalk.blue('├─')} Ejecutando ${mockTriggers.length} triggers:`);
+            
+            for (let i = 0; i < mockTriggers.length; i++) {
+                const triggerName = mockTriggers[i];
+                await progress.showTableProgress(triggerName, 'trigger');
+                totalTriggersProcessed++;
             }
             
+            // Ejecutar los triggers reales
+            await progress.showProgress('Aplicando triggers en la base de datos', async () => {
+                await schema.executeTriggers();
+            });
+            
+            console.log(`  ${chalk.blue('└─')} ${chalk.green('✓')} Base de datos ${config.name} completada`);
         }
+
+        // Mostrar resumen
+        progress.showSummary('trigger', totalTriggersProcessed, 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 la ejecución de triggers', 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/lib/ProgressIndicator.js

@@ -0,0 +1,154 @@
+const { default: chalk } = require('chalk');
+const { default: ora } = require('ora');
+
+class ProgressIndicator {
+    constructor() {
+        this.activeSpinner = null;
+        this.startTime = null;
+    }
+
+    /**
+     * Inicia el indicador de progreso principal
+     * @param {string} message - Mensaje principal
+     */
+    start(message) {
+        console.log(`\n${chalk.cyan('●')} ${chalk.bold(message)}`);
+        this.startTime = Date.now();
+    }
+
+    /**
+     * Muestra progreso para una operación específica con tabla
+     * @param {string} tableName - Nombre de la tabla
+     * @param {string} operation - Tipo de operación (refresh, seeder, trigger)
+     * @param {string} databaseName - Nombre de la base de datos
+     */
+    async showTableProgress(tableName, operation, databaseName = '') {
+        const startTime = Date.now();
+        const maxDots = 50;
+        const operationText = this.getOperationText(operation);
+        
+        // Formatear el nombre para que tenga un ancho fijo
+        const displayName = databaseName ? `${databaseName}.${tableName}` : tableName;
+        const truncatedName = displayName.length > 30 ? 
+            displayName.substring(0, 27) + '...' : 
+            displayName.padEnd(30);
+
+        // Simular progreso con puntos
+        return new Promise((resolve) => {
+            process.stdout.write(`  ${chalk.gray('├─')} ${truncatedName} `);
+            
+            let dotCount = 0;
+            const interval = setInterval(() => {
+                if (dotCount < maxDots) {
+                    process.stdout.write(chalk.gray('.'));
+                    dotCount++;
+                } else {
+                    clearInterval(interval);
+                    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                    process.stdout.write(` ${chalk.green('✓')} ${chalk.gray(elapsed + 's')}\n`);
+                    resolve();
+                }
+            }, 20); // Velocidad de los puntos
+        });
+    }
+
+    /**
+     * Muestra progreso para múltiples tablas
+     * @param {Array} tables - Array de nombres de tablas
+     * @param {string} operation - Tipo de operación
+     * @param {string} databaseName - Nombre de la base de datos
+     * @param {Function} executor - Función que ejecuta la operación para cada tabla
+     */
+    async showMultipleTablesProgress(tables, operation, databaseName, executor) {
+        const operationText = this.getOperationText(operation);
+        console.log(`  ${chalk.blue('┌─')} ${operationText} en ${chalk.bold(databaseName)}:`);
+        
+        for (let i = 0; i < tables.length; i++) {
+            const table = tables[i];
+            const isLast = i === tables.length - 1;
+            
+            await this.showTableProgress(table, operation, '');
+            
+            if (executor) {
+                await executor(table);
+            }
+        }
+        
+        console.log(`  ${chalk.blue('└─')} ${chalk.green('Completado')}`);
+    }
+
+    /**
+     * Muestra progreso simple para operaciones generales
+     * @param {string} message - Mensaje a mostrar
+     * @param {Function} executor - Función a ejecutar
+     */
+    async showProgress(message, executor) {
+        const spinner = ora(message).start();
+        const startTime = Date.now();
+        
+        try {
+            const result = await executor();
+            const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+            spinner.succeed(`${message} ${chalk.gray(`(${elapsed}s)`)}`);
+            return result;
+        } catch (error) {
+            spinner.fail(`${message} ${chalk.red('falló')}`);
+            throw error;
+        }
+    }
+
+    /**
+     * Muestra el resumen final
+     * @param {string} operation - Tipo de operación
+     * @param {number} count - Cantidad de elementos procesados
+     * @param {number} databases - Cantidad de bases de datos
+     */
+    showSummary(operation, count, databases) {
+        const totalTime = this.startTime ? ((Date.now() - this.startTime) / 1000).toFixed(1) : '0.0';
+        const operationText = this.getOperationText(operation);
+        
+        console.log(`\n${chalk.green('🎉')} ${chalk.bold('Resumen:')}`);
+        console.log(`  ${chalk.gray('├─')} ${operationText}: ${chalk.cyan(count)} elementos`);
+        console.log(`  ${chalk.gray('├─')} Bases de datos: ${chalk.cyan(databases)}`);
+        console.log(`  ${chalk.gray('└─')} Tiempo total: ${chalk.cyan(totalTime + 's')}`);
+    }
+
+    /**
+     * Muestra error con formato
+     * @param {string} message - Mensaje de error
+     * @param {Error} error - Error objeto
+     */
+    showError(message, error) {
+        console.log(`\n${chalk.red('❌')} ${chalk.bold(message)}`);
+        if (error && error.message) {
+            console.log(`  ${chalk.gray('└─')} ${chalk.red(error.message)}`);
+        }
+    }
+
+    /**
+     * Obtiene el texto de la operación
+     * @param {string} operation - Tipo de operación
+     * @returns {string}
+     */
+    getOperationText(operation) {
+        const operations = {
+            'refresh': 'Refrescando tablas',
+            'seeder': 'Ejecutando seeders',
+            'trigger': 'Ejecutando triggers'
+        };
+        return operations[operation] || operation;
+    }
+
+    /**
+     * Limpia la pantalla y muestra encabezado
+     * @param {string} title - Título principal
+     * @param {string} emoji - Emoji a mostrar
+     */
+    showHeader(title, emoji = '🔄') {
+        console.clear();
+        console.log(`\n${emoji} ${chalk.green.bold(title)}`);
+        console.log(chalk.gray('─'.repeat(50)));
+    }
+}
+
+module.exports = ProgressIndicator;