@dbcube/cli 1.0.1

package/src/commands/run/table/refresh.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 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');
+        
+        // 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 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!`)}`);
+            }
+            
+        }
+    } 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/trigger/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 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');
+        
+        // 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 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!`)}`);
+            }
+            
+        }
+    } 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/index.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+const path = require('path');
+
+// Obtener los argumentos pasados al comando
+const args = process.argv.slice(2);
+
+// Procesar los argumentos
+let mainCommand = '';
+const commandArgs = [];
+
+if (args.length > 0) {
+  // Si el primer argumento es "run", combinamos con el segundo para formar el comando
+  if (args[0] === 'run' && args.length > 1) {
+    mainCommand = 'run:' + args[1];
+    // Añadir el resto de argumentos
+    for (let i = 2; i < args.length; i++) {
+      commandArgs.push(args[i]);
+    }
+  } else if (args[0].includes('create:')) {
+    // Si es un comando create: lo usamos directamente
+    mainCommand = args[0];
+    // Añadir el resto de argumentos
+    for (let i = 1; i < args.length; i++) {
+      commandArgs.push(args[i]);
+    }
+  } else {
+    // Para otros comandos, usamos el primer argumento como comando
+    mainCommand = args[0];
+    // Añadir el resto de argumentos
+    for (let i = 1; i < args.length; i++) {
+      commandArgs.push(args[i]);
+    }
+  }
+}
+
+// Mapa de comandos para mapear nombres de comandos a rutas de archivo
+const commandMap = {
+  'run:table:fresh': '../src/commands/run/table/fresh.js',
+  'run:table:refresh': '../src/commands/run/table/refresh.js',
+
+  'run:trigger:fresh': '../src/commands/run/trigger/fresh.js',
+
+  'run:seeder:add': '../src/commands/run/seeder/add.js',
+  
+  'run:database:create': '../src/commands/run/database/create/index.js',
+  'run:database:create:config': '../src/commands/run/database/create/addDatabaseConfig.js',
+  'run:database:create:physical': '../src/commands/run/database/create/createDatabase.js',
+};
+
+// Función para ejecutar comandos basados en los argumentos
+async function executeCommand(command, commandArgs) {
+  // Verificar si el comando existe en el mapa
+  if (commandMap[command]) {
+    const examplePath = path.join(__dirname, commandMap[command]);
+    
+    // Guardamos los argumentos originales
+    const originalArgv = process.argv;
+    
+    try {
+      // Reemplazamos los argumentos con los que necesitamos pasar al script
+      process.argv = [process.argv[0], process.argv[1], ...commandArgs];
+      await require(examplePath);
+    } finally {
+      // Restauramos los argumentos originales
+      process.argv = originalArgv;
+    }
+  } else {
+    // Comando desconocido
+    console.log(`Comando desconocido: ${command} ${commandArgs.join(' ')}`);
+    console.log('Comandos disponibles:');
+    for (const cmd in commandMap) {
+      let description = '';
+      switch (cmd) {
+        case 'run:cube:fresh':
+          description = 'Ejecuta el ejemplo de migración';
+          break;
+        case 'run:create:database':
+        case 'run:create:db':
+        case 'create:database':
+        case 'create:db':
+          if (!description) description = 'Crea una base de datos [--name=<nombre> | -n <nombre>] [--motor=<motor> | -m <motor>]';
+          break;
+        case 'run:create:database:config':
+          description = 'Agrega configuración de base de datos [--name=<nombre> | -n <nombre>] [--motor=<motor> | -m <motor>]';
+          break;
+        case 'run:create:database:physical':
+          description = 'Crea la base de datos física [--name=<nombre> | -n <nombre>]';
+          break;
+      }
+      if (description) console.log(`  ${cmd} - ${description}`);
+    }
+    process.exit(1);
+  }
+}
+
+// Ejecutar el comando correspondiente
+executeCommand(mainCommand, commandArgs).catch(err => {
+  console.error('Error inesperado:', err);
+  process.exit(1);
+});

package/src/lib/DBCubeLogger.js

