mpx-db 1.0.0

package/src/db/sqlite-adapter.js

@@ -0,0 +1,141 @@
+import { BaseAdapter } from './base-adapter.js';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * SQLite adapter using better-sqlite3
+ */
+export class SQLiteAdapter extends BaseAdapter {
+  constructor(connectionString) {
+    super(connectionString);
+    
+    // Extract file path from sqlite:// or sqlite3://
+    this.dbPath = connectionString
+      .replace(/^sqlite3?:\/\//, '')
+      .replace(/^\//, ''); // Remove leading slash if absolute path
+  }
+
+  async connect() {
+    try {
+      // Try to import better-sqlite3
+      const Database = (await import('better-sqlite3')).default;
+      
+      // Ensure directory exists
+      const dir = path.dirname(this.dbPath);
+      if (dir && dir !== '.' && !fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      
+      this.connection = new Database(this.dbPath);
+      this.connection.pragma('journal_mode = WAL'); // Better concurrency
+      
+    } catch (err) {
+      if (err.code === 'ERR_MODULE_NOT_FOUND' || err.code === 'MODULE_NOT_FOUND') {
+        throw new Error(
+          'SQLite driver not found. Install it with:\n  npm install better-sqlite3'
+        );
+      }
+      throw err;
+    }
+  }
+
+  async disconnect() {
+    if (this.connection) {
+      this.connection.close();
+      this.connection = null;
+    }
+  }
+
+  async query(sql, params = []) {
+    if (!this.connection) {
+      throw new Error('Not connected to database');
+    }
+    
+    const stmt = this.connection.prepare(sql);
+    return stmt.all(...params);
+  }
+
+  async execute(sql, params = []) {
+    if (!this.connection) {
+      throw new Error('Not connected to database');
+    }
+    
+    const stmt = this.connection.prepare(sql);
+    const result = stmt.run(...params);
+    
+    return {
+      affectedRows: result.changes,
+      insertId: result.lastInsertRowid
+    };
+  }
+
+  async getTables() {
+    const rows = await this.query(
+      "SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%' ORDER BY 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,
+        rows: countResult[0].count
+      });
+    }
+    
+    return tables;
+  }
+
+  async getTableSchema(tableName) {
+    const rows = await this.query(`PRAGMA table_info(${tableName})`);
+    
+    return rows.map(row => ({
+      name: row.name,
+      type: row.type,
+      nullable: row.notnull === 0,
+      default: row.dflt_value,
+      primaryKey: row.pk === 1
+    }));
+  }
+
+  async getInfo() {
+    const tables = await this.getTables();
+    const totalRows = tables.reduce((sum, t) => sum + t.rows, 0);
+    
+    let size = 0;
+    if (fs.existsSync(this.dbPath)) {
+      size = fs.statSync(this.dbPath).size;
+    }
+    
+    return {
+      type: 'SQLite',
+      path: this.dbPath,
+      size: size,
+      sizeFormatted: formatBytes(size),
+      tables: tables.length,
+      totalRows
+    };
+  }
+
+  async ensureMigrationsTable() {
+    await this.execute(`
+      CREATE TABLE IF NOT EXISTS mpx_migrations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE,
+        applied_at TEXT NOT NULL
+      )
+    `);
+  }
+}
+
+/**
+ * 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/index.js

@@ -0,0 +1,15 @@
+/**
+ * mpx-db - Database management CLI
+ * Main exports for programmatic usage
+ */
+
+export { createConnection, testConnection } from './db/connection.js';
+export { SQLiteAdapter } from './db/sqlite-adapter.js';
+export { PostgresAdapter } from './db/postgres-adapter.js';
+export { MySQLAdapter } from './db/mysql-adapter.js';
+export { 
+  saveConnection, 
+  loadConnections, 
+  deleteConnection, 
+  getConnection 
+} from './utils/config.js';

package/src/utils/config.js

@@ -0,0 +1,109 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { encrypt, decrypt } from './crypto.js';
+
+const CONFIG_DIR = path.join(os.homedir(), '.mpx-db');
+const CONNECTIONS_FILE = path.join(CONFIG_DIR, 'connections.json');
+
+/**
+ * Ensure config directory exists
+ */
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+/**
+ * Load all saved connections
+ */
+export function loadConnections() {
+  ensureConfigDir();
+  
+  if (!fs.existsSync(CONNECTIONS_FILE)) {
+    return {};
+  }
+  
+  const data = JSON.parse(fs.readFileSync(CONNECTIONS_FILE, 'utf8'));
+  
+  // Decrypt passwords
+  const connections = {};
+  for (const [name, conn] of Object.entries(data)) {
+    connections[name] = {
+      ...conn,
+      url: conn.encrypted ? decrypt(conn.url) : conn.url
+    };
+  }
+  
+  return connections;
+}
+
+/**
+ * Save a connection
+ */
+export function saveConnection(name, url) {
+  ensureConfigDir();
+  
+  const connections = {};
+  if (fs.existsSync(CONNECTIONS_FILE)) {
+    const data = JSON.parse(fs.readFileSync(CONNECTIONS_FILE, 'utf8'));
+    Object.assign(connections, data);
+  }
+  
+  // Parse URL to extract type
+  const type = url.split(':')[0];
+  
+  connections[name] = {
+    type,
+    url: encrypt(url),
+    encrypted: true,
+    createdAt: new Date().toISOString()
+  };
+  
+  fs.writeFileSync(CONNECTIONS_FILE, JSON.stringify(connections, null, 2), { mode: 0o600 });
+}
+
+/**
+ * Delete a connection
+ */
+export function deleteConnection(name) {
+  ensureConfigDir();
+  
+  if (!fs.existsSync(CONNECTIONS_FILE)) {
+    return false;
+  }
+  
+  const connections = JSON.parse(fs.readFileSync(CONNECTIONS_FILE, 'utf8'));
+  
+  if (!connections[name]) {
+    return false;
+  }
+  
+  delete connections[name];
+  fs.writeFileSync(CONNECTIONS_FILE, JSON.stringify(connections, null, 2), { mode: 0o600 });
+  
+  return true;
+}
+
+/**
+ * Get a specific connection
+ */
+export function getConnection(name) {
+  const connections = loadConnections();
+  return connections[name] || null;
+}
+
+/**
+ * Load project config (.mpx-db.yaml)
+ */
+export function loadProjectConfig() {
+  const configPath = path.join(process.cwd(), '.mpx-db.yaml');
+  
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  
+  // We'll parse YAML when needed, for now just check existence
+  return configPath;
+}

package/src/utils/crypto.js

@@ -0,0 +1,67 @@
+import crypto from 'crypto';
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+
+const ALGORITHM = 'aes-256-gcm';
+const KEY_LENGTH = 32;
+const IV_LENGTH = 16;
+const TAG_LENGTH = 16;
+
+/**
+ * Get or create encryption key
+ */
+function getEncryptionKey() {
+  const configDir = path.join(os.homedir(), '.mpx-db');
+  const keyFile = path.join(configDir, '.key');
+
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
+  }
+
+  if (fs.existsSync(keyFile)) {
+    return fs.readFileSync(keyFile);
+  }
+
+  // Generate new key
+  const key = crypto.randomBytes(KEY_LENGTH);
+  fs.writeFileSync(keyFile, key, { mode: 0o600 });
+  return key;
+}
+
+/**
+ * Encrypt a string
+ */
+export function encrypt(text) {
+  const key = getEncryptionKey();
+  const iv = crypto.randomBytes(IV_LENGTH);
+  
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+  let encrypted = cipher.update(text, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+  
+  const authTag = cipher.getAuthTag();
+  
+  // Return iv + authTag + encrypted
+  return iv.toString('hex') + authTag.toString('hex') + encrypted;
+}
+
+/**
+ * Decrypt a string
+ */
+export function decrypt(encrypted) {
+  const key = getEncryptionKey();
+  
+  // Extract iv, authTag, and encrypted data
+  const iv = Buffer.from(encrypted.slice(0, IV_LENGTH * 2), 'hex');
+  const authTag = Buffer.from(encrypted.slice(IV_LENGTH * 2, (IV_LENGTH + TAG_LENGTH) * 2), 'hex');
+  const encryptedData = encrypted.slice((IV_LENGTH + TAG_LENGTH) * 2);
+  
+  const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+  decipher.setAuthTag(authTag);
+  
+  let decrypted = decipher.update(encryptedData, 'hex', 'utf8');
+  decrypted += decipher.final('utf8');
+  
+  return decrypted;
+}