thatcher 1.0.7 → 1.0.34

package/src/lib/database-core.js

@@ -1,255 +0,0 @@
-/**
- * Database Core - SQLite initialization and schema management
- * Adapted from moonlanding/src/lib/database-core.js
- */
-
-import Database from 'better-sqlite3';
-import fs from 'fs';
-import path from 'path';
-import { runMigrations } from './database-migrations.js';
-
-const SQL_TYPES = {
-  id: 'TEXT PRIMARY KEY',
-  text: 'TEXT',
-  textarea: 'TEXT',
-  email: 'TEXT',
-  int: 'INTEGER',
-  decimal: 'REAL',
-  bool: 'INTEGER',
-  date: 'INTEGER',
-  timestamp: 'INTEGER',
-  json: 'TEXT',
-  image: 'TEXT',
-  ref: 'TEXT',
-  enum: 'TEXT',
-};
-
-let db = null;
-let migrationComplete = false;
-const moduleCache = new Map();
-
-/**
- * Get or create database instance
- * @param {string} dbPath - Path to SQLite database file
- * @returns {Database} better-sqlite3 database instance
- */
-export function getDatabase(dbPath = null) {
-  if (db && !dbPath) return db;
-
-  const DB_PATH = dbPath || path.resolve(process.cwd(), 'data', 'app.db');
-  const dataDir = path.dirname(DB_PATH);
-
-  if (!fs.existsSync(dataDir)) {
-    fs.mkdirSync(dataDir, { recursive: true });
-  }
-
-  db = new Database(DB_PATH);
-  db.pragma('journal_mode = WAL');
-  const BUSY_TIMEOUT_MS = process.env.DATABASE_BUSY_TIMEOUT_MS || '5000';
-  db.pragma(`busy_timeout = ${BUSY_TIMEOUT_MS}`);
-  db.pragma('synchronous = NORMAL');
-  db.pragma('foreign_keys = ON');
-  db.pragma('auto_vacuum = INCREMENTAL');
-
-  return db;
-}
-
-/**
- * Generate unique ID using nanoid-like algorithm
- * @returns {string}
- */
-export function genId() {
-  // Simple but effective ID generation
-  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-}
-
-/**
- * Get current Unix timestamp (seconds)
- * @returns {number}
- */
-export function now() {
-  return Math.floor(Date.now() / 1000);
-}
-
-/**
- * Build column definition from field spec
- * @param {string} key - Field name
- * @param {object} field - Field definition
- * @returns {string} SQL column definition
- */
-function buildColumnDef(key, field) {
-  let col = `"${key}" ${SQL_TYPES[field.type] || 'TEXT'}`;
-
-  if (field.required && field.type !== 'id') {
-    col += ' NOT NULL';
-  }
-
-  if (field.unique) {
-    col += ' UNIQUE';
-  }
-
-  if (field.default !== undefined) {
-    if (typeof field.default === 'string' || typeof field.default === 'number' || typeof field.default === 'boolean') {
-      const defaultVal = typeof field.default === 'string'
-        ? `'${field.default.replace(/'/g, "''")}'`
-        : field.default;
-      col += ` DEFAULT ${defaultVal}`;
-    }
-  }
-
-  return col;
-}
-
-/**
- * Run migrations to create/update tables from entity specs
- * @param {object} configEngine - Config engine with entity specs
- */
-export function migrate(configEngine) {
-  if (migrationComplete) return;
-
-  const dbInstance = getDatabase();
-  let specsToUse = {};
-
-  try {
-    const allEntities = configEngine.getAllEntities();
-    for (const entityName of allEntities) {
-      specsToUse[entityName] = configEngine.generateEntitySpec(entityName);
-    }
-  } catch (e) {
-    console.error('[Database] Failed to get specs from ConfigEngine during migration:', e.message);
-    return;
-  }
-
-  // Create tables
-  for (const spec of Object.values(specsToUse)) {
-    if (!spec) continue;
-
-    const tableName = spec.name === 'user' ? 'users' : spec.name;
-    const columns = [];
-    const foreignKeys = [];
-
-    // Build columns from fields
-    for (const [key, field] of Object.entries(spec.fields || {})) {
-      columns.push(buildColumnDef(key, field));
-
-      if (field.type === 'ref' && field.ref) {
-        const refTable = field.ref === 'user' ? 'users' : field.ref;
-        foreignKeys.push(`FOREIGN KEY ("${key}") REFERENCES "${refTable}"(id)`);
-      }
-    }
-
-    const fkPart = foreignKeys.length ? (',\n' + foreignKeys.join(',\n')) : '';
-    const sql = `CREATE TABLE IF NOT EXISTS "${tableName}" (${columns.join(',\n')}${fkPart})`;
-
-    try {
-      dbInstance.exec(sql);
-    } catch (e) {
-      console.error(`[Database] Table creation failed for ${tableName}:`, e.message, '\nSQL:', sql);
-      throw e;
-    }
-
-    // Add new columns (ALTER TABLE for schema evolution)
-    try {
-      const existingCols = new Set(
-        dbInstance.prepare(`PRAGMA table_info("${tableName}")`).all().map(c => c.name)
-      );
-
-      for (const [key, field] of Object.entries(spec.fields || {})) {
-        if (!existingCols.has(key)) {
-          let colType = SQL_TYPES[field.type] || 'TEXT';
-          let alterSql = `ALTER TABLE "${tableName}" ADD COLUMN "${key}" ${colType}`;
-
-          if (field.default !== undefined && (typeof field.default === 'string' || typeof field.default === 'number' || typeof field.default === 'boolean')) {
-            const defaultVal = typeof field.default === 'string'
-              ? `'${field.default.replace(/'/g, "''")}'`
-              : field.default;
-            alterSql += ` DEFAULT ${defaultVal}`;
-          }
-
-          dbInstance.exec(alterSql);
-        }
-      }
-    } catch (e) {
-      console.error(`[Database] Column migration failed for ${tableName}:`, e.message);
-    }
-  }
-
-  // Create indexes
-  for (const spec of Object.values(specsToUse)) {
-    if (!spec) continue;
-
-    const tableName = spec.name === 'user' ? 'users' : spec.name;
-    const searchFields = [];
-
-    for (const [key, field] of Object.entries(spec.fields || {})) {
-      if (field.type === 'ref' || field.sortable || field.search) {
-        try {
-          dbInstance.exec(`CREATE INDEX IF NOT EXISTS idx_${tableName}_${key} ON "${tableName}"("${key}")`);
-        } catch (e) {
-          console.error(`[Database] Index creation failed for ${tableName}.${key}:`, e.message);
-        }
-      }
-
-      if (field.search || key === 'name' || key === 'description') {
-        searchFields.push(`"${key}"`);
-      }
-    }
-
-    // Create FTS virtual table for search
-    if (searchFields.length > 0) {
-      try {
-        dbInstance.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS ${tableName}_fts USING fts5(${searchFields.join(', ')}, content="${tableName}", content_rowid=id)`);
-      } catch (e) {
-        console.error(`[Database] FTS table creation failed for ${tableName}:`, e.message);
-      }
-    }
-  }
-
-  // Run additional migrations
-  runCustomMigrations(dbInstance, specsToUse);
-
-  migrationComplete = true;
-}
-
-/**
- * Run custom migration logic (triggers, data migrations, etc.)
- * @param {Database} dbInstance
- * @param {object} specs
- */
-function runCustomMigrations(dbInstance, specs) {
-  // Delegate to the dedicated migrations module (ported from moonlanding):
-  // idempotent triggers, activity_log + notification tables, etc.
-  try {
-    runMigrations(dbInstance);
-  } catch (e) {
-    console.error('[Database] Custom migrations failed:', e.message);
-  }
-}
-
-/**
- * Ensure database is initialized (lazy migration)
- */
-export function ensureInitialized(configEngine) {
-  if (!migrationComplete) {
-    migrate(configEngine);
-  }
-}
-
-/**
- * Reset database (for testing)
- */
-export function resetDatabase() {
-  const DB_PATH = path.resolve(process.cwd(), 'data', 'app.db');
-  try {
-    if (db) db.close();
-    if (fs.existsSync(DB_PATH)) fs.unlinkSync(DB_PATH);
-    if (fs.existsSync(DB_PATH + '-wal')) fs.unlinkSync(DB_PATH + '-wal');
-    if (fs.existsSync(DB_PATH + '-shm')) fs.unlinkSync(DB_PATH + '-shm');
-    db = null;
-    migrationComplete = false;
-  } catch (e) {
-    console.error('[Database] Reset failed:', e.message);
-  }
-}
-
-export { SQL_TYPES };

package/src/lib/database-migrations.js

@@ -1,350 +0,0 @@
-/**
- * Database Migrations - Custom SQL migrations and schema evolution
- * Runs after auto-migration completes
- */
-
-/**
- * Run custom migrations
- * @param {object} db - better-sqlite3 database instance
- */
-export function runMigrations(db) {
-  // All migrations defined here are idempotent
-  const migrations = [
-    createTimestampTriggers,
-    createActivityLogTable,
-    createNotificationTable,
-    createSessionsTable,
-    createChatTables,
-    createAuditLogsTable,
-    createRfiTables,
-    createPasswordResetTokensTable,
-    addHighlightColumns,
-    migrateRfiSectionTable,
-    createSystemSettingsTable,
-    createRecreationLogTable,
-    createBugReportTable,
-  ];
-
-  for (const migration of migrations) {
-    try {
-      migration(db);
-    } catch (err) {
-      console.error('[Migration] Failed:', err.message);
-    }
-  }
-}
-
-/**
- * Create triggers to auto-update updated_at on row changes
- * @param {object} db
- */
-function createTimestampTriggers(db) {
-  const tables = ['users', 'engagements', 'rfis', 'reviews']; // Could be dynamic
-
-  for (const table of tables) {
-    try {
-      db.exec(`
-        CREATE TRIGGER IF NOT EXISTS set_timestamp_${table}
-        AFTER UPDATE ON ${table}
-        FOR EACH ROW
-        BEGIN
-          UPDATE ${table} SET updated_at = CURRENT_TIMESTAMP WHERE id = NEW.id;
-        END;
-      `);
-    } catch (e) {
-      // Table might not exist yet
-    }
-  }
-}
-
-/**
- * Create activity_log table for audit trail
- * @param {object} db
- */
-function createActivityLogTable(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS activity_log (
-      id TEXT PRIMARY KEY,
-      entity_type TEXT NOT NULL,
-      entity_id TEXT NOT NULL,
-      action TEXT NOT NULL,
-      message TEXT,
-      details TEXT,
-      user_id TEXT,
-      created_at INTEGER NOT NULL,
-      FOREIGN KEY (user_id) REFERENCES users(id)
-    );
-  `);
-
-  db.exec(`CREATE INDEX IF NOT EXISTS idx_activity_log_entity ON activity_log(entity_type, entity_id)`);
-  db.exec(`CREATE INDEX IF NOT EXISTS idx_activity_log_user ON activity_log(user_id)`);
-  db.exec(`CREATE INDEX IF NOT EXISTS idx_activity_log_created ON activity_log(created_at)`);
-}
-
-/**
- * Create notification table
- * @param {object} db
- */
-function createNotificationTable(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS notification (
-      id TEXT PRIMARY KEY,
-      type TEXT NOT NULL,
-      user_id TEXT NOT NULL,
-      title TEXT NOT NULL,
-      message TEXT,
-      data TEXT,
-      entity_type TEXT,
-      entity_id TEXT,
-      created_at INTEGER NOT NULL,
-      read_at INTEGER,
-      FOREIGN KEY (user_id) REFERENCES users(id)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_notification_user ON notification(user_id, read_at);
-  `);
-}
-
-/**
- * Create sessions table (Lucia auth)
- * @param {object} db
- */
-function createSessionsTable(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS sessions (
-      id TEXT PRIMARY KEY,
-      user_id TEXT NOT NULL,
-      expires_at INTEGER NOT NULL,
-      FOREIGN KEY (user_id) REFERENCES users(id)
-    );
-  `);
-}
-
-/**
- * Create chat tables (messages + mentions)
- * @param {object} db
- */
-function createChatTables(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS chat_messages (
-      id TEXT PRIMARY KEY,
-      rfi_id TEXT,
-      user_id TEXT,
-      content TEXT,
-      attachments TEXT,
-      reactions TEXT DEFAULT '{}',
-      mentions TEXT DEFAULT '[]',
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER,
-      FOREIGN KEY (rfi_id) REFERENCES rfi(id),
-      FOREIGN KEY (user_id) REFERENCES users(id)
-    );
-
-    CREATE TABLE IF NOT EXISTS chat_mentions (
-      id TEXT PRIMARY KEY,
-      message_id TEXT NOT NULL,
-      user_id TEXT,
-      resolved BOOLEAN DEFAULT 0,
-      created_at INTEGER NOT NULL,
-      FOREIGN KEY (message_id) REFERENCES chat_messages(id),
-      FOREIGN KEY (user_id) REFERENCES users(id)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_chat_messages_rfi ON chat_messages(rfi_id);
-    CREATE INDEX IF NOT EXISTS idx_chat_messages_user ON chat_messages(user_id);
-    CREATE INDEX IF NOT EXISTS idx_chat_mentions_message ON chat_mentions(message_id);
-    CREATE INDEX IF NOT EXISTS idx_chat_mentions_user ON chat_mentions(user_id);
-  `);
-}
-
-/**
- * Create audit_logs table (before/after state audit trail)
- * Distinct from activity_log; preserved as an additive table.
- * @param {object} db
- */
-function createAuditLogsTable(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS audit_logs (
-      id TEXT PRIMARY KEY,
-      entity_type TEXT NOT NULL,
-      entity_id TEXT NOT NULL,
-      action TEXT NOT NULL,
-      user_id TEXT,
-      before_state TEXT,
-      after_state TEXT,
-      created_at INTEGER NOT NULL,
-      FOREIGN KEY (user_id) REFERENCES users(id)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_audit_logs_entity ON audit_logs(entity_type, entity_id);
-    CREATE INDEX IF NOT EXISTS idx_audit_logs_user ON audit_logs(user_id);
-    CREATE INDEX IF NOT EXISTS idx_audit_logs_created ON audit_logs(created_at);
-  `);
-}
-
-/**
- * Create RFI tables (rfis, questions, responses)
- * @param {object} db
- */
-function createRfiTables(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS rfis (
-      id TEXT PRIMARY KEY,
-      engagement_id TEXT NOT NULL,
-      status TEXT DEFAULT 'draft',
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL,
-      FOREIGN KEY (engagement_id) REFERENCES engagement(id)
-    );
-
-    CREATE TABLE IF NOT EXISTS rfi_questions (
-      id TEXT PRIMARY KEY,
-      rfi_id TEXT NOT NULL,
-      question TEXT NOT NULL,
-      category TEXT,
-      assigned_to TEXT,
-      due_date TEXT,
-      status TEXT DEFAULT 'pending',
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL,
-      FOREIGN KEY (rfi_id) REFERENCES rfis(id),
-      FOREIGN KEY (assigned_to) REFERENCES users(id)
-    );
-
-    CREATE TABLE IF NOT EXISTS rfi_responses (
-      id TEXT PRIMARY KEY,
-      question_id TEXT NOT NULL,
-      response TEXT,
-      attachments TEXT,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL,
-      FOREIGN KEY (question_id) REFERENCES rfi_questions(id)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_rfis_engagement ON rfis(engagement_id);
-    CREATE INDEX IF NOT EXISTS idx_rfis_status ON rfis(status);
-    CREATE INDEX IF NOT EXISTS idx_rfi_questions_rfi ON rfi_questions(rfi_id);
-    CREATE INDEX IF NOT EXISTS idx_rfi_questions_status ON rfi_questions(status);
-    CREATE INDEX IF NOT EXISTS idx_rfi_responses_question ON rfi_responses(question_id);
-  `);
-}
-
-/**
- * Create password_reset_tokens table
- * @param {object} db
- */
-function createPasswordResetTokensTable(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS password_reset_tokens (
-      id TEXT PRIMARY KEY,
-      user_id TEXT NOT NULL,
-      token TEXT NOT NULL UNIQUE,
-      expires_at INTEGER NOT NULL,
-      used INTEGER DEFAULT 0,
-      created_at INTEGER NOT NULL,
-      FOREIGN KEY (user_id) REFERENCES users(id)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_password_reset_tokens_token ON password_reset_tokens(token);
-    CREATE INDEX IF NOT EXISTS idx_password_reset_tokens_user ON password_reset_tokens(user_id);
-  `);
-}
-
-/**
- * Add flags/tags columns to highlight table (idempotent — ignores duplicate-column error)
- * @param {object} db
- */
-function addHighlightColumns(db) {
-  for (const col of ['flags', 'tags']) {
-    try {
-      db.exec(`ALTER TABLE highlight ADD COLUMN ${col} TEXT`);
-    } catch (e) {
-      // Column already exists or table not present yet
-    }
-  }
-}
-
-/**
- * Rebuild rfi_section table if it lacks an id column (legacy shape)
- * @param {object} db
- */
-function migrateRfiSectionTable(db) {
-  let cols = [];
-  try {
-    cols = db.prepare('PRAGMA table_info(rfi_section)').all().map(c => c.name);
-  } catch (e) {
-    return;
-  }
-  if (!cols.includes('id')) {
-    db.exec(`DROP TABLE IF EXISTS rfi_section`);
-    db.exec(`
-      CREATE TABLE IF NOT EXISTS rfi_section (
-        id TEXT PRIMARY KEY,
-        engagement_id TEXT NOT NULL,
-        name TEXT NOT NULL DEFAULT '',
-        sort_order INTEGER DEFAULT 0,
-        created_at INTEGER,
-        FOREIGN KEY (engagement_id) REFERENCES engagement(id)
-      );
-      CREATE INDEX IF NOT EXISTS idx_rfi_section_engagement ON rfi_section(engagement_id);
-    `);
-  }
-}
-
-/**
- * Create system_settings key/value table
- * @param {object} db
- */
-function createSystemSettingsTable(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS system_settings (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL,
-      updated_at INTEGER
-    );
-  `);
-}
-
-/**
- * Create recreation_log table
- * @param {object} db
- */
-function createRecreationLogTable(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS recreation_log (
-      id TEXT PRIMARY KEY,
-      engagement_id TEXT,
-      client_id TEXT,
-      engagement_type_id TEXT,
-      status TEXT,
-      details TEXT,
-      error TEXT,
-      created_at INTEGER NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_recreation_log_created ON recreation_log(created_at);
-    CREATE INDEX IF NOT EXISTS idx_recreation_log_status ON recreation_log(status);
-  `);
-}
-
-/**
- * Create bug_report table
- * @param {object} db
- */
-function createBugReportTable(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS bug_report (
-      id TEXT PRIMARY KEY,
-      user_id TEXT,
-      summary TEXT,
-      description TEXT,
-      url TEXT,
-      user_agent TEXT,
-      viewport TEXT,
-      status TEXT DEFAULT 'open',
-      created_at INTEGER NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_bug_report_created ON bug_report(created_at);
-  `);
-}

package/src/lib/db-backup.js

@@ -1,97 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import Database from 'better-sqlite3';
-
-const DEFAULT_DB_PATH = path.join(process.cwd(), 'data', 'app.db');
-const DEFAULT_BACKUP_DIR = path.join(process.cwd(), 'data', 'backups');
-
-export function createBackup(options = {}) {
-  const dbPath = options.dbPath || DEFAULT_DB_PATH;
-  const backupDir = options.backupDir || DEFAULT_BACKUP_DIR;
-  const label = options.label || 'backup';
-
-  if (!fs.existsSync(dbPath)) {
-    throw new Error(`Database not found: ${dbPath}`);
-  }
-
-  if (!fs.existsSync(backupDir)) {
-    fs.mkdirSync(backupDir, { recursive: true });
-  }
-
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  const backupPath = path.join(backupDir, `app-${label}-${timestamp}.db`);
-
-  const db = new Database(dbPath);
-  try {
-    db.pragma('wal_checkpoint(TRUNCATE)');
-    fs.copyFileSync(dbPath, backupPath);
-  } finally {
-    db.close();
-  }
-
-  const sourceSize = fs.statSync(dbPath).size;
-  const backupSize = fs.statSync(backupPath).size;
-
-  if (sourceSize !== backupSize) {
-    throw new Error(`Backup size mismatch: source=${sourceSize}, backup=${backupSize}`);
-  }
-
-  return { path: backupPath, size: backupSize, timestamp };
-}
-
-export function restoreBackup(backupPath, options = {}) {
-  const dbPath = options.dbPath || DEFAULT_DB_PATH;
-
-  if (!fs.existsSync(backupPath)) {
-    throw new Error(`Backup not found: ${backupPath}`);
-  }
-
-  const verifyDb = new Database(backupPath, { readonly: true });
-  try {
-    const result = verifyDb.pragma('integrity_check');
-    if (result[0]?.integrity_check !== 'ok') {
-      throw new Error(`Backup integrity check failed: ${JSON.stringify(result)}`);
-    }
-  } finally {
-    verifyDb.close();
-  }
-
-  const walPath = dbPath + '-wal';
-  const shmPath = dbPath + '-shm';
-
-  fs.copyFileSync(backupPath, dbPath);
-  if (fs.existsSync(walPath)) fs.unlinkSync(walPath);
-  if (fs.existsSync(shmPath)) fs.unlinkSync(shmPath);
-
-  return { restored: true, from: backupPath, to: dbPath };
-}
-
-export function listBackups(options = {}) {
-  const backupDir = options.backupDir || DEFAULT_BACKUP_DIR;
-
-  if (!fs.existsSync(backupDir)) return [];
-
-  return fs.readdirSync(backupDir)
-    .filter(f => f.endsWith('.db') && f.startsWith('app-'))
-    .map(f => ({
-      name: f,
-      path: path.join(backupDir, f),
-      size: fs.statSync(path.join(backupDir, f)).size,
-      created: fs.statSync(path.join(backupDir, f)).mtime,
-    }))
-    .sort((a, b) => b.created - a.created);
-}
-
-export function pruneBackups(options = {}) {
-  const maxBackups = options.maxBackups || 10;
-  const backups = listBackups(options);
-
-  if (backups.length <= maxBackups) return { pruned: 0 };
-
-  const toDelete = backups.slice(maxBackups);
-  for (const backup of toDelete) {
-    fs.unlinkSync(backup.path);
-  }
-
-  return { pruned: toDelete.length };
-}