pg-migration-engine 0.1.0

package/src/executor/progress-tracker.js

@@ -0,0 +1,81 @@
+export class ProgressTracker {
+  constructor() {
+    this.progress = new Map();
+    this.listeners = new Set();
+    this.events = [];
+  }
+
+  /**
+   * @param {string} stepId
+   * @param {'PENDING'|'RUNNING'|'COMPLETED'|'FAILED'} status
+   * @param {string} [message]
+   */
+  update(stepId, status, message) {
+    this.progress.set(stepId, { status, message, timestamp: Date.now() });
+    for (const listener of this.listeners) {
+      listener({ stepId, status, message, timestamp: Date.now() });
+    }
+  }
+
+  /**
+   * Emit a progress event
+   * @param {Object} event
+   */
+  emit(event) {
+    this.events.push({
+      ...event,
+      timestamp: event.timestamp || Date.now(),
+    });
+
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (e) {
+        // Don't let listener errors break execution
+      }
+    }
+  }
+
+  /**
+   * Subscribe to progress events
+   * @param {Function} listener
+   * @returns {Function} Unsubscribe function
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  /**
+   * Get progress for a step
+   * @param {string} stepId
+   * @returns {Object}
+   */
+  get(stepId) {
+    return this.progress.get(stepId) || { status: 'PENDING' };
+  }
+
+  /**
+   * Get all progress
+   * @returns {Object}
+   */
+  getAll() {
+    return Object.fromEntries(this.progress);
+  }
+
+  /**
+   * Get all events
+   * @returns {Array}
+   */
+  getEvents() {
+    return this.events;
+  }
+
+  /**
+   * Clear all progress and events
+   */
+  clear() {
+    this.progress.clear();
+    this.events = [];
+  }
+}

package/src/executor/recovery-manager.js

@@ -0,0 +1,47 @@
+export class RecoveryManager {
+  /** @param {import('../types/execution.js').StorageProvider} storage */
+  constructor(storage) {
+    this.storage = storage;
+  }
+
+  /**
+   * @param {string} migrationId
+   * @returns {Promise<import('../types/execution.js').RecoveryResult>}
+   */
+  async recover(migrationId) {
+    const migration = await this.storage.getMigration(migrationId);
+    if (!migration) {
+      return { action: 'UNKNOWN', message: 'Migration not found' };
+    }
+
+    if (migration.status === 'COMPLETED') {
+      return { action: 'NONE', message: 'Migration already completed' };
+    }
+
+    if (migration.status === 'FAILED') {
+      return { action: 'RETRY', message: 'Database is consistent, migration can be retried' };
+    }
+
+    if (migration.status === 'RUNNING') {
+      return { action: 'WAIT', message: 'Migration is still running' };
+    }
+
+    if (migration.status === 'STALE') {
+      return { action: 'STALE_CLEANUP', message: 'Migration process died, cleaning up' };
+    }
+
+    return { action: 'UNKNOWN', message: `Unknown migration status: ${migration.status}` };
+  }
+
+  /**
+   * @param {string} migrationId
+   * @returns {Promise<void>}
+   */
+  async markFailed(migrationId) {
+    const migration = await this.storage.getMigration(migrationId);
+    if (migration) {
+      migration.status = 'FAILED';
+      await this.storage.saveMigration(migration);
+    }
+  }
+}

package/src/executor/snapshot-manager.js

@@ -0,0 +1,22 @@
+export class SnapshotManager {
+  /**
+   * @param {import('../introspection/index.js').SchemaIntrospector} introspector
+   * @param {import('../types/execution.js').StorageProvider} storage
+   */
+  constructor(introspector, storage) {
+    this.introspector = introspector;
+    this.storage = storage;
+  }
+
+  /** @returns {Promise<string>} */
+  async capture() {
+    const schema = await this.introspector.introspect();
+    await this.storage.saveSnapshot(schema.checksum, schema);
+    return schema.checksum;
+  }
+
+  /** @param {string} checksum */
+  async restore(checksum) {
+    return this.storage.loadSnapshot(checksum);
+  }
+}

package/src/executor/sql-splitter.js

