mpx-db 1.0.0

package/src/commands/schema.js

@@ -0,0 +1,181 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { createConnection } from '../db/connection.js';
+import { resolveConnection } from './query.js';
+
+/**
+ * Show database info
+ */
+export async function showInfo(target) {
+  let db;
+  
+  try {
+    const connectionString = await resolveConnection(target);
+    db = await createConnection(connectionString);
+    
+    const info = await db.getInfo();
+    
+    console.log(chalk.bold('\nDatabase Information'));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(`${chalk.cyan('Type:')}        ${info.type}`);
+    if (info.database) {
+      console.log(`${chalk.cyan('Database:')}    ${info.database}`);
+    }
+    if (info.path) {
+      console.log(`${chalk.cyan('Path:')}        ${info.path}`);
+    }
+    console.log(`${chalk.cyan('Size:')}        ${info.sizeFormatted}`);
+    console.log(`${chalk.cyan('Tables:')}      ${info.tables}`);
+    console.log(`${chalk.cyan('Total Rows:')}  ${info.totalRows.toLocaleString()}`);
+    console.log();
+    
+  } catch (err) {
+    console.error(chalk.red(`✗ ${err.message}`));
+    process.exit(1);
+  } finally {
+    if (db) {
+      await db.disconnect();
+    }
+  }
+}
+
+/**
+ * List all tables
+ */
+export async function listTables(target) {
+  let db;
+  
+  try {
+    const connectionString = await resolveConnection(target);
+    db = await createConnection(connectionString);
+    
+    const tables = await db.getTables();
+    
+    if (tables.length === 0) {
+      console.log(chalk.yellow('No tables found'));
+      return;
+    }
+    
+    const table = new Table({
+      head: ['Table', 'Type', 'Rows'].map(h => chalk.cyan(h)),
+      style: { head: [], border: ['gray'] },
+      colAligns: ['left', 'left', 'right']
+    });
+    
+    for (const t of tables) {
+      table.push([
+        chalk.white(t.name),
+        chalk.gray(t.type),
+        chalk.yellow(t.rows.toLocaleString())
+      ]);
+    }
+    
+    console.log(table.toString());
+    console.log(chalk.gray(`\n${tables.length} table(s)`));
+    
+  } catch (err) {
+    console.error(chalk.red(`✗ ${err.message}`));
+    process.exit(1);
+  } finally {
+    if (db) {
+      await db.disconnect();
+    }
+  }
+}
+
+/**
+ * Describe table schema
+ */
+export async function describeTable(target, tableName) {
+  let db;
+  
+  try {
+    const connectionString = await resolveConnection(target);
+    db = await createConnection(connectionString);
+    
+    const schema = await db.getTableSchema(tableName);
+    
+    if (schema.length === 0) {
+      console.log(chalk.yellow(`Table "${tableName}" not found or has no columns`));
+      return;
+    }
+    
+    console.log(chalk.bold(`\nTable: ${tableName}`));
+    console.log(chalk.gray('─'.repeat(80)));
+    
+    const table = new Table({
+      head: ['Column', 'Type', 'Nullable', 'Default', 'Key'].map(h => chalk.cyan(h)),
+      style: { head: [], border: ['gray'] }
+    });
+    
+    for (const col of schema) {
+      table.push([
+        chalk.white(col.name),
+        chalk.gray(col.type),
+        col.nullable ? chalk.green('YES') : chalk.red('NO'),
+        col.default ? chalk.yellow(col.default) : chalk.gray('-'),
+        col.primaryKey ? chalk.magenta('PRI') : chalk.gray('-')
+      ]);
+    }
+    
+    console.log(table.toString());
+    console.log();
+    
+  } catch (err) {
+    console.error(chalk.red(`✗ ${err.message}`));
+    process.exit(1);
+  } finally {
+    if (db) {
+      await db.disconnect();
+    }
+  }
+}
+
+/**
+ * Dump database schema
+ */
+export async function dumpSchema(target) {
+  let db;
+  
+  try {
+    const connectionString = await resolveConnection(target);
+    db = await createConnection(connectionString);
+    
+    const info = await db.getInfo();
+    const tables = await db.getTables();
+    
+    console.log(chalk.gray(`-- Database: ${info.database || info.path}`));
+    console.log(chalk.gray(`-- Type: ${info.type}`));
+    console.log(chalk.gray(`-- Generated: ${new Date().toISOString()}`));
+    console.log();
+    
+    for (const table of tables) {
+      if (table.type !== 'table') continue;
+      
+      const schema = await db.getTableSchema(table.name);
+      
+      console.log(chalk.cyan(`-- Table: ${table.name}`));
+      console.log(chalk.gray(`-- Rows: ${table.rows}`));
+      
+      // This is a simplified dump - real implementations would generate proper DDL
+      const cols = schema.map(c => {
+        let def = `  ${c.name} ${c.type}`;
+        if (!c.nullable) def += ' NOT NULL';
+        if (c.default) def += ` DEFAULT ${c.default}`;
+        return def;
+      });
+      
+      console.log(`CREATE TABLE ${table.name} (`);
+      console.log(cols.join(',\n'));
+      console.log(');\n');
+    }
+    
+  } catch (err) {
+    console.error(chalk.red(`✗ ${err.message}`));
+    process.exit(1);
+  } finally {
+    if (db) {
+      await db.disconnect();
+    }
+  }
+}

