dbnexus 0.1.11 → 0.1.12

package/dist/api.js

@@ -80952,7 +80952,7 @@ var import_common = __toESM(require_common(), 1);
 import Database from "better-sqlite3";
 
 // packages/metadata/dist/schema.js
-var SCHEMA_VERSION = 9;
+var SCHEMA_VERSION = 11;
 var MIGRATIONS = [
   // Version 1: Initial schema
   `
@@ -81169,6 +81169,50 @@ var MIGRATIONS = [
   ALTER TABLE connections ADD COLUMN connection_type TEXT NOT NULL DEFAULT 'local' CHECK(connection_type IN ('local', 'docker', 'remote'));
 
   UPDATE schema_version SET version = 9;
+  `,
+  // Version 10: Refactor sync_runs to work without sync_configs (add direct connection/table info)
+  `
+  -- Create new sync_runs table without FK constraint
+  CREATE TABLE IF NOT EXISTS sync_runs_new (
+    id TEXT PRIMARY KEY,
+    source_connection_id TEXT,
+    target_connection_id TEXT,
+    schema_name TEXT,
+    table_name TEXT,
+    group_id TEXT,
+    started_at TEXT NOT NULL DEFAULT (datetime('now')),
+    completed_at TEXT,
+    status TEXT NOT NULL DEFAULT 'running',
+    inserts INTEGER NOT NULL DEFAULT 0,
+    updates INTEGER NOT NULL DEFAULT 0,
+    deletes INTEGER NOT NULL DEFAULT 0,
+    errors_json TEXT,
+    FOREIGN KEY (source_connection_id) REFERENCES connections(id) ON DELETE SET NULL,
+    FOREIGN KEY (target_connection_id) REFERENCES connections(id) ON DELETE SET NULL,
+    FOREIGN KEY (group_id) REFERENCES database_groups(id) ON DELETE SET NULL
+  );
+
+  -- Copy existing data (old sync_config_id will be lost, but that's ok)
+  INSERT INTO sync_runs_new (id, started_at, completed_at, status, inserts, updates, deletes, errors_json)
+  SELECT id, started_at, completed_at, status, inserts, updates, deletes, errors_json FROM sync_runs;
+
+  -- Drop old table and rename
+  DROP TABLE sync_runs;
+  ALTER TABLE sync_runs_new RENAME TO sync_runs;
+
+  -- Create indexes
+  CREATE INDEX IF NOT EXISTS idx_sync_runs_source ON sync_runs(source_connection_id);
+  CREATE INDEX IF NOT EXISTS idx_sync_runs_target ON sync_runs(target_connection_id);
+  CREATE INDEX IF NOT EXISTS idx_sync_runs_group ON sync_runs(group_id);
+  CREATE INDEX IF NOT EXISTS idx_sync_runs_started ON sync_runs(started_at DESC);
+
+  UPDATE schema_version SET version = 10;
+  `,
+  // Version 11: Add sql_statements to sync_runs for tracking executed SQL
+  `
+  ALTER TABLE sync_runs ADD COLUMN sql_statements TEXT;
+
+  UPDATE schema_version SET version = 11;
   `
 ];
 
@@ -81986,6 +82030,524 @@ var DatabaseGroupRepository = class {
   }
 };
 