@@ -0,0 +1,120 @@
+const DOLLAR_QUOTE_REGEX = /\$([a-zA-Z_][a-zA-Z0-9_]*)?\$/g;
+
+export function splitSqlStatements(sql) {
+  if (!sql || typeof sql !== 'string') return [];
+  
+  const statements = [];
+  let current = '';
+  let i = 0;
+  
+  while (i < sql.length) {
+    if (sql[i] === '-' && i + 1 < sql.length && sql[i + 1] === '-') {
+      current += sql[i];
+      i++;
+      while (i < sql.length && sql[i] !== '\n') {
+        current += sql[i];
+        i++;
+      }
+      if (i < sql.length) {
+        current += sql[i];
+        i++;
+      }
+      continue;
+    }
+    
+    if (sql[i] === '/' && i + 1 < sql.length && sql[i + 1] === '*') {
+      current += sql[i];
+      i++;
+      current += sql[i];
+      i++;
+      while (i < sql.length && !(sql[i - 1] === '*' && sql[i] === '/')) {
+        current += sql[i];
+        i++;
+      }
+      if (i < sql.length) {
+        current += sql[i];
+        i++;
+      }
+      continue;
+    }
+    
+    if (sql[i] === '$') {
+      const dollarMatch = sql.substring(i).match(DOLLAR_QUOTE_REGEX);
+      if (dollarMatch) {
+        const tag = dollarMatch[0];
+        current += tag;
+        i += tag.length;
+        
+        const endPattern = tag;
+        while (i < sql.length) {
+          if (sql.substring(i, i + tag.length) === endPattern) {
+            current += tag;
+            i += tag.length;
+            break;
+          }
+          current += sql[i];
+          i++;
+        }
+        continue;
+      }
+    }
+    
+    if (sql[i] === "'") {
+      current += sql[i];
+      i++;
+      while (i < sql.length) {
+        if (sql[i] === "'") {
+          current += sql[i];
+          i++;
+          if (i < sql.length && sql[i] === "'") {
+            current += sql[i];
+            i++;
+            continue;
+          }
+          break;
+        }
+        current += sql[i];
+        i++;
+      }
+      continue;
+    }
+    
+    if (sql[i] === '"') {
+      current += sql[i];
+      i++;
+      while (i < sql.length && sql[i] !== '"') {
+        current += sql[i];
+        i++;
+      }
+      if (i < sql.length) {
+        current += sql[i];
+        i++;
+      }
+      continue;
+    }
+    
+    if (sql[i] === ';') {
+      const trimmed = current.trim();
+      if (trimmed.length > 0) {
+        statements.push(trimmed);
+      }
+      current = '';
+      i++;
+      continue;
+    }
+    
+    current += sql[i];
+    i++;
+  }
+  
+  const trimmed = current.trim();
+  if (trimmed.length > 0) {
+    statements.push(trimmed);
+  }
+  
+  return statements;
+}
+
+export function sanitizeSavepointName(str) {
+  return str.replace(/[^a-zA-Z0-9_]/g, '_').substring(0, 63);
+}

package/src/executor/transaction-manager.js

