mpx-db 1.0.0

package/src/cli.js

@@ -0,0 +1,141 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { handleConnect, listConnections, removeConnection } from './commands/connections.js';
+import { handleQuery } from './commands/query.js';
+import { showInfo, listTables, describeTable, dumpSchema } from './commands/schema.js';
+import { 
+  initMigrations, 
+  createMigration, 
+  showMigrationStatus, 
+  runMigrations, 
+  rollbackMigration 
+} from './commands/migrate.js';
+import { exportData } from './commands/data.js';
+
+const program = new Command();
+
+program
+  .name('mpx-db')
+  .description('Database management CLI - Connect, query, migrate, and manage databases')
+  .version('1.0.0');
+
+// Connect command
+program
+  .command('connect')
+  .description('Test and optionally save a database connection')
+  .argument('<url>', 'Connection URL (sqlite://, postgres://, mysql://)')
+  .option('-s, --save <name>', 'Save connection with a name')
+  .action(handleConnect);
+
+// Connections command
+const connections = program
+  .command('connections')
+  .description('Manage saved connections');
+
+connections
+  .command('list')
+  .description('List all saved connections')
+  .action(listConnections);
+
+connections
+  .command('remove')
+  .description('Remove a saved connection')
+  .argument('<name>', 'Connection name')
+  .action(removeConnection);
+
+// Query command
+program
+  .command('query')
+  .description('Execute a SQL query')
+  .argument('<target>', 'Connection name or URL')
+  .argument('<sql>', 'SQL query to execute')
+  .action(handleQuery);
+
+// Info command
+program
+  .command('info')
+  .description('Show database information')
+  .argument('<target>', 'Connection name or URL')
+  .action(showInfo);
+
+// Tables command
+program
+  .command('tables')
+  .description('List all tables')
+  .argument('<target>', 'Connection name or URL')
+  .action(listTables);
+
+// Describe command
+program
+  .command('describe')
+  .description('Show table schema')
+  .argument('<target>', 'Connection name or URL')
+  .argument('<table>', 'Table name')
+  .action(describeTable);
+
+// Schema commands
+const schema = program
+  .command('schema')
+  .description('Schema operations');
+
+schema
+  .command('dump')
+  .description('Dump database schema as SQL')
+  .argument('<target>', 'Connection name or URL')
+  .action(dumpSchema);
+
+// Migration commands
+const migrate = program
+  .command('migrate')
+  .description('Database migration commands');
+
+migrate
+  .command('init')
+  .description('Initialize migrations directory')
+  .action(initMigrations);
+
+migrate
+  .command('create')
+  .description('Create a new migration file')
+  .argument('<description>', 'Migration description')
+  .action(createMigration);
+
+migrate
+  .command('status')
+  .description('Show migration status')
+  .argument('<target>', 'Connection name or URL')
+  .action(showMigrationStatus);
+
+migrate
+  .command('up')
+  .description('Run pending migrations')
+  .argument('<target>', 'Connection name or URL')
+  .action(runMigrations);
+
+migrate
+  .command('down')
+  .description('Rollback last migration')
+  .argument('<target>', 'Connection name or URL')
+  .action(rollbackMigration);
+
+// Export command
+program
+  .command('export')
+  .description('Export table data')
+  .argument('<target>', 'Connection name or URL')
+  .argument('<table>', 'Table name')
+  .option('-f, --format <format>', 'Output format (json, csv)', 'json')
+  .option('-o, --output <file>', 'Output file path')
+  .action(exportData);
+
+// Error handling
+program.exitOverride();
+
+try {
+  await program.parseAsync(process.argv);
+} catch (err) {
+  if (err.code !== 'commander.help' && err.code !== 'commander.helpDisplayed') {
+    console.error(chalk.red(`Error: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/connections.js

@@ -0,0 +1,79 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { saveConnection, loadConnections, deleteConnection } from '../utils/config.js';
+import { createConnection } from '../db/connection.js';
+
+/**
+ * Handle connect command
+ */
+export async function handleConnect(url, options) {
+  try {
+    // Test connection
+    console.log(chalk.gray('Testing connection...'));
+    const db = await createConnection(url);
+    const info = await db.getInfo();
+    await db.disconnect();
+    
+    console.log(chalk.green('✓ Connection successful'));
+    console.log(chalk.gray(`  Type: ${info.type}`));
+    if (info.database) {
+      console.log(chalk.gray(`  Database: ${info.database}`));
+    }
+    if (info.path) {
+      console.log(chalk.gray(`  Path: ${info.path}`));
+    }
+    
+    // Save if requested
+    if (options.save) {
+      saveConnection(options.save, url);
+      console.log(chalk.green(`✓ Saved connection as "${options.save}"`));
+    }
+    
+  } catch (err) {
+    console.error(chalk.red('✗ Connection failed'));
+    console.error(chalk.red(`  ${err.message}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * List saved connections
+ */
+export async function listConnections() {
+  const connections = loadConnections();
+  
+  if (Object.keys(connections).length === 0) {
+    console.log(chalk.yellow('No saved connections'));
+    console.log(chalk.gray('\nSave a connection with:'));
+    console.log(chalk.gray('  mpx-db connect --save <name> <url>'));
+    return;
+  }
+  
+  const table = new Table({
+    head: ['Name', 'Type', 'Created'].map(h => chalk.cyan(h)),
+    style: { head: [], border: ['gray'] }
+  });
+  
+  for (const [name, conn] of Object.entries(connections)) {
+    table.push([
+      chalk.white(name),
+      chalk.gray(conn.type),
+      chalk.gray(new Date(conn.createdAt).toLocaleDateString())
+    ]);
+  }
+  
+  console.log(table.toString());
+}
+
+/**
+ * Delete a saved connection
+ */
+export async function removeConnection(name) {
+  const deleted = deleteConnection(name);
+  
+  if (deleted) {
+    console.log(chalk.green(`✓ Deleted connection "${name}"`));
+  } else {
+    console.log(chalk.yellow(`Connection "${name}" not found`));
+  }
+}

package/src/commands/data.js

@@ -0,0 +1,79 @@
+import fs from 'fs';
+import chalk from 'chalk';
+import { createConnection } from '../db/connection.js';
+import { resolveConnection } from './query.js';
+
+/**
+ * Export table data to CSV or JSON
+ */
+export async function exportData(target, tableName, options) {
+  let db;
+  
+  try {
+    const connectionString = await resolveConnection(target);
+    db = await createConnection(connectionString);
+    
+    // Query all data
+    const rows = await db.query(`SELECT * FROM ${tableName}`);
+    
+    if (rows.length === 0) {
+      console.log(chalk.yellow('No data to export'));
+      return;
+    }
+    
+    const format = options.format || 'json';
+    const output = options.output || `${tableName}.${format}`;
+    
+    let content;
+    
+    if (format === 'json') {
+      content = JSON.stringify(rows, null, 2);
+    } else if (format === 'csv') {
+      content = convertToCSV(rows);
+    } else {
+      throw new Error(`Unsupported format: ${format}`);
+    }
+    
+    fs.writeFileSync(output, content);
+    
+    console.log(chalk.green(`✓ Exported ${rows.length} rows to ${output}`));
+    
+  } catch (err) {
+    console.error(chalk.red(`✗ Export failed: ${err.message}`));
+    process.exit(1);
+  } finally {
+    if (db) {
+      await db.disconnect();
+    }
+  }
+}
+
+/**
+ * Convert rows to CSV
+ */
+function convertToCSV(rows) {
+  if (rows.length === 0) return '';
+  
+  const columns = Object.keys(rows[0]);
+  const header = columns.map(escapeCSV).join(',');
+  
+  const lines = rows.map(row => {
+    return columns.map(col => {
+      const val = row[col];
+      if (val === null) return '';
+      return escapeCSV(String(val));
+    }).join(',');
+  });
+  
+  return [header, ...lines].join('\n');
+}
+
+/**
+ * Escape CSV field
+ */
+function escapeCSV(field) {
+  if (field.includes(',') || field.includes('"') || field.includes('\n')) {
+    return `"${field.replace(/"/g, '""')}"`;
+  }
+  return field;
+}

package/src/commands/migrate.js

@@ -0,0 +1,318 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { createConnection } from '../db/connection.js';
+import { resolveConnection } from './query.js';
+
+const MIGRATIONS_DIR = './migrations';
+
+/**
+ * Initialize migrations directory
+ */
+export async function initMigrations() {
+  if (fs.existsSync(MIGRATIONS_DIR)) {
+    console.log(chalk.yellow('Migrations directory already exists'));
+    return;
+  }
+  
+  fs.mkdirSync(MIGRATIONS_DIR, { recursive: true });
+  
+  // Create README
+  const readme = `# Database Migrations
+
+This directory contains database migration files.
+
+## File naming convention
+
+Migrations are named: \`YYYYMMDD_HHMMSS_description.sql\`
+
+Example: \`20260215_143022_create_users_table.sql\`
+
+## Migration format
+
+Each migration file should contain SQL statements:
+
+\`\`\`sql
+-- Up migration
+CREATE TABLE users (
+  id INTEGER PRIMARY KEY,
+  name TEXT NOT NULL,
+  email TEXT UNIQUE NOT NULL
+);
+
+-- Down migration (optional, after -- DOWN marker)
+-- DOWN
+DROP TABLE users;
+\`\`\`
+
+## Commands
+
+- \`mpx-db migrate create <description>\` - Create new migration
+- \`mpx-db migrate status <connection>\` - Show migration status
+- \`mpx-db migrate up <connection>\` - Run pending migrations
+- \`mpx-db migrate down <connection>\` - Rollback last migration
+`;
+  
+  fs.writeFileSync(path.join(MIGRATIONS_DIR, 'README.md'), readme);
+  
+  console.log(chalk.green('✓ Migrations directory created'));
+  console.log(chalk.gray(`  ${MIGRATIONS_DIR}/`));
+}
+
+/**
+ * Create new migration file
+ */
+export async function createMigration(description) {
+  if (!fs.existsSync(MIGRATIONS_DIR)) {
+    console.log(chalk.yellow('Migrations directory not found. Run: mpx-db migrate init'));
+    return;
+  }
+  
+  // Generate timestamp-based filename
+  const timestamp = new Date()
+    .toISOString()
+    .replace(/[-:]/g, '')
+    .replace(/\..+/, '')
+    .replace('T', '_');
+  
+  const slug = description
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '_')
+    .replace(/^_|_$/g, '');
+  
+  const filename = `${timestamp}_${slug}.sql`;
+  const filepath = path.join(MIGRATIONS_DIR, filename);
+  
+  const template = `-- Migration: ${description}
+-- Created: ${new Date().toISOString()}
+
+-- Up migration
+-- Write your SQL here
+
+
+-- Down migration (rollback)
+-- DOWN
+
+`;
+  
+  fs.writeFileSync(filepath, template);
+  
+  console.log(chalk.green('✓ Created migration'));
+  console.log(chalk.gray(`  ${filepath}`));
+}
+
+/**
+ * Get all migration files
+ */
+function getMigrationFiles() {
+  if (!fs.existsSync(MIGRATIONS_DIR)) {
+    return [];
+  }
+  
+  return fs.readdirSync(MIGRATIONS_DIR)
+    .filter(f => f.endsWith('.sql'))
+    .sort();
+}
+
+/**
+ * Parse migration file (split up/down)
+ */
+function parseMigration(filepath) {
+  const content = fs.readFileSync(filepath, 'utf8');
+  const parts = content.split(/^--\s*DOWN\s*$/m);
+  
+  return {
+    up: parts[0].trim(),
+    down: parts[1]?.trim() || null
+  };
+}
+
+/**
+ * Show migration status
+ */
+export async function showMigrationStatus(target) {
+  let db;
+  
+  try {
+    const connectionString = await resolveConnection(target);
+    db = await createConnection(connectionString);
+    
+    // Ensure migrations table exists
+    await db.ensureMigrationsTable();
+    
+    // Get applied migrations
+    const applied = await db.getAppliedMigrations();
+    const appliedNames = new Set(applied.map(m => m.name));
+    
+    // Get migration files
+    const files = getMigrationFiles();
+    
+    if (files.length === 0) {
+      console.log(chalk.yellow('No migration files found'));
+      console.log(chalk.gray('Create one with: mpx-db migrate create <description>'));
+      return;
+    }
+    
+    const table = new Table({
+      head: ['Migration', 'Status', 'Applied'].map(h => chalk.cyan(h)),
+      style: { head: [], border: ['gray'] }
+    });
+    
+    for (const file of files) {
+      const name = file.replace('.sql', '');
+      const isApplied = appliedNames.has(name);
+      const appliedRecord = applied.find(m => m.name === name);
+      
+      table.push([
+        chalk.white(name),
+        isApplied ? chalk.green('Applied') : chalk.yellow('Pending'),
+        appliedRecord ? chalk.gray(new Date(appliedRecord.applied_at).toLocaleString()) : chalk.gray('-')
+      ]);
+    }
+    
+    console.log(table.toString());
+    
+    const pending = files.filter(f => !appliedNames.has(f.replace('.sql', '')));
+    console.log(chalk.gray(`\n${applied.length} applied, ${pending.length} pending`));
+    
+  } catch (err) {
+    console.error(chalk.red(`✗ ${err.message}`));
+    process.exit(1);
+  } finally {
+    if (db) {
+      await db.disconnect();
+    }
+  }
+}
+
+/**
+ * Run pending migrations
+ */
+export async function runMigrations(target) {
+  let db;
+  
+  try {
+    const connectionString = await resolveConnection(target);
+    db = await createConnection(connectionString);
+    
+    await db.ensureMigrationsTable();
+    
+    const applied = await db.getAppliedMigrations();
+    const appliedNames = new Set(applied.map(m => m.name));
+    
+    const files = getMigrationFiles();
+    const pending = files.filter(f => !appliedNames.has(f.replace('.sql', '')));
+    
+    if (pending.length === 0) {
+      console.log(chalk.green('✓ All migrations up to date'));
+      return;
+    }
+    
+    console.log(chalk.cyan(`Running ${pending.length} migration(s)...\n`));
+    
+    for (const file of pending) {
+      const name = file.replace('.sql', '');
+      const filepath = path.join(MIGRATIONS_DIR, file);
+      const migration = parseMigration(filepath);
+      
+      console.log(chalk.gray(`→ ${name}`));
+      
+      // Execute migration (split by semicolon for multiple statements)
+      // Remove comment lines first, then split
+      const cleanedSQL = migration.up
+        .split('\n')
+        .filter(line => !line.trim().startsWith('--'))
+        .join('\n');
+      
+      const statements = cleanedSQL
+        .split(';')
+        .map(s => s.trim())
+        .filter(s => s.length > 0);
+      
+      for (const statement of statements) {
+        await db.execute(statement);
+      }
+      
+      await db.recordMigration(name);
+      
+      console.log(chalk.green(`  ✓ Applied`));
+    }
+    
+    console.log(chalk.green(`\n✓ ${pending.length} migration(s) applied`));
+    
+  } catch (err) {
+    console.error(chalk.red(`\n✗ Migration failed: ${err.message}`));
+    process.exit(1);
+  } finally {
+    if (db) {
+      await db.disconnect();
+    }
+  }
+}
+
+/**
+ * Rollback last migration
+ */
+export async function rollbackMigration(target) {
+  let db;
+  
+  try {
+    const connectionString = await resolveConnection(target);
+    db = await createConnection(connectionString);
+    
+    await db.ensureMigrationsTable();
+    
+    const applied = await db.getAppliedMigrations();
+    
+    if (applied.length === 0) {
+      console.log(chalk.yellow('No migrations to rollback'));
+      return;
+    }
+    
+    const last = applied[applied.length - 1];
+    const filepath = path.join(MIGRATIONS_DIR, `${last.name}.sql`);
+    
+    if (!fs.existsSync(filepath)) {
+      console.error(chalk.red(`✗ Migration file not found: ${filepath}`));
+      process.exit(1);
+    }
+    
+    const migration = parseMigration(filepath);
+    
+    if (!migration.down) {
+      console.error(chalk.red(`✗ No down migration found in ${last.name}`));
+      process.exit(1);
+    }
+    
+    console.log(chalk.cyan(`Rolling back: ${last.name}`));
+    
+    // Execute rollback (split by semicolon for multiple statements)
+    // Remove comment lines first, then split
+    const cleanedSQL = migration.down
+      .split('\n')
+      .filter(line => !line.trim().startsWith('--'))
+      .join('\n');
+    
+    const statements = cleanedSQL
+      .split(';')
+      .map(s => s.trim())
+      .filter(s => s.length > 0);
+    
+    for (const statement of statements) {
+      await db.execute(statement);
+    }
+    
+    await db.removeMigration(last.name);
+    
+    console.log(chalk.green('✓ Rolled back'));
+    
+  } catch (err) {
+    console.error(chalk.red(`✗ Rollback failed: ${err.message}`));
+    process.exit(1);
+  } finally {
+    if (db) {
+      await db.disconnect();
+    }
+  }
+}

package/src/commands/query.js

@@ -0,0 +1,93 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { getConnection } from '../utils/config.js';
+import { createConnection } from '../db/connection.js';
+
+/**
+ * Execute a query
+ */
+export async function handleQuery(target, sql, options) {
+  let db;
+  
+  try {
+    // Get connection string
+    const connectionString = await resolveConnection(target);
+    
+    // Connect
+    db = await createConnection(connectionString);
+    
+    // Execute query
+    const startTime = Date.now();
+    const rows = await db.query(sql);
+    const duration = Date.now() - startTime;
+    
+    // Display results
+    if (rows.length === 0) {
+      console.log(chalk.yellow('No rows returned'));
+    } else {
+      displayTable(rows);
+    }
+    
+    console.log(chalk.gray(`\n${rows.length} row(s) in ${duration}ms`));
+    
+  } catch (err) {
+    console.error(chalk.red('✗ Query failed'));
+    console.error(chalk.red(`  ${err.message}`));
+    process.exit(1);
+  } finally {
+    if (db) {
+      await db.disconnect();
+    }
+  }
+}
+
+/**
+ * Display query results as table
+ */
+function displayTable(rows) {
+  if (rows.length === 0) return;
+  
+  const columns = Object.keys(rows[0]);
+  
+  const table = new Table({
+    head: columns.map(c => chalk.cyan(c)),
+    style: { head: [], border: ['gray'] }
+  });
+  
+  for (const row of rows) {
+    table.push(
+      columns.map(col => {
+        const val = row[col];
+        if (val === null) return chalk.gray('NULL');
+        if (typeof val === 'number') return chalk.yellow(val.toString());
+        return val.toString();
+      })
+    );
+  }
+  
+  console.log(table.toString());
+}
+
+/**
+ * Resolve connection string from target (name or URL)
+ */
+async function resolveConnection(target) {
+  // Check if it's a saved connection name
+  const saved = getConnection(target);
+  if (saved) {
+    return saved.url;
+  }
+  
+  // Check if it looks like a connection URL
+  if (target.includes('://')) {
+    return target;
+  }
+  
+  throw new Error(
+    `Connection "${target}" not found.\n` +
+    `  Use a connection URL or save a connection with:\n` +
+    `  mpx-db connect --save ${target} <url>`
+  );
+}
+
+export { resolveConnection };