dbcube 0.0.1 → 1.0.1

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);

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;