pg-migration-engine 0.1.0

package/src/executor/drift-detector.js

@@ -0,0 +1,221 @@
+/**
+ * Drift Detector - Detect schema drift during migration execution
+ */
+
+export class DriftDetector {
+  /**
+   * Compare before/after snapshots to detect drift
+   * @param {Object} snapshotBefore - Snapshot before migration
+   * @param {Object} snapshotAfter - Snapshot after migration
+   * @param {Object} expectedDiff - The diff we applied
+   * @returns {Object} Drift report
+   */
+  detect(snapshotBefore, snapshotAfter, expectedDiff) {
+    const drift = {
+      detected: false,
+      unexpectedChanges: [],
+      missingChanges: [],
+      extraChanges: [],
+      summary: {
+        objectsModified: 0,
+        objectsCreated: 0,
+        objectsDropped: 0,
+      },
+    };
+
+    if (!snapshotBefore?.checksums || !snapshotAfter?.checksums) {
+      return drift;
+    }
+
+    const beforeMap = new Map(
+      snapshotBefore.checksums.map(c => [`${c.schema}.${c.name}.${c.kind}`, c.checksum])
+    );
+    const afterMap = new Map(
+      snapshotAfter.checksums.map(c => [`${c.schema}.${c.name}.${c.kind}`, c.checksum])
+    );
+
+    const ourPaths = new Set(
+      (expectedDiff.changes || []).map(c => c.objectKey || c.path)
+    );
+
+    for (const [key, afterChecksum] of afterMap) {
+      const beforeChecksum = beforeMap.get(key);
+
+      if (beforeChecksum && beforeChecksum !== afterChecksum) {
+        if (!ourPaths.has(key)) {
+          drift.detected = true;
+          drift.unexpectedChanges.push({
+            path: key,
+            type: 'modified',
+            message: `Schema object ${key} was modified by another process during migration`,
+          });
+          drift.summary.objectsModified++;
+        }
+      }
+    }
+
+    for (const [key] of beforeMap) {
+      if (!afterMap.has(key)) {
+        const wasDropped = (expectedDiff.changes || []).some(
+          c => (c.objectKey === key || c.path === key) && c.changeType?.startsWith('DROP')
+        );
+        if (!wasDropped) {
+          drift.detected = true;
+          drift.unexpectedChanges.push({
+            path: key,
+            type: 'dropped',
+            message: `Schema object ${key} was dropped by another process during migration`,
+          });
+          drift.summary.objectsDropped++;
+        }
+      }
+    }
+
+    for (const [key] of afterMap) {
+      if (!beforeMap.has(key)) {
+        const wasCreated = (expectedDiff.changes || []).some(
+          c => (c.objectKey === key || c.path === key) && c.changeType?.startsWith('CREATE')
+        );
+        if (!wasCreated) {
+          drift.detected = true;
+          drift.unexpectedChanges.push({
+            path: key,
+            type: 'created',
+            message: `Schema object ${key} was created by another process during migration`,
+          });
+          drift.summary.objectsCreated++;
+        }
+      }
+    }
+
+    const expectedCreates = (expectedDiff.changes || []).filter(
+      c => c.changeType?.startsWith('CREATE')
+    );
+    for (const expected of expectedCreates) {
+      const key = expected.objectKey || expected.path;
+      if (!afterMap.has(key)) {
+        drift.missingChanges.push({
+          path: key,
+          expectedType: 'CREATE',
+          message: `Expected object ${key} was not created`,
+        });
+      }
+    }
+
+    return drift;
+  }
+
+  /**
+   * Compare two schema snapshots for column-level drift
+   * @param {Object} snapshotBefore
+   * @param {Object} snapshotAfter
+   * @param {string} tableName - Table to check
+   * @returns {Object} Column-level drift report
+   */
+  detectColumnDrift(snapshotBefore, snapshotAfter, tableName) {
+    const drift = {
+      tableName,
+      columnsAdded: [],
+      columnsDropped: [],
+      columnsModified: [],
+    };
+
+    const beforeCols = this.getTableColumns(snapshotBefore, tableName);
+    const afterCols = this.getTableColumns(snapshotAfter, tableName);
+
+    for (const [colName, afterCol] of Object.entries(afterCols)) {
+      if (!beforeCols[colName]) {
+        drift.columnsAdded.push(colName);
+      } else if (JSON.stringify(beforeCols[colName]) !== JSON.stringify(afterCol)) {
+        drift.columnsModified.push({
+          name: colName,
+          before: beforeCols[colName],
+          after: afterCol,
+        });
+      }
+    }
+
+    for (const colName of Object.keys(beforeCols)) {
+      if (!afterCols[colName]) {
+        drift.columnsDropped.push(colName);
+      }
+    }
+
+    drift.hasDrift = drift.columnsAdded.length > 0 ||
+                     drift.columnsDropped.length > 0 ||
+                     drift.columnsModified.length > 0;
+
+    return drift;
+  }
+
+  /**
+   * Get columns for a table from snapshot
+   * @param {Object} snapshot
+   * @param {string} tableName
+   * @returns {Object}
+   */
+  getTableColumns(snapshot, tableName) {
+    if (!snapshot?.schemas) return {};
+
+    const parts = tableName.split('.');
+    const schemaName = parts.length > 1 ? parts[0] : 'public';
+    const table = parts.length > 1 ? parts[1] : parts[0];
+
+    const schema = snapshot.schemas[schemaName];
+    if (!schema?.tables) return {};
+
+    const tableObj = schema.tables.find(t => t.name === table);
+    if (!tableObj?.columns) return {};
+
+    const cols = {};
+    for (const col of tableObj.columns) {
+      cols[col.name] = {
+        dataType: col.dataType,
+        isNullable: col.isNullable,
+        defaultValue: col.defaultValue,
+      };
+    }
+    return cols;
+  }
+
+  /**
+   * Quick drift check using pg_stat_* system view activity
+   * @param {import('pg').Pool} pool
+   * @returns {Promise<Object>}
+   */
+  async quickDriftCheck(pool) {
+    const client = await pool.connect();
+
+    try {
+      const activityQuery = `
+        SELECT DISTINCT
+          query,
+          state,
+          query_start,
+          now() - query_start AS duration
+        FROM pg_stat_activity
+        WHERE state = 'active'
+          AND query NOT LIKE 'pg_stat_activity%'
+          AND pid != pg_backend_pid()
+          AND now() - query_start < interval '5 minutes'
+        ORDER BY query_start
+      `;
+
+      const activity = await client.query(activityQuery);
+
+      const ddlActivity = activity.rows.filter(r =>
+        r.query.toUpperCase().match(/^(CREATE|ALTER|DROP|TRUNCATE)\s/)
+      );
+
+      return {
+        hasDDLActivity: ddlActivity.length > 0,
+        activityCount: activity.rows.length,
+        ddlActivityCount: ddlActivity.length,
+        ddlQueries: ddlActivity,
+      };
+
+    } finally {
+      client.release();
+    }
+  }
+}