@@ -0,0 +1,116 @@
+class DBCubeLogger {
+    constructor(title) {
+        this.logs = [];
+        this.maxLogs = 3;
+        this.title = title;
+        this.isWaiting = false;
+        this.animationInterval = null;
+        this.currentFace = 0;
+        this.faces = ['● ‿ ●', '● ‿ ●', '● ‿ <', '● ‿ <', '● ‿ ●', '● ‿ ●', '> ‿ ●', '> ‿ ●', '● ‿ ●', '● ‿ ●', '> ‿ <', '> ‿ <', '● ‿ ●', '● ‿ ●', '> ‿ <', '> ‿ <'];
+        
+        // Registrar globalmente para que LoggerConsole pueda acceder
+        global.dbcubeLogger = this;
+    }
+
+    // Función para limpiar solo el área superior de la consola
+    clearConsole() {
+        // Solo limpiar si estamos en modo división de consola
+        if (global.loggerConsoleInstances && global.loggerConsoleInstances.top && global.loggerConsoleInstances.top.isActive) {
+            // Usar el método clear interceptado que solo afecta al área superior
+            console.clear();
+        } else {
+            // Comportamiento normal si no hay división
+            console.clear();
+        }
+    }
+
+    // Función para dibujar el cubo con logs
+    drawCube() {
+        this.clearConsole();
+        console.log(this.title);
+        
+        // Mostrar logs anteriores (máximo 3)
+        for (let i = 0; i < this.logs.length - 3; i++) {
+            const log = this.logs[i];
+            if (i == 0) console.log('╭───────╮');
+            console.log('│───────│  ' + log.message);
+        }
+        
+        if (this.logs.length == 1) {
+            console.log('╭───────╮');
+            console.log('│───────│');
+            console.log('│───────│');
+        }
+        
+        if (this.logs.length == 2) {
+            const penPastLog = this.logs[this.logs.length - 2];
+            console.log('╭───────╮');
+            console.log('│───────│');
+            console.log('│───────│  ' + penPastLog.message);
+        }
+        
+        if (this.logs.length == 3) {
+            const penPastLog = this.logs[this.logs.length - 3];
+            const penPastLog2 = this.logs[this.logs.length - 2];
+            console.log('╭───────╮');
+            console.log('│───────│  ' + penPastLog.message);
+            console.log('│───────│  ' + penPastLog2.message);
+        }
+        
+        // Mostrar el cubo con cara en la última posición
+        if (this.logs.length > 0) {
+            const lastLog = this.logs[this.logs.length - 1];
+            const face = this.isWaiting ? this.faces[this.currentFace] : lastLog.face;
+            console.log('│ ' + face + ' │  ' + lastLog.message);
+            console.log('╰───────╯');
+        }
+    }
+
+    // Función para agregar un log
+    addLog(message, face) {
+        const log = { message, face };
+        this.logs.push(log);
+        
+        // Mantener máximo 3 logs
+        if (this.logs.length > this.maxLogs) {
+            this.logs.shift();
+        }
+        
+        if (!this.isWaiting) {
+            this.drawCube();
+        }
+    }
+
+    // Función para logs normales
+    info(message) {
+        this.addLog(message, '● ‿ ●');
+    }
+
+    // Función para logs de error
+    error(message) {
+        this.addLog(message, 'x _ x');
+    }
+
+    // Función para comenzar la animación de espera
+    wait() {
+        this.isWaiting = true;
+        this.currentFace = 0;
+        
+        this.animationInterval = setInterval(() => {
+            this.currentFace = (this.currentFace + 1) % this.faces.length;
+            this.drawCube();
+        }, 500); // Cambia cada 500ms
+    }
+
+    // Función para detener la animación
+    continue() {
+        this.isWaiting = false;
+        if (this.animationInterval) {
+            clearInterval(this.animationInterval);
+            this.animationInterval = null;
+        }
+        this.drawCube();
+    }
+}
+
+module.exports = DBCubeLogger;

package/src/lib/LoggerConsole.js