@@ -0,0 +1,288 @@
+/**
+ * Transaction Manager - Handles transaction execution with proper error handling
+ */
+
+export class TransactionManager {
+  /**
+   * @param {import('pg').Pool} pool
+   */
+  constructor(pool) {
+    this.pool = pool;
+  }
+
+  /**
+   * Execute steps in a transaction
+   * @param {Array} steps - Steps to execute
+   * @param {Object} options - { lockTimeout, statementTimeout, dryRun, continueOnError }
+   * @returns {Promise<Array>} Results of each step
+   */
+  async executeTransactional(steps, options = {}) {
+    const client = await this.pool.connect();
+    const results = [];
+
+    try {
+      await client.query('BEGIN');
+
+      if (options.lockTimeout) {
+        await client.query(`SET LOCAL lock_timeout = '${options.lockTimeout}'`);
+      }
+      if (options.statementTimeout) {
+        await client.query(`SET LOCAL statement_timeout = '${options.statementTimeout}'`);
+      }
+
+      await client.query(`SET LOCAL search_path = 'public'`);
+
+      for (const step of steps) {
+        const startTime = Date.now();
+        try {
+          const result = await client.query(step.sql);
+          results.push({
+            stepId: step.id,
+            success: true,
+            duration: Date.now() - startTime,
+            rowCount: result.rowCount,
+            rows: result.rows,
+          });
+        } catch (error) {
+          results.push({
+            stepId: step.id,
+            success: false,
+            duration: Date.now() - startTime,
+            error: error.message,
+            code: error.code,
+          });
+
+          if (!options.continueOnError) {
+            throw error;
+          }
+        }
+      }
+
+      if (options.dryRun) {
+        await client.query('ROLLBACK');
+      } else {
+        await client.query('COMMIT');
+      }
+
+      return results;
+
+    } catch (error) {
+      await client.query('ROLLBACK').catch(() => {});
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+
+  /**
+   * Execute a single non-transactional step
+   * @param {Object} step - The step to execute
+   * @param {Object} options - { statementTimeout }
+   * @returns {Promise<Object>}
+   */
+  async executeNonTransactional(step, options = {}) {
+    const client = await this.pool.connect();
+
+    try {
+      if (options.statementTimeout) {
+        await client.query(`SET statement_timeout = '${options.statementTimeout}'`);
+      }
+
+      const startTime = Date.now();
+      const result = await client.query(step.sql);
+
+      return {
+        stepId: step.id,
+        success: true,
+        duration: Date.now() - startTime,
+        rowCount: result.rowCount,
+        isTransactional: false,
+        warning: 'This step was executed outside a transaction and cannot be automatically rolled back',
+      };
+
+    } catch (error) {
+      return {
+        stepId: step.id,
+        success: false,
+        error: error.message,
+        code: error.code,
+        isTransactional: false,
+        requiresManualRecovery: true,
+      };
+    } finally {
+      client.release();
+    }
+  }
+
+  /**
+   * Execute steps with validation first, then for real
+   * @param {Array} steps
+   * @param {Object} options
+   * @returns {Promise<Object>}
+   */
+  async executeWithValidation(steps, options = {}) {
+    const validationResult = await this.executeTransactional(steps, {
+      ...options,
+      dryRun: true,
+    });
+
+    const hasErrors = validationResult.some(r => !r.success);
+    if (hasErrors) {
+      return {
+        validated: false,
+        validationResults: validationResult,
+        message: 'Validation failed. Migration not applied.',
+      };
+    }
+
+    if (!options.dryRun) {
+      const executionResult = await this.executeTransactional(steps, {
+        ...options,
+        dryRun: false,
+      });
+      return {
+        validated: true,
+        executionResults: executionResult,
+      };
+    }
+
+    return {
+      validated: true,
+      validationResults: validationResult,
+      message: 'Validation passed (dry run). No changes applied.',
+    };
+  }
+
+  /**
+   * Execute with savepoint support for partial rollback
+   * @param {Array} steps
+   * @param {Object} options
+   * @returns {Promise<Object>}
+   */
+  async executeWithSavepoints(steps, options = {}) {
+    const client = await this.pool.connect();
+    const results = [];
+    let lastSuccessfulSavepoint = 0;
+
+    try {
+      await client.query('BEGIN');
+
+      if (options.lockTimeout) {
+        await client.query(`SET LOCAL lock_timeout = '${options.lockTimeout}'`);
+      }
+      if (options.statementTimeout) {
+        await client.query(`SET LOCAL statement_timeout = '${options.statementTimeout}'`);
+      }
+
+      for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        const savepointName = `sp_${i}`;
+
+        await client.query(`SAVEPOINT ${savepointName}`);
+
+        const startTime = Date.now();
+        try {
+          const result = await client.query(step.sql);
+          results.push({
+            stepId: step.id,
+            success: true,
+            duration: Date.now() - startTime,
+            rowCount: result.rowCount,
+            savepoint: savepointName,
+          });
+          lastSuccessfulSavepoint = i;
+        } catch (error) {
+          await client.query(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+
+          results.push({
+            stepId: step.id,
+            success: false,
+            duration: Date.now() - startTime,
+            error: error.message,
+            code: error.code,
+            savepoint: savepointName,
+          });
+
+          if (!options.continueOnError) {
+            throw error;
+          }
+        }
+      }
+
+      if (options.dryRun) {
+        await client.query('ROLLBACK');
+      } else {
+        await client.query('COMMIT');
+      }
+
+      return {
+        success: true,
+        results,
+        lastSuccessfulSavepoint,
+      };
+
+    } catch (error) {
+      await client.query('ROLLBACK').catch(() => {});
+      return {
+        success: false,
+        results,
+        lastSuccessfulSavepoint,
+        error: error.message,
+      };
+    } finally {
+      client.release();
+    }
+  }
+
+  /**
+   * Execute with retry on deadlock
+   * @param {Array} steps
+   * @param {Object} options
+   * @returns {Promise<Object>}
+   */
+  async executeWithRetry(steps, options = {}) {
+    const maxRetries = options.maxRetries || 3;
+    const retryDelay = options.retryDelay || 1000;
+    let lastError;
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        const result = await this.executeTransactional(steps, options);
+        return {
+          success: true,
+          results: result,
+          attempts: attempt,
+        };
+      } catch (error) {
+        lastError = error;
+
+        const isDeadlock = error.code === '40P01';
+        const isLockNotAvailable = error.code === '55P03';
+        const isSerializationFailure = error.code === '40001';
+
+        if (!isDeadlock && !isLockNotAvailable && !isSerializationFailure) {
+          throw error;
+        }
+
+        if (attempt < maxRetries) {
+          await new Promise(resolve => setTimeout(resolve, retryDelay * attempt));
+        }
+      }
+    }
+
+    return {
+      success: false,
+      error: lastError?.message,
+      attempts: maxRetries,
+    };
+  }
+
+  /**
+   * Dry run a single step
+   * @param {Object} step
+   * @returns {Promise<Object>}
+   */
+  async dryRun(step) {
+    return this.executeTransactional([step], { dryRun: true });
+  }
+}