package/src/db/base-adapter.js

@@ -0,0 +1,101 @@
+/**
+ * Base database adapter
+ * All adapters must implement these methods
+ */
+export class BaseAdapter {
+  constructor(connectionString) {
+    this.connectionString = connectionString;
+    this.connection = null;
+  }
+
+  /**
+   * Connect to database
+   */
+  async connect() {
+    throw new Error('connect() must be implemented');
+  }
+
+  /**
+   * Disconnect from database
+   */
+  async disconnect() {
+    throw new Error('disconnect() must be implemented');
+  }
+
+  /**
+   * Execute a query
+   * @returns {Array} rows
+   */
+  async query(sql, params = []) {
+    throw new Error('query() must be implemented');
+  }
+
+  /**
+   * Execute a statement (INSERT, UPDATE, DELETE)
+   * @returns {Object} { affectedRows, insertId }
+   */
+  async execute(sql, params = []) {
+    throw new Error('execute() must be implemented');
+  }
+
+  /**
+   * Get list of tables
+   */
+  async getTables() {
+    throw new Error('getTables() must be implemented');
+  }
+
+  /**
+   * Get table schema
+   */
+  async getTableSchema(tableName) {
+    throw new Error('getTableSchema() must be implemented');
+  }
+
+  /**
+   * Get database info (size, table count, etc.)
+   */
+  async getInfo() {
+    throw new Error('getInfo() must be implemented');
+  }
+
+  /**
+   * Get table row count
+   */
+  async getRowCount(tableName) {
+    const result = await this.query(`SELECT COUNT(*) as count FROM ${tableName}`);
+    return result[0].count;
+  }
+
+  /**
+   * Create migrations table if not exists
+   */
+  async ensureMigrationsTable() {
+    throw new Error('ensureMigrationsTable() must be implemented');
+  }
+
+  /**
+   * Get applied migrations
+   */
+  async getAppliedMigrations() {
+    const rows = await this.query('SELECT * FROM mpx_migrations ORDER BY id ASC');
+    return rows;
+  }
+
+  /**
+   * Record migration as applied
+   */
+  async recordMigration(name) {
+    await this.execute(
+      'INSERT INTO mpx_migrations (name, applied_at) VALUES (?, ?)',
+      [name, new Date().toISOString()]
+    );
+  }
+
+  /**
+   * Remove migration record (for rollback)
+   */
+  async removeMigration(name) {
+    await this.execute('DELETE FROM mpx_migrations WHERE name = ?', [name]);
+  }
+}

package/src/db/connection.js