@@ -0,0 +1,262 @@
+class LoggerConsole {
+    constructor(topLines = null) {
+        this.topLines = topLines;
+        this.isTopConsole = topLines !== null && topLines !== undefined;
+        this.isActive = false;
+        this.originalConsole = {};
+        this.buffer = [];
+        this.bottomBuffer = [];
+        this.topBuffer = [];
+        this.terminalHeight = process.stdout.rows || 24;
+        this.terminalWidth = process.stdout.columns || 80;
+        
+        // Compartir instancias globalmente
+        if (!global.loggerConsoleInstances) {
+            global.loggerConsoleInstances = {
+                top: null,
+                bottom: null,
+                sharedState: {
+                    topBuffer: [],
+                    bottomBuffer: [],
+                    activeInstance: null
+                }
+            };
+        }
+        
+        // Registrar la instancia
+        if (this.isTopConsole) {
+            global.loggerConsoleInstances.top = this;
+        } else {
+            global.loggerConsoleInstances.bottom = this;
+        }
+    }
+
+    start() {
+        if (this.isActive) return;
+        
+        this.isActive = true;
+        global.loggerConsoleInstances.sharedState.activeInstance = this;
+        
+        // Interceptar console methods solo para la instancia activa
+        if (this.isTopConsole) {
+            this.interceptConsole();
+        }
+        
+        // Configurar el terminal
+        this.setupTerminal();
+        
+        // Render inicial
+        this.render();
+    }
+
+    end() {
+        if (!this.isActive) return;
+        
+        this.isActive = false;
+
+        // Restaurar console original
+        if (this.isTopConsole) {
+            this.restoreConsole();
+        }
+        
+        // Limpiar terminal
+        this.cleanup();
+        
+        
+        global.loggerConsoleInstances.sharedState.activeInstance = null;
+    }
+
+    setupTerminal() {
+        // Ocultar cursor
+        process.stdout.write('\x1B[?25l');
+        
+        // Limpiar pantalla
+        process.stdout.write('\x1B[2J\x1B[H');
+        
+        // Configurar el área de trabajo
+        this.reserveArea();
+    }
+
+    reserveArea() {
+        if (this.isTopConsole) {
+            // Reservar líneas superiores
+            for (let i = 0; i < this.topLines; i++) {
+                process.stdout.write('\n');
+            }
+            // Posicionar cursor en la primera línea reservada
+            process.stdout.write(`\x1B[${this.topLines}A`);
+        } else {
+            // Posicionar cursor en la parte inferior
+            const bottomStartLine = (global.loggerConsoleInstances.top?.topLines || 0) + 2;
+            process.stdout.write(`\x1B[${bottomStartLine};1H`);
+        }
+    }
+
+    interceptConsole() {
+        // Guardar métodos originales
+        this.originalConsole.log = console.log;
+        this.originalConsole.info = console.info;
+        this.originalConsole.error = console.error;
+        this.originalConsole.warn = console.warn;
+        this.originalConsole.clear = console.clear;
+
+        // Interceptar console.log para la consola superior
+        console.log = (...args) => {
+            if (this.isActive && this.isTopConsole) {
+                this.addToTopBuffer(args.join(' '));
+                this.render();
+            }
+        };
+
+        console.info = (...args) => {
+            if (this.isActive && this.isTopConsole) {
+                this.addToTopBuffer(args.join(' '));
+                this.render();
+            }
+        };
+
+        console.error = (...args) => {
+            if (this.isActive && this.isTopConsole) {
+                this.addToTopBuffer(args.join(' '));
+                this.render();
+            }
+        };
+
+        console.warn = (...args) => {
+            if (this.isActive && this.isTopConsole) {
+                this.addToTopBuffer(args.join(' '));
+                this.render();
+            }
+        };
+
+        console.clear = () => {
+            if (this.isActive && this.isTopConsole) {
+                this.clearTopBuffer();
+                this.render();
+            }
+        };
+    }
+
+    restoreConsole() {
+        console.log = this.originalConsole.log;
+        console.info = this.originalConsole.info;
+        console.error = this.originalConsole.error;
+        console.warn = this.originalConsole.warn;
+        console.clear = this.originalConsole.clear;
+    }
+
+    addToTopBuffer(message) {
+        global.loggerConsoleInstances.sharedState.topBuffer.push(message);
+        
+        // Mantener solo las líneas necesarias
+        if (global.loggerConsoleInstances.sharedState.topBuffer.length > this.topLines) {
+            global.loggerConsoleInstances.sharedState.topBuffer.shift();
+        }
+    }
+
+    addToBottomBuffer(message) {
+        global.loggerConsoleInstances.sharedState.bottomBuffer.push(message);
+    }
+
+    clearTopBuffer() {
+        global.loggerConsoleInstances.sharedState.topBuffer = [];
+    }
+
+    render() {
+        if (!this.isActive) return;
+        
+        if (this.isTopConsole) {
+            this.renderTopArea();
+        } else {
+            this.renderBottomArea();
+        }
+    }
+
+    renderTopArea() {
+        // Guardar posición del cursor
+        process.stdout.write('\x1B[s');
+        
+        // Ir al inicio del área superior
+        process.stdout.write('\x1B[1;1H');
+        
+        // Limpiar área superior
+        for (let i = 0; i < this.topLines; i++) {
+            process.stdout.write('\x1B[2K'); // Limpiar línea
+            if (i < this.topLines - 1) process.stdout.write('\n');
+        }
+        
+        // Volver al inicio del área superior
+        process.stdout.write('\x1B[1;1H');
+        
+        // Renderizar buffer superior
+        const topBuffer = global.loggerConsoleInstances.sharedState.topBuffer;
+        for (let i = 0; i < Math.min(topBuffer.length, this.topLines); i++) {
+            process.stdout.write(topBuffer[i]);
+            if (i < Math.min(topBuffer.length, this.topLines) - 1) {
+                process.stdout.write('\n');
+            }
+        }
+        
+        // Restaurar posición del cursor
+        process.stdout.write('\x1B[u');
+    }
+
+    renderBottomArea() {
+        const topLines = global.loggerConsoleInstances.top?.topLines || 0;
+        const separatorLine = topLines + 1;
+        const bottomStartLine = topLines + 2;
+        
+        // Dibujar separador
+        process.stdout.write(`\x1B[${separatorLine};1H`);
+        process.stdout.write('\x1B[2K');
+        process.stdout.write('─'.repeat(this.terminalWidth));
+        
+        // Posicionar cursor en área inferior
+        process.stdout.write(`\x1B[${bottomStartLine};1H`);
+    }
+
+    cleanup() {
+        // Mostrar cursor
+        process.stdout.write('\x1B[?25h');
+        
+        // Ir al final de la pantalla
+        process.stdout.write(`\x1B[${this.terminalHeight};1H`);
+        
+        // Limpiar pantalla si es necesario
+        if (this.isTopConsole) {
+            process.stdout.write('\x1B[2J\x1B[H');
+        }
+    }
+
+    // Método para enviar logs desde la consola inferior a la superior
+    sendToTop(message, type = 'info') {
+        if (global.loggerConsoleInstances.top && global.loggerConsoleInstances.top.isActive) {
+            // Simular llamada al método del DBCubeLogger
+            if (global.dbcubeLogger) {
+                switch (type) {
+                    case 'info':
+                        global.dbcubeLogger.info(message);
+                        break;
+                    case 'error':
+                        global.dbcubeLogger.error(message);
+                        break;
+                    case 'wait':
+                        global.dbcubeLogger.wait();
+                        break;
+                    case 'continue':
+                        global.dbcubeLogger.continue();
+                        break;
+                }
+            }
+        }
+    }
+
+    // Método estático para facilitar el envío de logs
+    static sendToTop(message, type = 'info') {
+        if (global.loggerConsoleInstances.bottom) {
+            global.loggerConsoleInstances.bottom.sendToTop(message, type);
+        }
+    }
+}
+
+module.exports = LoggerConsole;

package/src/utils/Config.js

@@ -0,0 +1,49 @@
+/**
+ * Clase para manejar la configuración del ORM
+ */
+class Config {
+  constructor() {
+    this.data = {};
+    this.databases = {};
+  }
+
+  /**
+   * Establece la configuración
+   * @param {Object} configData - Datos de configuración
+   */
+  set(configData) {
+    this.data = configData;
+    
+    if (configData.databases) {
+      this.databases = configData.databases;
+    }
+  }
+
+  /**
+   * Obtiene un valor de configuración
+   * @param {string} key - Clave de configuración
+   * @returns {any} - Valor de configuración
+   */
+  get(key) {
+    return this.data[key];
+  }
+
+  /**
+   * Obtiene la configuración de una base de datos específica
+   * @param {string} dbName - Nombre de la base de datos
+   * @returns {Object} - Configuración de la base de datos
+   */
+  getDatabase(dbName) {
+    return this.databases[dbName] || null;
+  }
+
+  /**
+   * Obtiene todas las bases de datos configuradas
+   * @returns {Object} - Todas las configuraciones de bases de datos
+   */
+  getAllDatabases() {
+    return this.databases;
+  }
+}
+
+module.exports = Config;