@dbcube/cli 5.1.4 → 5.2.1

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

@@ -1,35 +1,81 @@
-const { Schema } = require('@dbcube/schema-builder');
-const ConfigFileUtils = require('./../../../utils/ConfigFileUtils');
-
-async function main() {
-  try {
-    const args = process.argv.slice(2);
-    const runSeeders = args.includes('--seeder');
-
-    const configuredDatabases = await ConfigFileUtils.getConfiguredDatabases();
-
-    for (const config of configuredDatabases) {
-      const schema = new Schema(config.name);
-      await schema.freshTables();
-      if (runSeeders) {
-        await schema.executeSeeders();
-      }
-    }
-  } 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);
-    }
-  }
-}
-
-// Ejecutar el ejemplo
-main().catch(console.error);
+const chalk = require('chalk');
+const { Schema } = require('@dbcube/schema-builder');
+const ConfigFileUtils = require('./../../../utils/ConfigFileUtils');
+
+/**
+ * dbcube run table:fresh [--seeder] [--force]
+ * DESTRUCTIVO: dropea y recrea todas las tablas desde los .table.cube.
+ * Pide confirmación ESCRITA (el nombre de la base de datos) salvo con --force.
+ */
+async function confirmDestruction(databases) {
+  const { input } = require('@inquirer/prompts');
+
+  console.log('');
+  console.log(`  ${chalk.bgRed.white.bold(' ⚠ DESTRUCTIVE OPERATION ')}`);
+  console.log('');
+  console.log(`  ${chalk.red('table:fresh will DROP and recreate ALL tables.')}`);
+  console.log(`  ${chalk.red.bold('ALL DATA WILL BE PERMANENTLY LOST')} in:`);
+  for (const db of databases) {
+    console.log(`    ${chalk.yellow('•')} ${chalk.bold(db.name)} ${chalk.gray(`(${db.type})`)}`);
+  }
+  console.log('');
+  console.log(`  ${chalk.gray('To update schemas WITHOUT losing data use:')} ${chalk.white('npx dbcube run table:refresh')}`);
+  console.log('');
+
+  const expected = databases.length === 1 ? databases[0].name : 'all';
+  const answer = await input({
+    message: `Type ${chalk.bold(expected)} to confirm (anything else aborts):`,
+  });
+
+  return answer.trim() === expected;
+}
+
+async function main() {
+  try {
+    const args = process.argv.slice(2);
+    const runSeeders = args.includes('--seeder');
+    const force = args.includes('--force') || args.includes('-y') || args.includes('--yes');
+
+    const configuredDatabases = await ConfigFileUtils.getConfiguredDatabases();
+
+    if (!force) {
+      if (!process.stdin.isTTY) {
+        console.error(`\n${chalk.red('❌ table:fresh is destructive and needs confirmation.')}`);
+        console.error(`${chalk.gray('Non-interactive environment detected — pass')} ${chalk.white('--force')} ${chalk.gray('to proceed (e.g. in CI).')}\n`);
+        process.exit(1);
+      }
+      const confirmed = await confirmDestruction(configuredDatabases);
+      if (!confirmed) {
+        console.log(`\n${chalk.yellow('Aborted.')} ${chalk.gray('No changes were made.')}\n`);
+        process.exit(0);
+      }
+    }
+
+    for (const config of configuredDatabases) {
+      const schema = new Schema(config.name);
+      await schema.freshTables();
+      if (runSeeders) {
+        await schema.executeSeeders();
+      }
+    }
+  } catch (error) {
+    if (error.name === 'ExitPromptError') {
+      console.log(`\n${chalk.yellow('Aborted.')} ${chalk.gray('No changes were made.')}\n`);
+      process.exit(0);
+    }
+    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 database:create`);
+      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:', error.message);
+      process.exit(1);
+    }
+  }
+}
+
+main().catch(console.error);

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

@@ -2,7 +2,6 @@ const { Schema } = require('@dbcube/schema-builder');
 const ConfigFileUtils = require('./../../../utils/ConfigFileUtils');
 
 async function main() {
-  console.clear();
   try {
     const configuredDatabases = await ConfigFileUtils.getConfiguredDatabases();
     // Recorrer cada archivo y mostrar su contenido
@@ -14,14 +13,15 @@ async function main() {
     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(`\tnpx dbcube run database:create`);
       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.error(`❌ ${error.message}`);
+      if (process.env.DEBUG) console.error(error);
+      process.exit(1);
     }
   }
 }

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

@@ -14,14 +14,15 @@ async function main() {
     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(`\tnpx dbcube run database:create`);
       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.error(`❌ ${error.message}`);
+      if (process.env.DEBUG) console.error(error);
+      process.exit(1);
     }
   }
   console.log('\n');

package/src/commands/validate.js

@@ -0,0 +1,70 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { CubeValidator } = require('@dbcube/schema-builder');
+
+/**
+ * dbcube validate — Validates every .cube file in dbcube/ without executing
+ * anything. Exit code 1 when any file is invalid (CI-friendly).
+ */
+function collectCubeFiles(dir, acc = []) {
+    if (!fs.existsSync(dir)) return acc;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (!['triggers', 'logs', 'node_modules'].includes(entry.name)) collectCubeFiles(full, acc);
+        } else if (entry.name.endsWith('.cube')) {
+            acc.push(full);
+        }
+    }
+    return acc;
+}
+
+async function main() {
+    const cubesDir = path.join(process.cwd(), 'dbcube');
+    const files = collectCubeFiles(cubesDir);
+
+    if (files.length === 0) {
+        console.log(`${chalk.yellow('⚠')} No .cube files found in dbcube/`);
+        process.exit(0);
+    }
+
+    console.log(`\n🔎 ${chalk.green('Validating')} ${files.length} cube file(s)...\n`);
+
+    const validator = new CubeValidator();
+    let errorCount = 0;
+
+    for (const file of files) {
+        const rel = path.relative(process.cwd(), file);
+        // CubeValidator covers .table.cube structure; other types get a syntax-level pass
+        let result;
+        try {
+            result = validator.validateCubeFile(file);
+        } catch (e) {
+            result = { isValid: false, errors: [{ error: e.message, lineNumber: 1 }] };
+        }
+
+        if (result.isValid) {
+            console.log(`  ${chalk.green('✓')} ${rel}`);
+        } else {
+            errorCount++;
+            console.log(`  ${chalk.red('✗')} ${rel}`);
+            for (const err of result.errors) {
+                const line = err.lineNumber ? chalk.gray(`:${err.lineNumber}`) : '';
+                console.log(`      ${chalk.red('[error]')} ${err.error}${line}`);
+            }
+        }
+    }
+
+    console.log('');
+    if (errorCount > 0) {
+        console.log(`${chalk.red('✗')} ${errorCount} file(s) with errors\n`);
+        process.exit(1);
+    }
+    console.log(`${chalk.green('✓')} All cube files are valid\n`);
+}
+
+main().catch(error => {
+    console.error('Error fatal:', error);
+    process.exit(1);
+});

package/src/commands/version.js

@@ -1,29 +1,66 @@
-const path = require('path');
-const fs = require('fs');
-const chalk = require('chalk');
-
-/**
- * Muestra la versión actual del CLI de Dbcube
- */
-async function showVersion() {
-    try {
-        // Leer el package.json del CLI
-        const packageJsonPath = path.join(__dirname, '../../package.json');
-        const packageData = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-        
-        console.log(`\n${chalk.green('🚀 Dbcube CLI')}`);
-        console.log(`${chalk.cyan('Versión:')} ${chalk.bold(packageData.version)}`);
-        console.log(`${chalk.cyan('Nombre:')} ${packageData.name}`);
-        console.log(`${chalk.gray('Licencia:')} ${packageData.license}\n`);
-        
-    } catch (error) {
-        console.error('❌ Error al obtener la versión:', error.message);
-        process.exit(1);
-    }
-}
-
-// Ejecutar función
-showVersion().catch(error => {
-    console.error('Error fatal:', error);
-    process.exit(1);
-});
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+
+/**
+ * dbcube version — CLI, packages, engine binaries, and environment info.
+ */
+function readVersion(pkgPath) {
+    try {
+        return JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version;
+    } catch {
+        return null;
+    }
+}
+
+function findEngineVersions() {
+    const binDir = path.join(process.cwd(), '.dbcube', 'bin');
+    const engines = {};
+    try {
+        for (const f of fs.readdirSync(binDir)) {
+            const m = f.match(/^(query-engine|schema-engine|sqlite-engine)-v([\d.]+)-/);
+            if (m) engines[m[1]] = `v${m[2]}`;
+        }
+    } catch { /* no binaries downloaded yet */ }
+    return engines;
+}
+
+async function showVersion() {
+    try {
+        const cliVersion = readVersion(path.join(__dirname, '../../package.json'));
+        const row = (label, value, dim = false) =>
+            console.log(`  ${chalk.gray(label.padEnd(16))} ${dim ? chalk.gray(value) : chalk.white(value)}`);
+
+        console.log('');
+        console.log(`  ${chalk.green.bold('▣ DBCube CLI')} ${chalk.bold('v' + cliVersion)}`);
+        console.log(`  ${chalk.gray('─'.repeat(40))}`);
+
+        // Local package versions (when resolvable from the project)
+        const localPkgs = ['dbcube', '@dbcube/query-builder', '@dbcube/schema-builder', '@dbcube/core'];
+        for (const pkg of localPkgs) {
+            try {
+                const pkgJson = require.resolve(`${pkg}/package.json`, { paths: [process.cwd()] });
+                const v = readVersion(pkgJson);
+                if (v) row(pkg, 'v' + v);
+            } catch { /* not installed in this project */ }
+        }
+
+        const engines = findEngineVersions();
+        for (const [name, v] of Object.entries(engines)) {
+            row(name, `${v} ${chalk.gray('(rust)')}`);
+        }
+
+        console.log(`  ${chalk.gray('─'.repeat(40))}`);
+        row('node', process.version, true);
+        row('platform', `${process.platform}-${process.arch}`, true);
+        console.log('');
+    } catch (error) {
+        console.error('❌ Error al obtener la versión:', error.message);
+        process.exit(1);
+    }
+}
+
+showVersion().catch(error => {
+    console.error('Error fatal:', error);
+    process.exit(1);
+});

package/src/index.js

@@ -1,92 +1,162 @@
-#!/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:table:alter': '../src/commands/run/table/alter.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',
-
-  'run:download': '../src/commands/run/download.js',
-  'run:update': '../src/commands/run/update.js',
-
-  'update': '../src/commands/update.js',
-
-  '--version': '../src/commands/version.js',
-  '-v': '../src/commands/version.js',
-
-  '--help': '../src/commands/help.js',
-  '-h': '../src/commands/help.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 - mostrar help
-    const chalk = require('chalk');
-    console.log(`\n${chalk.red('❌ Unknown command:')} ${command} ${commandArgs.join(' ')}\n`);
-    console.log(`${chalk.cyan('Run')} ${chalk.yellow('npx dbcube help')} ${chalk.cyan('to see all available commands.')}\n`);
-    process.exit(1);
-  }
-}
-
-// Ejecutar el comando correspondiente
-executeCommand(mainCommand, commandArgs).catch(err => {
-  console.error('Error inesperado:', err);
-  process.exit(1);
-});
+#!/usr/bin/env node
+const path = require('path');
+const chalk = require('chalk');
+
+// 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];
+    for (let i = 2; i < args.length; i++) {
+      commandArgs.push(args[i]);
+    }
+  } else if (args[0].includes('create:')) {
+    mainCommand = args[0];
+    for (let i = 1; i < args.length; i++) {
+      commandArgs.push(args[i]);
+    }
+  } else {
+    mainCommand = args[0];
+    for (let i = 1; i < args.length; i++) {
+      commandArgs.push(args[i]);
+    }
+  }
+} else {
+  // Sin argumentos: mostrar ayuda en lugar de fallar
+  mainCommand = '--help';
+}
+
+// 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:table:alter': '../src/commands/run/table/alter.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',
+  // Alias sin "run" (el help histórico lo documenta así)
+  'database:create': '../src/commands/run/database/create/index.js',
+
+  'run:pull': '../src/commands/run/pull.js',
+
+  'run:download': '../src/commands/run/download.js',
+  'run:update': '../src/commands/run/update.js',
+
+  'init': '../src/commands/init.js',
+  'generate': '../src/commands/generate.js',
+  'validate': '../src/commands/validate.js',
+  'doctor': '../src/commands/doctor.js',
+  'dev': '../src/commands/dev.js',
+
+  'migrate:status': '../src/commands/migrate/status.js',
+  'migrate:rollback': '../src/commands/migrate/rollback.js',
+
+  'update': '../src/commands/update.js',
+
+  'version': '../src/commands/version.js',
+  '--version': '../src/commands/version.js',
+  '-v': '../src/commands/version.js',
+
+  'help': '../src/commands/help.js',
+  '--help': '../src/commands/help.js',
+  '-h': '../src/commands/help.js',
+};
+
+// Distancia de Levenshtein para sugerencias "did you mean"
+function levenshtein(a, b) {
+  const m = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+  for (let j = 0; j <= b.length; j++) m[0][j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      m[i][j] = Math.min(
+        m[i - 1][j] + 1,
+        m[i][j - 1] + 1,
+        m[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)
+      );
+    }
+  }
+  return m[a.length][b.length];
+}
+
+function suggestCommand(input) {
+  // Candidatos: forma completa ("run table:fresh") y forma corta ("table:fresh"),
+  // ambos mostrando siempre la forma completa al usuario.
+  const candidates = [];
+  for (const c of Object.keys(commandMap)) {
+    if (c.startsWith('-')) continue;
+    if (c.startsWith('run:')) {
+      const display = 'run ' + c.slice(4);
+      candidates.push({ match: display, display });
+      candidates.push({ match: c.slice(4), display });
+    } else {
+      candidates.push({ match: c, display: c });
+    }
+  }
+
+  const scored = candidates
+    .map(({ match, display }) => ({ display, d: levenshtein(input.toLowerCase(), match.toLowerCase()) }))
+    .sort((x, y) => x.d - y.d);
+
+  if (scored.length === 0 || scored[0].d > Math.max(3, Math.floor(input.length / 2))) return [];
+
+  const seen = new Set();
+  return scored
+    .filter(s => s.d <= scored[0].d + 1)
+    .filter(s => !seen.has(s.display) && seen.add(s.display))
+    .slice(0, 3)
+    .map(s => s.display);
+}
+
+// Función para ejecutar comandos basados en los argumentos
+async function executeCommand(command, commandArgs) {
+  if (commandMap[command]) {
+    const examplePath = path.join(__dirname, commandMap[command]);
+    const originalArgv = process.argv;
+
+    try {
+      process.argv = [process.argv[0], process.argv[1], ...commandArgs];
+      await require(examplePath);
+    } finally {
+      process.argv = originalArgv;
+    }
+  } else {
+    // Comando desconocido: error claro + sugerencias
+    const typed = [args[0], args[1]].filter(Boolean).join(' ');
+    console.log('');
+    console.log(`  ${chalk.bgRed.white.bold(' ERROR ')} ${chalk.red(`Unknown command:`)} ${chalk.bold(typed)}`);
+
+    const suggestions = suggestCommand(typed);
+    if (suggestions.length > 0) {
+      console.log('');
+      console.log(`  ${chalk.cyan('Did you mean:')}`);
+      for (const s of suggestions) {
+        console.log(`    ${chalk.green('→')} ${chalk.white('npx dbcube ' + s)}`);
+      }
+    }
+
+    console.log('');
+    console.log(`  ${chalk.gray('Run')} ${chalk.yellow('npx dbcube help')} ${chalk.gray('to see all available commands.')}`);
+    console.log('');
+    process.exit(1);
+  }
+}
+
+// Ejecutar el comando correspondiente
+executeCommand(mainCommand, commandArgs).catch(err => {
+  console.log('');
+  console.log(`  ${chalk.bgRed.white.bold(' FATAL ')} ${chalk.red(err.message)}`);
+  console.log(`  ${chalk.gray('Run')} ${chalk.yellow('npx dbcube doctor')} ${chalk.gray('to diagnose your setup.')}`);
+  console.log('');
+  process.exit(1);
+});

package/src/utils/ConfigFileUtils.js

@@ -78,8 +78,9 @@ class ConfigFileUtils {
             }
             return arrayDatabases;
         } catch (error) {
-            console.error('Error al cargar las bases de datos desde ' + configPath, error);
-            return ['test1']; // Valor por defecto
+            // Fallar claro: devolver una DB inventada ocultaría el problema
+            // y haría que los comandos operen contra una base inexistente
+            throw new Error(`No se pudo cargar la configuración desde ${configPath}: ${error.message}`);
         }
     }
 

package/.npmignore

@@ -1,58 +0,0 @@
-# Directories
-examples
-
-# Ignorar dependencias y configuraciones de desarrollo
-node_modules/
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# Ignorar carpetas y archivos irrelevantes
-.vscode/
-.lh
-.idea/
-.DS_Store
-Thumbs.db
-*.log
-
-# Ignorar configuraciones del proyecto
-.env
-.env.*.local
-package-lock.json
-
-# Ignorar archivos del sistema
-*.swp
-*.swo
-*.tmp
-*.temp
-
-# Ignorar carpetas de trabajo
-temp/
-logs/
-debug/
-
-# Ignorar archivos de compilación
-src/
-tsconfig.json
-tsconfig.tsbuildinfo
-
-# Ignorar pruebas y configuraciones
-tests/
-__tests__/
-__mocks__/
-coverage/
-jest.config.js
-
-# Ignorar documentación o ejemplos no necesarios
-docs/
-examples/
-
-# Asegurarse de incluir solo lo esencial
-!.npmignore
-tsconfig.json
-tsup.config.ts
-
-.dbcube
-dbcube
-.env
-*.db