@@ -0,0 +1,46 @@
+import { SQLiteAdapter } from './sqlite-adapter.js';
+import { PostgresAdapter } from './postgres-adapter.js';
+import { MySQLAdapter } from './mysql-adapter.js';
+
+/**
+ * Create database adapter from connection string
+ */
+export async function createConnection(connectionString) {
+  if (!connectionString) {
+    throw new Error('Connection string is required');
+  }
+
+  let adapter;
+  
+  // Determine database type from connection string
+  if (connectionString.startsWith('sqlite://') || connectionString.startsWith('sqlite3://')) {
+    adapter = new SQLiteAdapter(connectionString);
+  } else if (connectionString.startsWith('postgres://') || connectionString.startsWith('postgresql://')) {
+    adapter = new PostgresAdapter(connectionString);
+  } else if (connectionString.startsWith('mysql://')) {
+    adapter = new MySQLAdapter(connectionString);
+  } else {
+    throw new Error(
+      `Unsupported database type. Connection string must start with:\n` +
+      `  - sqlite:// or sqlite3://\n` +
+      `  - postgres:// or postgresql://\n` +
+      `  - mysql://`
+    );
+  }
+
+  await adapter.connect();
+  return adapter;
+}
+
+/**
+ * Test connection
+ */
+export async function testConnection(connectionString) {
+  try {
+    const adapter = await createConnection(connectionString);
+    await adapter.disconnect();
+    return true;
+  } catch (err) {
+    return false;
+  }
+}

package/src/db/mysql-adapter.js