package/src/executor/index.js

@@ -0,0 +1,7 @@
+export { MigrationExecutor } from './migration-executor.js';
+export { TransactionManager } from './transaction-manager.js';
+export { LockManager } from './lock-manager.js';
+export { ProgressTracker } from './progress-tracker.js';
+export { SnapshotManager } from './snapshot-manager.js';
+export { DriftDetector } from './drift-detector.js';
+export { RecoveryManager } from './recovery-manager.js';

package/src/executor/lock-manager.js

@@ -0,0 +1,308 @@
+import crypto from 'crypto';
+
+export class LockManager {
+  isLocked = false;
+  lockId = null;
+  connectionId = null;
+  _heartbeatTimer = null;
+  _heartbeatClient = null;
+
+  constructor(pool, options = {}) {
+    this.pool = pool;
+    this.locks = new Map();
+    this.connectionId = options.connectionId || null;
+    this.lockId = this.computeLockKey(this.connectionId);
+  }
+
+  computeLockKey(connectionId) {
+    if (!connectionId) {
+      console.warn(
+        '[SchemaWeaver] No connectionId for lock key computation. ' +
+        'Using default lock key. This may cause cross-database lock conflicts.'
+      );
+      return 12345;
+    }
+
+    const hash = crypto.createHash('sha256')
+      .update(`schema-weaver-lock:${connectionId}`)
+      .digest();
+
+    const lockKey = hash.readInt32BE(0);
+
+    return Math.abs(lockKey) || 1;
+  }
+
+  async acquire(lockKey, timeout) {
+    const effectiveKey = lockKey || this.lockId;
+    const client = await this.pool.connect();
+
+    try {
+      if (timeout) {
+        await client.query(`SET lock_timeout = '${timeout}'`);
+      }
+
+      const result = await client.query(
+        'SELECT pg_try_advisory_lock($1) as acquired',
+        [effectiveKey]
+      );
+
+      const acquired = result.rows[0].acquired;
+
+      if (acquired) {
+        this.isLocked = true;
+        this.lockId = effectiveKey;
+        this.locks.set(effectiveKey, {
+          acquiredAt: new Date().toISOString(),
+          client,
+          key: effectiveKey,
+        });
+      }
+
+      return acquired;
+
+    } catch (error) {
+      client.release();
+      throw error;
+    }
+  }
+
+  async acquireAndWait(lockKey, timeout) {
+    const effectiveKey = lockKey || this.lockId;
+    const client = await this.pool.connect();
+
+    try {
+      if (timeout) {
+        await client.query(`SET lock_timeout = '${timeout}'`);
+      }
+
+      const startTime = Date.now();
+
+      await client.query('SELECT pg_advisory_lock($1)', [effectiveKey]);
+
+      this.isLocked = true;
+      this.lockId = effectiveKey;
+      this.locks.set(effectiveKey, {
+        acquiredAt: new Date().toISOString(),
+        client,
+        key: effectiveKey,
+        waitTime: Date.now() - startTime,
+      });
+
+      return true;
+
+    } catch (error) {
+      client.release();
+
+      if (error.code === '55P03') {
+        return false;
+      }
+      throw error;
+    }
+  }
+
+  async release(lockKey) {
+    const effectiveKey = lockKey || this.lockId;
+    const lockInfo = this.locks.get(effectiveKey);
+
+    this.stopHeartbeat();
+
+    if (lockInfo) {
+      const { client } = lockInfo;
+
+      try {
+        await client.query('SELECT pg_advisory_unlock($1)', [effectiveKey]);
+        this.locks.delete(effectiveKey);
+        this.isLocked = false;
+        this.lockId = null;
+        return true;
+      } catch {
+        this.isLocked = false;
+        this.lockId = null;
+        return false;
+      } finally {
+        client.release();
+      }
+    }
+
+    const standaloneClient = await this.pool.connect();
+    try {
+      await standaloneClient.query('SELECT pg_advisory_unlock($1)', [effectiveKey]);
+      this.locks.delete(effectiveKey);
+      this.isLocked = false;
+      this.lockId = null;
+      return true;
+    } catch {
+      this.isLocked = false;
+      this.lockId = null;
+      return false;
+    } finally {
+      standaloneClient.release();
+    }
+  }
+
+  async isLocked(lockKey) {
+    const effectiveKey = lockKey || this.lockId;
+    const selfHeld = this.locks.has(effectiveKey);
+
+    if (selfHeld) {
+      return { held: true, heldBySelf: true };
+    }
+
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        'SELECT pg_try_advisory_lock($1) as acquired',
+        [effectiveKey]
+      );
+
+      const acquired = result.rows[0].acquired;
+
+      if (acquired) {
+        await client.query('SELECT pg_advisory_unlock($1)', [effectiveKey]);
+        return { held: false, heldBySelf: false };
+      }
+
+      return { held: true, heldBySelf: false };
+
+    } finally {
+      client.release();
+    }
+  }
+
+  isHeldBySelf(lockKey) {
+    const effectiveKey = lockKey || this.lockId;
+    return this.locks.has(effectiveKey);
+  }
+
+  async releaseAll() {
+    let count = 0;
+
+    for (const [lockKey] of this.locks) {
+      try {
+        await this.release(lockKey);
+        count++;
+      } catch {
+      }
+    }
+
+    return count;
+  }
+
+  startHeartbeat(lockKey, intervalMs = 30000) {
+    this.stopHeartbeat();
+    const effectiveKey = lockKey || this.lockId;
+    this.lockId = effectiveKey;
+
+    this._heartbeatTimer = setInterval(async () => {
+      try {
+        await this.heartbeat();
+      } catch {
+      }
+    }, intervalMs);
+  }
+
+  stopHeartbeat() {
+    if (this._heartbeatTimer) {
+      clearInterval(this._heartbeatTimer);
+      this._heartbeatTimer = null;
+    }
+  }
+
+  async heartbeat() {
+    if (!this.isLocked || !this.lockId) {
+      return false;
+    }
+
+    const held = await this.isLockHeld(this.lockId);
+    if (!held) {
+      this.isLocked = false;
+      throw new Error(`Advisory lock ${this.lockId} is no longer held. Connection may have been recycled.`);
+    }
+    return true;
+  }
+
+  async isLockHeld(lockKey) {
+    const effectiveKey = lockKey || this.lockId;
+    const result = await this.pool.query(
+      `SELECT COUNT(*)::int AS count FROM pg_locks WHERE locktype = 'advisory' AND objid = $1`,
+      [effectiveKey]
+    );
+    return result.rows[0].count > 0;
+  }
+
+  async forceRelease(lockKey) {
+    const effectiveKey = lockKey || this.lockId;
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `SELECT pg_try_advisory_lock($1) AS acquired`,
+        [effectiveKey]
+      );
+      if (result.rows[0].acquired) {
+        await client.query(`SELECT pg_advisory_unlock($1)`, [effectiveKey]);
+        this.isLocked = false;
+        this.locks.delete(effectiveKey);
+        return true;
+      }
+      return false;
+    } finally {
+      client.release();
+    }
+  }
+
+  async checkDeadlock(lockKey) {
+    const effectiveKey = lockKey || this.lockId;
+    const client = await this.pool.connect();
+
+    try {
+      const lockWaitQuery = `
+        SELECT
+          blocked.pid AS blocked_pid,
+          blocked.query AS blocked_query,
+          blocking.pid AS blocking_pid,
+          blocking.query AS blocking_query,
+          now() - blocked.query_start AS wait_duration
+        FROM pg_stat_activity blocked
+        JOIN pg_locks blocked_locks ON blocked_locks.pid = blocked.pid
+        JOIN pg_locks blocking_locks ON blocking_locks.locktype = blocked_locks.locktype
+          AND blocking_locks.database = blocked_locks.database
+          AND blocking_locks.relation = blocked_locks.relation
+          AND blocking_locks.pid != blocked_locks.pid
+        JOIN pg_stat_activity blocking ON blocking.pid = blocking_locks.pid
+        WHERE blocked_locks.granted = false
+      `;
+
+      const result = await client.query(lockWaitQuery);
+
+      return {
+        blockedQueries: result.rows,
+        hasPotentialDeadlock: result.rows.length > 0,
+      };
+
+    } finally {
+      client.release();
+    }
+  }
+
+  async getAllLocks() {
+    const client = await this.pool.connect();
+
+    try {
+      const result = await client.query(`
+        SELECT
+          locktype,
+          objid AS lock_key,
+          pid,
+          mode,
+          granted
+        FROM pg_locks
+        WHERE locktype = 'advisory'
+      `);
+
+      return result.rows;
+
+    } finally {
+      client.release();
+    }
+  }
+}