+// packages/metadata/dist/repositories/sync-run.repository.js
+var SyncRunRepository = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Create a new sync run (starts in 'running' status)
+   */
+  create(input) {
+    const id = crypto.randomUUID();
+    this.db.getDb().prepare(`
+            INSERT INTO sync_runs (id, source_connection_id, target_connection_id, schema_name, table_name, group_id, status)
+            VALUES (?, ?, ?, ?, ?, ?, 'running')
+        `).run(id, input.sourceConnectionId, input.targetConnectionId, input.schemaName || null, input.tableName || null, input.groupId || null);
+    return this.findById(id);
+  }
+  /**
+   * Find a sync run by ID
+   */
+  findById(id) {
+    const row = this.db.getDb().prepare(`
+            SELECT 
+                sr.*,
+                src.name as source_connection_name,
+                tgt.name as target_connection_name,
+                dg.name as group_name
+            FROM sync_runs sr
+            LEFT JOIN connections src ON sr.source_connection_id = src.id
+            LEFT JOIN connections tgt ON sr.target_connection_id = tgt.id
+            LEFT JOIN database_groups dg ON sr.group_id = dg.id
+            WHERE sr.id = ?
+        `).get(id);
+    return row ? this.rowToRun(row) : null;
+  }
+  /**
+   * Find sync runs by group ID
+   */
+  findByGroupId(groupId, limit) {
+    let query = `
+            SELECT 
+                sr.*,
+                src.name as source_connection_name,
+                tgt.name as target_connection_name,
+                dg.name as group_name
+            FROM sync_runs sr
+            LEFT JOIN connections src ON sr.source_connection_id = src.id
+            LEFT JOIN connections tgt ON sr.target_connection_id = tgt.id
+            LEFT JOIN database_groups dg ON sr.group_id = dg.id
+            WHERE sr.group_id = ?
+            ORDER BY sr.started_at DESC
+        `;
+    if (limit) {
+      query += ` LIMIT ${limit}`;
+    }
+    const rows = this.db.getDb().prepare(query).all(groupId);
+    return rows.map((row) => this.rowToRun(row));
+  }
+  /**
+   * Find sync runs by connection ID (either source or target)
+   */
+  findByConnectionId(connectionId, limit) {
+    let query = `
+            SELECT 
+                sr.*,
+                src.name as source_connection_name,
+                tgt.name as target_connection_name,
+                dg.name as group_name
+            FROM sync_runs sr
+            LEFT JOIN connections src ON sr.source_connection_id = src.id
+            LEFT JOIN connections tgt ON sr.target_connection_id = tgt.id
+            LEFT JOIN database_groups dg ON sr.group_id = dg.id
+            WHERE sr.source_connection_id = ? OR sr.target_connection_id = ?
+            ORDER BY sr.started_at DESC
+        `;
+    if (limit) {
+      query += ` LIMIT ${limit}`;
+    }
+    const rows = this.db.getDb().prepare(query).all(connectionId, connectionId);
+    return rows.map((row) => this.rowToRun(row));
+  }
+  /**
+   * Find recent sync runs
+   */
+  findRecent(limit = 50) {
+    const rows = this.db.getDb().prepare(`
+            SELECT 
+                sr.*,
+                src.name as source_connection_name,
+                tgt.name as target_connection_name,
+                dg.name as group_name
+            FROM sync_runs sr
+            LEFT JOIN connections src ON sr.source_connection_id = src.id
+            LEFT JOIN connections tgt ON sr.target_connection_id = tgt.id
+            LEFT JOIN database_groups dg ON sr.group_id = dg.id
+            ORDER BY sr.started_at DESC
+            LIMIT ?
+        `).all(limit);
+    return rows.map((row) => this.rowToRun(row));
+  }
+  /**
+   * Find running sync runs
+   */
+  findRunning() {
+    const rows = this.db.getDb().prepare(`
+            SELECT 
+                sr.*,
+                src.name as source_connection_name,
+                tgt.name as target_connection_name,
+                dg.name as group_name
+            FROM sync_runs sr
+            LEFT JOIN connections src ON sr.source_connection_id = src.id
+            LEFT JOIN connections tgt ON sr.target_connection_id = tgt.id
+            LEFT JOIN database_groups dg ON sr.group_id = dg.id
+            WHERE sr.status = 'running'
+            ORDER BY sr.started_at DESC
+        `).all();
+    return rows.map((row) => this.rowToRun(row));
+  }
+  /**
+   * Update a sync run
+   */
+  update(id, input) {
+    const updates = [];
+    const params = [];
+    if (input.status !== void 0) {
+      updates.push("status = ?");
+      params.push(input.status);
+      if (["completed", "failed", "cancelled"].includes(input.status)) {
+        updates.push("completed_at = datetime('now')");
+      }
+    }
+    if (input.inserts !== void 0) {
+      updates.push("inserts = ?");
+      params.push(input.inserts);
+    }
+    if (input.updates !== void 0) {
+      updates.push("updates = ?");
+      params.push(input.updates);
+    }
+    if (input.deletes !== void 0) {
+      updates.push("deletes = ?");
+      params.push(input.deletes);
+    }
+    if (input.errors !== void 0) {
+      updates.push("errors_json = ?");
+      params.push(JSON.stringify(input.errors));
+    }
+    if (input.sqlStatements !== void 0) {
+      updates.push("sql_statements = ?");
+      params.push(JSON.stringify(input.sqlStatements));
+    }
+    if (updates.length === 0) {
+      return this.findById(id);
+    }
+    params.push(id);
+    this.db.getDb().prepare(`UPDATE sync_runs SET ${updates.join(", ")} WHERE id = ?`).run(...params);
+    return this.findById(id);
+  }
+  /**
+   * Complete a sync run with results
+   */
+  complete(id, results) {
+    return this.update(id, {
+      status: results.errors.length > 0 ? "failed" : "completed",
+      inserts: results.inserts,
+      updates: results.updates,
+      deletes: results.deletes,
+      errors: results.errors
+    });
+  }
+  /**
+   * Delete a sync run
+   */
+  delete(id) {
+    const result = this.db.getDb().prepare("DELETE FROM sync_runs WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+  /**
+   * Delete old sync runs (cleanup)
+   */
+  deleteOlderThan(days) {
+    const result = this.db.getDb().prepare(`
+            DELETE FROM sync_runs 
+            WHERE started_at < datetime('now', '-' || ? || ' days')
+        `).run(days);
+    return result.changes;
+  }
+  /**
+   * Convert database row to SyncRun
+   */
+  rowToRun(row) {
+    return {
+      id: row.id,
+      sourceConnectionId: row.source_connection_id || void 0,
+      targetConnectionId: row.target_connection_id || void 0,
+      schemaName: row.schema_name || void 0,
+      tableName: row.table_name || void 0,
+      groupId: row.group_id || void 0,
+      startedAt: new Date(row.started_at),
+      completedAt: row.completed_at ? new Date(row.completed_at) : void 0,
+      status: row.status,
+      inserts: row.inserts,
+      updates: row.updates,
+      deletes: row.deletes,
+      errors: row.errors_json ? JSON.parse(row.errors_json) : [],
+      sqlStatements: row.sql_statements ? JSON.parse(row.sql_statements) : [],
+      sourceConnectionName: row.source_connection_name,
+      targetConnectionName: row.target_connection_name,
+      groupName: row.group_name
+    };
+  }
+};
+
+// packages/metadata/dist/repositories/schema-snapshot.repository.js
+var SchemaSnapshotRepository = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Create a new schema snapshot
+   */
+  create(input) {
+    const id = crypto.randomUUID();
+    const schemaJsonStr = JSON.stringify(input.schemaJson);
+    this.db.getDb().prepare(`
+            INSERT INTO schema_snapshots (id, connection_id, schema_json)
+            VALUES (?, ?, ?)
+        `).run(id, input.connectionId, schemaJsonStr);
+    return this.findById(id);
+  }
+  /**
+   * Find a snapshot by ID
+   */
+  findById(id) {
+    const row = this.db.getDb().prepare(`
+            SELECT 
+                ss.*,
+                c.name as connection_name
+            FROM schema_snapshots ss
+            LEFT JOIN connections c ON ss.connection_id = c.id
+            WHERE ss.id = ?
+        `).get(id);
+    return row ? this.rowToSnapshot(row) : null;
+  }
+  /**
+   * Find snapshots by connection ID
+   */
+  findByConnectionId(connectionId, limit) {
+    let query = `
+            SELECT 
+                ss.*,
+                c.name as connection_name
+            FROM schema_snapshots ss
+            LEFT JOIN connections c ON ss.connection_id = c.id
+            WHERE ss.connection_id = ?
+            ORDER BY ss.captured_at DESC
+        `;
+    if (limit) {
+      query += ` LIMIT ${limit}`;
+    }
+    const rows = this.db.getDb().prepare(query).all(connectionId);
+    return rows.map((row) => this.rowToSnapshot(row));
+  }
+  /**
+   * Find the latest snapshot for a connection
+   */
+  findLatest(connectionId) {
+    const row = this.db.getDb().prepare(`
+            SELECT 
+                ss.*,
+                c.name as connection_name
+            FROM schema_snapshots ss
+            LEFT JOIN connections c ON ss.connection_id = c.id
+            WHERE ss.connection_id = ?
+            ORDER BY ss.captured_at DESC
+            LIMIT 1
+        `).get(connectionId);
+    return row ? this.rowToSnapshot(row) : null;
+  }
+  /**
+   * Find all snapshots
+   */
+  findAll(limit = 100) {
+    const rows = this.db.getDb().prepare(`
+            SELECT 
+                ss.*,
+                c.name as connection_name
+            FROM schema_snapshots ss
+            LEFT JOIN connections c ON ss.connection_id = c.id
+            ORDER BY ss.captured_at DESC
+            LIMIT ?
+        `).all(limit);
+    return rows.map((row) => this.rowToSnapshot(row));
+  }
+  /**
+   * Delete a snapshot
+   */
+  delete(id) {
+    const result = this.db.getDb().prepare("DELETE FROM schema_snapshots WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+  /**
+   * Delete snapshots older than N days
+   */
+  deleteOlderThan(days) {
+    const result = this.db.getDb().prepare(`
+            DELETE FROM schema_snapshots 
+            WHERE captured_at < datetime('now', '-' || ? || ' days')
+        `).run(days);
+    return result.changes;
+  }
+  /**
+   * Delete all snapshots for a connection except the N most recent
+   */
+  keepLatest(connectionId, count) {
+    const result = this.db.getDb().prepare(`
+            DELETE FROM schema_snapshots 
+            WHERE connection_id = ?
+            AND id NOT IN (
+                SELECT id FROM schema_snapshots
+                WHERE connection_id = ?
+                ORDER BY captured_at DESC
+                LIMIT ?
+            )
+        `).run(connectionId, connectionId, count);
+    return result.changes;
+  }
+  /**
+   * Convert database row to SchemaSnapshot
+   */
+  rowToSnapshot(row) {
+    return {
+      id: row.id,
+      connectionId: row.connection_id,
+      capturedAt: new Date(row.captured_at),
+      schemaJson: JSON.parse(row.schema_json),
+      connectionName: row.connection_name
+    };
+  }
+};
+
+// packages/metadata/dist/repositories/audit-log.repository.js
+var AuditLogRepository = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Create a new audit log entry
+   */
+  create(input) {
+    const id = crypto.randomUUID();
+    const detailsJson = input.details ? JSON.stringify(input.details) : null;
+    this.db.getDb().prepare(`
+            INSERT INTO audit_log (id, action, entity_type, entity_id, connection_id, details_json)
+            VALUES (?, ?, ?, ?, ?, ?)
+        `).run(id, input.action, input.entityType, input.entityId || null, input.connectionId || null, detailsJson);
+    return this.findById(id);
+  }
+  /**
+   * Log a sync operation start
+   */
+  logSyncStart(syncRunId, connectionId, details) {
+    return this.create({
+      action: "data_sync_started",
+      entityType: "sync_run",
+      entityId: syncRunId,
+      connectionId,
+      details
+    });
+  }
+  /**
+   * Log a sync operation completion
+   */
+  logSyncComplete(syncRunId, connectionId, results) {
+    const hasErrors = results.errors.length > 0;
+    return this.create({
+      action: hasErrors ? "data_sync_failed" : "data_sync_completed",
+      entityType: "sync_run",
+      entityId: syncRunId,
+      connectionId,
+      details: results
+    });
+  }
+  /**
+   * Log a schema migration
+   */
+  logMigration(migrationId, targetConnectionId, details) {
+    return this.create({
+      action: "schema_migration_applied",
+      entityType: "migration",
+      entityId: migrationId,
+      connectionId: targetConnectionId,
+      details
+    });
+  }
+  /**
+   * Log a query execution
+   */
+  logQuery(connectionId, details) {
+    return this.create({
+      action: "query_executed",
+      entityType: "query",
+      connectionId,
+      details
+    });
+  }
+  /**
+   * Find an entry by ID
+   */
+  findById(id) {
+    const row = this.db.getDb().prepare(`
+            SELECT 
+                al.*,
+                c.name as connection_name
+            FROM audit_log al
+            LEFT JOIN connections c ON al.connection_id = c.id
+            WHERE al.id = ?
+        `).get(id);
+    return row ? this.rowToEntry(row) : null;
+  }
+  /**
+   * Find entries by connection ID
+   */
+  findByConnectionId(connectionId, limit) {
+    let query = `
+            SELECT 
+                al.*,
+                c.name as connection_name
+            FROM audit_log al
+            LEFT JOIN connections c ON al.connection_id = c.id
+            WHERE al.connection_id = ?
+            ORDER BY al.created_at DESC
+        `;
+    if (limit) {
+      query += ` LIMIT ${limit}`;
+    }
+    const rows = this.db.getDb().prepare(query).all(connectionId);
+    return rows.map((row) => this.rowToEntry(row));
+  }
+  /**
+   * Find entries by action type
+   */
+  findByAction(action, limit) {
+    let query = `
+            SELECT 
+                al.*,
+                c.name as connection_name
+            FROM audit_log al
+            LEFT JOIN connections c ON al.connection_id = c.id
+            WHERE al.action = ?
+            ORDER BY al.created_at DESC
+        `;
+    if (limit) {
+      query += ` LIMIT ${limit}`;
+    }
+    const rows = this.db.getDb().prepare(query).all(action);
+    return rows.map((row) => this.rowToEntry(row));
+  }
+  /**
+   * Find entries by entity
+   */
+  findByEntity(entityType, entityId) {
+    const rows = this.db.getDb().prepare(`
+            SELECT 
+                al.*,
+                c.name as connection_name
+            FROM audit_log al
+            LEFT JOIN connections c ON al.connection_id = c.id
+            WHERE al.entity_type = ? AND al.entity_id = ?
+            ORDER BY al.created_at DESC
+        `).all(entityType, entityId);
+    return rows.map((row) => this.rowToEntry(row));
+  }
+  /**
+   * Find recent entries
+   */
+  findRecent(limit = 100) {
+    const rows = this.db.getDb().prepare(`
+            SELECT 
+                al.*,
+                c.name as connection_name
+            FROM audit_log al
+            LEFT JOIN connections c ON al.connection_id = c.id
+            ORDER BY al.created_at DESC
+            LIMIT ?
+        `).all(limit);
+    return rows.map((row) => this.rowToEntry(row));
+  }
+  /**
+   * Delete entries older than N days
+   */
+  deleteOlderThan(days) {
+    const result = this.db.getDb().prepare(`
+            DELETE FROM audit_log 
+            WHERE created_at < datetime('now', '-' || ? || ' days')
+        `).run(days);
+    return result.changes;
+  }
+  /**
+   * Convert database row to AuditLogEntry
+   */
+  rowToEntry(row) {
+    return {
+      id: row.id,
+      action: row.action,
+      entityType: row.entity_type,
+      entityId: row.entity_id || void 0,
+      connectionId: row.connection_id || void 0,
+      details: row.details_json ? JSON.parse(row.details_json) : void 0,
+      createdAt: new Date(row.created_at),
+      connectionName: row.connection_name
+    };
+  }
+};
+
 // apps/api/dist/metadata/metadata.service.js
 import * as path from "node:path";
 import * as fs from "node:fs";
@@ -82004,6 +82566,9 @@ var MetadataService = MetadataService_1 = class MetadataService2 {
   _migrationHistoryRepository;
   _projectRepository;
   _databaseGroupRepository;
+  _syncRunRepository;
+  _schemaSnapshotRepository;
+  _auditLogRepository;
   onModuleInit() {
     let dbnexusDir;
     if (process.env["DBNEXUS_DATA_DIR"]) {
@@ -82026,6 +82591,9 @@ var MetadataService = MetadataService_1 = class MetadataService2 {
     this._migrationHistoryRepository = new MigrationHistoryRepository(this.db);
     this._projectRepository = new ProjectRepository(this.db);
     this._databaseGroupRepository = new DatabaseGroupRepository(this.db);
+    this._syncRunRepository = new SyncRunRepository(this.db);
+    this._schemaSnapshotRepository = new SchemaSnapshotRepository(this.db);
+    this._auditLogRepository = new AuditLogRepository(this.db);
     this.logger.log(`\u{1F4E6} Metadata database initialized at ${dbPath}`);
   }
   onModuleDestroy() {
@@ -82046,6 +82614,15 @@ var MetadataService = MetadataService_1 = class MetadataService2 {
   get databaseGroupRepository() {
     return this._databaseGroupRepository;
   }
+  get syncRunRepository() {
+    return this._syncRunRepository;
+  }
+  get schemaSnapshotRepository() {
+    return this._schemaSnapshotRepository;
+  }
+  get auditLogRepository() {
+    return this._auditLogRepository;
+  }
   get database() {
     return this.db;
   }
@@ -83801,16 +84378,36 @@ function normalizeDefaultForComparison(defaultValue) {
   }
   return defaultValue;
 }
+function getColumnDefForCreate(col, engine) {
+  const quotedName = quoteIdentifier(col.name, engine);
+  if (isIdentityOrSerialDefault(col.defaultValue)) {
+    if (engine === "postgres") {
+      const isBigInt = col.dataType.toLowerCase().includes("big");
+      const baseType = isBigInt ? "BIGINT" : "INTEGER";
+      return `${quotedName} ${baseType} GENERATED BY DEFAULT AS IDENTITY`;
+    } else if (engine === "mysql" || engine === "mariadb") {
+      const isBigInt = col.dataType.toLowerCase().includes("big");
+      const baseType = isBigInt ? "BIGINT" : "INT";
+      let def2 = `${quotedName} ${baseType} AUTO_INCREMENT`;
+      if (!col.nullable)
+        def2 += " NOT NULL";
+      return def2;
+    } else {
+      return `${quotedName} INTEGER`;
+    }
+  }
+  let def = `${quotedName} ${col.dataType}`;
+  if (!col.nullable)
+    def += " NOT NULL";
+  if (col.defaultValue !== null)
+    def += ` DEFAULT ${col.defaultValue}`;
+  return def;
+}
 function generateCreateTableSql(table, engine) {
   const sql = [];
   const columnDefs = [];
   for (const col of table.columns) {
-    let def = `${quoteIdentifier(col.name, engine)} ${col.dataType}`;
-    if (!col.nullable)
-      def += " NOT NULL";
-    if (col.defaultValue !== null)
-      def += ` DEFAULT ${col.defaultValue}`;
-    columnDefs.push(def);
+    columnDefs.push(getColumnDefForCreate(col, engine));
   }
   const primaryKey = parseColumnArray(table.primaryKey);
   if (primaryKey.length > 0) {
@@ -83833,7 +84430,22 @@ function generateDropTableSql(schema, table, engine) {
   return `DROP TABLE IF EXISTS ${quoteTable(schema, table, engine)};`;
 }
 function generateAddColumnSql(schema, table, col, engine) {
-  let sql = `ALTER TABLE ${quoteTable(schema, table, engine)} ADD COLUMN ${quoteIdentifier(col.name, engine)} ${col.dataType}`;
+  const prefix = `ALTER TABLE ${quoteTable(schema, table, engine)} ADD COLUMN`;
+  if (isIdentityOrSerialDefault(col.defaultValue)) {
+    if (engine === "postgres") {
+      const isBigInt = col.dataType.toLowerCase().includes("big");
+      const baseType = isBigInt ? "BIGINT" : "INTEGER";
+      return `${prefix} ${quoteIdentifier(col.name, engine)} ${baseType} GENERATED BY DEFAULT AS IDENTITY;`;
+    } else if (engine === "mysql" || engine === "mariadb") {
+      const isBigInt = col.dataType.toLowerCase().includes("big");
+      const baseType = isBigInt ? "BIGINT" : "INT";
+      let sql2 = `${prefix} ${quoteIdentifier(col.name, engine)} ${baseType} AUTO_INCREMENT`;
+      if (!col.nullable)
+        sql2 += " NOT NULL";
+      return sql2 + ";";
+    }
+  }
+  let sql = `${prefix} ${quoteIdentifier(col.name, engine)} ${col.dataType}`;
   if (!col.nullable)
     sql += " NOT NULL";
   if (col.defaultValue !== null)
@@ -84779,6 +85391,40 @@ function isJsonColumn(dataType) {
   const typeLower = dataType.toLowerCase();
   return typeLower === "json" || typeLower === "jsonb";
 }
+function formatValueForSql(value) {
+  if (value === null || value === void 0) {
+    return "NULL";
+  }
+  if (typeof value === "string") {
+    return `'${value.replace(/'/g, "''")}'`;
+  }
+  if (typeof value === "number" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "TRUE" : "FALSE";
+  }
+  if (value instanceof Date) {
+    return `'${value.toISOString()}'`;
+  }
+  if (typeof value === "object") {
+    return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+  }
+  return String(value);
+}
+function buildReadableSql(template, values, engine) {
+  let sql = template;
+  if (engine === "mysql" || engine === "mariadb") {
+    for (const value of values) {
+      sql = sql.replace("?", formatValueForSql(value));
+    }
+  } else {
+    for (let i = values.length; i >= 1; i--) {
+      sql = sql.replace(`$${i}`, formatValueForSql(values[i - 1]));
+    }
+  }
+  return sql;
+}
 function serializeValueForInsert(value, dataType) {
   if (value === null || value === void 0) {
     return value;
@@ -84979,17 +85625,21 @@ var SyncService = SyncService_1 = class SyncService2 {
    * Get detailed data diff for a specific table
    */
   async getTableDataDiff(sourceConnectionId, targetConnectionId, schema, table, primaryKeyColumns) {
+    const pkColumns = parseColumnArray(primaryKeyColumns);
+    if (pkColumns.length === 0) {
+      throw new Error("No primary key columns provided");
+    }
     const sourceConnection = this.connectionsService.findById(sourceConnectionId);
     const targetConnection = this.connectionsService.findById(targetConnectionId);
     const sourceConnector = await this.connectionsService.getConnector(sourceConnectionId);
     const targetConnector = await this.connectionsService.getConnector(targetConnectionId);
     const sourceTableRef = quoteTableRef(schema, table, sourceConnection.engine);
     const targetTableRef = quoteTableRef(schema, table, targetConnection.engine);
-    const sourceOrderBy = primaryKeyColumns.map((c) => quoteIdentifier2(c, sourceConnection.engine)).join(", ");
-    const targetOrderBy = primaryKeyColumns.map((c) => quoteIdentifier2(c, targetConnection.engine)).join(", ");
+    const sourceOrderBy = pkColumns.map((c) => quoteIdentifier2(c, sourceConnection.engine)).join(", ");
+    const targetOrderBy = pkColumns.map((c) => quoteIdentifier2(c, targetConnection.engine)).join(", ");
     const sourceResult = await sourceConnector.query(`SELECT * FROM ${sourceTableRef} ORDER BY ${sourceOrderBy}`);
     const targetResult = await targetConnector.query(`SELECT * FROM ${targetTableRef} ORDER BY ${targetOrderBy}`);
-    const getPkValue = (row) => primaryKeyColumns.map((c) => String(row[c])).join("|");
+    const getPkValue = (row) => pkColumns.map((c) => String(row[c])).join("|");
     const sourceMap = /* @__PURE__ */ new Map();
     const targetMap = /* @__PURE__ */ new Map();
     for (const row of sourceResult.rows) {
@@ -85030,7 +85680,26 @@ var SyncService = SyncService_1 = class SyncService2 {
     };
     const targetConnection = this.connectionsService.findById(targetConnectionId);
     const targetConnector = await this.connectionsService.getConnector(targetConnectionId);
-    const diff = await this.getTableDataDiff(sourceConnectionId, targetConnectionId, schema, table, primaryKeyColumns);
+    const parsedPkColumns = parseColumnArray(primaryKeyColumns);
+    let effectivePkColumns = parsedPkColumns;
+    if (parsedPkColumns.length === 0 || parsedPkColumns.length === 1 && parsedPkColumns[0] === "id") {
+      const tableSchema2 = await targetConnector.getTableSchema(schema, table);
+      const schemaPks = parseColumnArray(tableSchema2.primaryKey);
+      if (schemaPks.length > 0) {
+        effectivePkColumns = schemaPks;
+        this.logger.debug(`Auto-detected primary keys for ${schema}.${table}: ${effectivePkColumns.join(", ")}`);
+      } else {
+        effectivePkColumns = ["id"];
+        this.logger.warn(`No primary key found for ${schema}.${table}, falling back to 'id'`);
+      }
+    }
+    const syncRun = this.metadataService.syncRunRepository.create({
+      sourceConnectionId,
+      targetConnectionId,
+      schemaName: schema,
+      tableName: table
+    });
+    const diff = await this.getTableDataDiff(sourceConnectionId, targetConnectionId, schema, table, effectivePkColumns);
     const tableSchema = await targetConnector.getTableSchema(schema, table);
     const columns = tableSchema.columns.map((c) => c.name);
     const columnTypes = new Map(tableSchema.columns.map((c) => [c.name, c.dataType]));
@@ -85041,13 +85710,16 @@ var SyncService = SyncService_1 = class SyncService2 {
       const dataType = columnTypes.get(colName) || "";
       return serializeValueForInsert(value, dataType);
     };
+    const executedSql = [];
     if (options.insertMissing && diff.missingInTarget.length > 0) {
       for (const row of diff.missingInTarget) {
         try {
           const values = insertableColumns.map((c) => serializeValue(c, row[c]));
           const placeholders = insertableColumns.map((_, i) => getPlaceholder(i + 1, engine)).join(", ");
           const quotedColumns = insertableColumns.map((c) => quoteIdentifier2(c, engine)).join(", ");
-          await targetConnector.execute(`INSERT INTO ${tableRef} (${quotedColumns}) VALUES (${placeholders})`, values);
+          const sqlTemplate = `INSERT INTO ${tableRef} (${quotedColumns}) VALUES (${placeholders})`;
+          executedSql.push(buildReadableSql(sqlTemplate, values, engine));
+          await targetConnector.execute(sqlTemplate, values);
           result.inserted++;
         } catch (error) {
           result.errors.push(`Insert failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -85057,14 +85729,16 @@ var SyncService = SyncService_1 = class SyncService2 {
     if (options.updateDifferent && diff.different.length > 0) {
       for (const { source } of diff.different) {
         try {
-          const nonPkColumns = columns.filter((c) => !primaryKeyColumns.includes(c));
+          const nonPkColumns = columns.filter((c) => !effectivePkColumns.includes(c));
           const setClause = nonPkColumns.map((c, i) => `${quoteIdentifier2(c, engine)} = ${getPlaceholder(i + 1, engine)}`).join(", ");
-          const whereClause = primaryKeyColumns.map((c, i) => `${quoteIdentifier2(c, engine)} = ${getPlaceholder(nonPkColumns.length + i + 1, engine)}`).join(" AND ");
+          const whereClause = effectivePkColumns.map((c, i) => `${quoteIdentifier2(c, engine)} = ${getPlaceholder(nonPkColumns.length + i + 1, engine)}`).join(" AND ");
           const values = [
             ...nonPkColumns.map((c) => serializeValue(c, source[c])),
-            ...primaryKeyColumns.map((c) => serializeValue(c, source[c]))
+            ...effectivePkColumns.map((c) => serializeValue(c, source[c]))
           ];
-          await targetConnector.execute(`UPDATE ${tableRef} SET ${setClause} WHERE ${whereClause}`, values);
+          const sqlTemplate = `UPDATE ${tableRef} SET ${setClause} WHERE ${whereClause}`;
+          executedSql.push(buildReadableSql(sqlTemplate, values, engine));
+          await targetConnector.execute(sqlTemplate, values);
           result.updated++;
         } catch (error) {
           result.errors.push(`Update failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -85074,15 +85748,25 @@ var SyncService = SyncService_1 = class SyncService2 {
     if (options.deleteExtra && diff.missingInSource.length > 0) {
       for (const row of diff.missingInSource) {
         try {
-          const whereClause = primaryKeyColumns.map((c, i) => `${quoteIdentifier2(c, engine)} = ${getPlaceholder(i + 1, engine)}`).join(" AND ");
-          const values = primaryKeyColumns.map((c) => row[c]);
-          await targetConnector.execute(`DELETE FROM ${tableRef} WHERE ${whereClause}`, values);
+          const whereClause = effectivePkColumns.map((c, i) => `${quoteIdentifier2(c, engine)} = ${getPlaceholder(i + 1, engine)}`).join(" AND ");
+          const values = effectivePkColumns.map((c) => row[c]);
+          const sqlTemplate = `DELETE FROM ${tableRef} WHERE ${whereClause}`;
+          executedSql.push(buildReadableSql(sqlTemplate, values, engine));
+          await targetConnector.execute(sqlTemplate, values);
           result.deleted++;
         } catch (error) {
           result.errors.push(`Delete failed: ${error instanceof Error ? error.message : String(error)}`);
         }
       }
     }
+    this.metadataService.syncRunRepository.update(syncRun.id, {
+      status: result.errors.length > 0 ? "failed" : "completed",
+      inserts: result.inserted,
+      updates: result.updated,
+      deletes: result.deleted,
+      errors: result.errors,
+      sqlStatements: executedSql
+    });
     return result;
   }
   /**
@@ -85233,6 +85917,11 @@ var SyncService = SyncService_1 = class SyncService2 {
       errors: [],
       tableResults: []
     };
+    const syncRun = this.metadataService.syncRunRepository.create({
+      sourceConnectionId,
+      targetConnectionId,
+      schemaName: schema
+    });
     const sourceConnection = this.connectionsService.findById(sourceConnectionId);
     const targetConnection = this.connectionsService.findById(targetConnectionId);
     const sourceConnector = await this.connectionsService.getConnector(sourceConnectionId);
@@ -85327,6 +86016,12 @@ var SyncService = SyncService_1 = class SyncService2 {
     } finally {
       await this.setForeignKeyChecks(targetConnector, targetEngine, true);
     }
+    this.metadataService.syncRunRepository.complete(syncRun.id, {
+      inserts: result.rowsCopied,
+      updates: 0,
+      deletes: 0,
+      errors: result.errors
+    });
     return result;
   }
   /**
@@ -85372,8 +86067,16 @@ var __param6 = function(paramIndex, decorator) {
 };
 var SyncController = class SyncController2 {
   syncService;
-  constructor(syncService) {
+  metadataService;
+  constructor(syncService, metadataService) {
     this.syncService = syncService;
+    this.metadataService = metadataService;
+  }
+  /**
+   * Get recent sync runs (for activity log)
+   */
+  getSyncRuns(limit) {
+    return this.metadataService.syncRunRepository.findRecent(limit ? parseInt(limit, 10) : 500);
   }
   /**
    * Get sync status for an instance group
@@ -85472,6 +86175,13 @@ var SyncController = class SyncController2 {
     });
   }
 };
+__decorate17([
+  (0, import_common16.Get)("runs"),
+  __param6(0, (0, import_common16.Query)("limit")),
+  __metadata11("design:type", Function),
+  __metadata11("design:paramtypes", [String]),
+  __metadata11("design:returntype", void 0)
+], SyncController.prototype, "getSyncRuns", null);
 __decorate17([
   (0, import_common16.Get)("groups/:groupId/status"),
   __param6(0, (0, import_common16.Param)("groupId")),
@@ -85556,7 +86266,10 @@ __decorate17([
 ], SyncController.prototype, "dumpAndRestore", null);
 SyncController = __decorate17([
   (0, import_common16.Controller)("sync"),
-  __metadata11("design:paramtypes", [SyncService])
+  __metadata11("design:paramtypes", [
+    SyncService,
+    MetadataService
+  ])
 ], SyncController);
 
 // apps/api/dist/sync/sync.module.js