@@ -0,0 +1,144 @@
+import { BaseAdapter } from './base-adapter.js';
+
+/**
+ * MySQL adapter using mysql2
+ */
+export class MySQLAdapter extends BaseAdapter {
+  async connect() {
+    try {
+      const mysql = await import('mysql2/promise');
+      
+      this.connection = await mysql.default.createConnection(this.connectionString);
+      
+    } catch (err) {
+      if (err.code === 'ERR_MODULE_NOT_FOUND' || err.code === 'MODULE_NOT_FOUND') {
+        throw new Error(
+          'MySQL driver not found. Install it with:\n  npm install mysql2'
+        );
+      }
+      throw err;
+    }
+  }
+
+  async disconnect() {
+    if (this.connection) {
+      await this.connection.end();
+      this.connection = null;
+    }
+  }
+
+  async query(sql, params = []) {
+    if (!this.connection) {
+      throw new Error('Not connected to database');
+    }
+    
+    const [rows] = await this.connection.execute(sql, params);
+    return rows;
+  }
+
+  async execute(sql, params = []) {
+    if (!this.connection) {
+      throw new Error('Not connected to database');
+    }
+    
+    const [result] = await this.connection.execute(sql, params);
+    
+    return {
+      affectedRows: result.affectedRows,
+      insertId: result.insertId
+    };
+  }
+
+  async getTables() {
+    const rows = await this.query(`
+      SELECT 
+        TABLE_NAME as name,
+        TABLE_TYPE as type
+      FROM information_schema.TABLES
+      WHERE TABLE_SCHEMA = DATABASE()
+      ORDER BY TABLE_NAME
+    `);
+    
+    const tables = [];
+    for (const row of rows) {
+      const countResult = await this.query(
+        `SELECT COUNT(*) as count FROM \`${row.name}\``
+      );
+      tables.push({
+        name: row.name,
+        type: row.type === 'BASE TABLE' ? 'table' : 'view',
+        rows: parseInt(countResult[0].count)
+      });
+    }
+    
+    return tables;
+  }
+
+  async getTableSchema(tableName) {
+    const rows = await this.query(`
+      SELECT 
+        COLUMN_NAME as name,
+        COLUMN_TYPE as type,
+        IS_NULLABLE as nullable,
+        COLUMN_DEFAULT as \`default\`,
+        COLUMN_KEY as key_type
+      FROM information_schema.COLUMNS
+      WHERE TABLE_NAME = ?
+        AND TABLE_SCHEMA = DATABASE()
+      ORDER BY ORDINAL_POSITION
+    `, [tableName]);
+    
+    return rows.map(row => ({
+      name: row.name,
+      type: row.type,
+      nullable: row.nullable === 'YES',
+      default: row.default,
+      primaryKey: row.key_type === 'PRI'
+    }));
+  }
+
+  async getInfo() {
+    const tables = await this.getTables();
+    const totalRows = tables.reduce((sum, t) => sum + t.rows, 0);
+    
+    const sizeResult = await this.query(`
+      SELECT 
+        SUM(data_length + index_length) as size
+      FROM information_schema.TABLES
+      WHERE TABLE_SCHEMA = DATABASE()
+    `);
+    const size = parseInt(sizeResult[0].size || 0);
+    
+    const dbResult = await this.query('SELECT DATABASE() as name');
+    
+    return {
+      type: 'MySQL',
+      database: dbResult[0].name,
+      size: size,
+      sizeFormatted: formatBytes(size),
+      tables: tables.length,
+      totalRows
+    };
+  }
+
+  async ensureMigrationsTable() {
+    await this.execute(`
+      CREATE TABLE IF NOT EXISTS mpx_migrations (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        name VARCHAR(255) NOT NULL UNIQUE,
+        applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+  }
+}
+
+/**
+ * Format bytes to human readable
+ */
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 Bytes';
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
+}

package/src/db/postgres-adapter.js

@@ -0,0 +1,150 @@
+import { BaseAdapter } from './base-adapter.js';
+
+/**
+ * PostgreSQL adapter using pg
+ */
+export class PostgresAdapter extends BaseAdapter {
+  async connect() {
+    try {
+      const pkg = await import('pg');
+      const { Client } = pkg.default || pkg;
+      
+      this.connection = new Client({ connectionString: this.connectionString });
+      await this.connection.connect();
+      
+    } catch (err) {
+      if (err.code === 'ERR_MODULE_NOT_FOUND' || err.code === 'MODULE_NOT_FOUND') {
+        throw new Error(
+          'PostgreSQL driver not found. Install it with:\n  npm install pg'
+        );
+      }
+      throw err;
+    }
+  }
+
+  async disconnect() {
+    if (this.connection) {
+      await this.connection.end();
+      this.connection = null;
+    }
+  }
+
+  async query(sql, params = []) {
+    if (!this.connection) {
+      throw new Error('Not connected to database');
+    }
+    
+    const result = await this.connection.query(sql, params);
+    return result.rows;
+  }
+
+  async execute(sql, params = []) {
+    if (!this.connection) {
+      throw new Error('Not connected to database');
+    }
+    
+    const result = await this.connection.query(sql, params);
+    
+    return {
+      affectedRows: result.rowCount,
+      insertId: result.rows[0]?.id || null
+    };
+  }
+
+  async getTables() {
+    const rows = await this.query(`
+      SELECT 
+        table_name as name,
+        table_type as type
+      FROM information_schema.tables
+      WHERE table_schema = 'public'
+      ORDER BY table_name
+    `);
+    
+    const tables = [];
+    for (const row of rows) {
+      const countResult = await this.query(
+        `SELECT COUNT(*) as count FROM ${row.name}`
+      );
+      tables.push({
+        name: row.name,
+        type: row.type === 'BASE TABLE' ? 'table' : 'view',
+        rows: parseInt(countResult[0].count)
+      });
+    }
+    
+    return tables;
+  }
+
+  async getTableSchema(tableName) {
+    const rows = await this.query(`
+      SELECT 
+        column_name as name,
+        data_type as type,
+        is_nullable as nullable,
+        column_default as "default",
+        CASE WHEN c.column_name IN (
+          SELECT kcu.column_name
+          FROM information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+          WHERE tc.table_name = $1
+            AND tc.constraint_type = 'PRIMARY KEY'
+        ) THEN true ELSE false END as primary_key
+      FROM information_schema.columns c
+      WHERE table_name = $1
+        AND table_schema = 'public'
+      ORDER BY ordinal_position
+    `, [tableName]);
+    
+    return rows.map(row => ({
+      name: row.name,
+      type: row.type,
+      nullable: row.nullable === 'YES',
+      default: row.default,
+      primaryKey: row.primary_key
+    }));
+  }
+
+  async getInfo() {
+    const tables = await this.getTables();
+    const totalRows = tables.reduce((sum, t) => sum + t.rows, 0);
+    
+    const sizeResult = await this.query(`
+      SELECT pg_database_size(current_database()) as size
+    `);
+    const size = parseInt(sizeResult[0].size);
+    
+    const dbResult = await this.query('SELECT current_database() as name');
+    
+    return {
+      type: 'PostgreSQL',
+      database: dbResult[0].name,
+      size: size,
+      sizeFormatted: formatBytes(size),
+      tables: tables.length,
+      totalRows
+    };
+  }
+
+  async ensureMigrationsTable() {
+    await this.execute(`
+      CREATE TABLE IF NOT EXISTS mpx_migrations (
+        id SERIAL PRIMARY KEY,
+        name VARCHAR(255) NOT NULL UNIQUE,
+        applied_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+  }
+}
+
+/**
+ * Format bytes to human readable
+ */
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 Bytes';
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
+}