@dotdo/postgres 0.1.0

package/src/migrations/rollback.test.ts

@@ -0,0 +1,644 @@
+/**
+ * Tests for Migration Rollback Functionality
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import {
+  MigrationRunner,
+  MigrationRegistry,
+  createMigrationRegistry,
+  createMigrationRunner,
+  defineMigration,
+} from './index'
+import type {
+  Migration,
+  QueryExecutor,
+  RollbackOptions,
+  RollbackProgressEvent,
+} from './types'
+
+// Mock query executor for testing
+class MockQueryExecutor implements QueryExecutor {
+  public queries: Array<{ sql: string; params?: unknown[] }> = []
+  public tables: Map<string, Map<string, unknown[]>> = new Map()
+  public migrationRecords: Map<string, { id: string; name: string; version: number; checksum: string; status: string; applied_at: string; execution_time_ms: number }> = new Map()
+  public rollbackHistory: unknown[] = []
+  public shouldFail = false
+  public failOnQuery: string | null = null
+
+  async query<T = unknown>(
+    sql: string,
+    params?: unknown[]
+  ): Promise<{ rows: T[]; fields: { name: string; dataTypeID: number }[]; affectedRows?: number }> {
+    this.queries.push({ sql, params })
+
+    // Check for intentional failure
+    if (this.shouldFail || (this.failOnQuery && sql.includes(this.failOnQuery))) {
+      throw new Error('Intentional query failure for testing')
+    }
+
+    // Handle CREATE TABLE (always succeeds)
+    if (sql.includes('CREATE TABLE IF NOT EXISTS')) {
+      return { rows: [] as T[], fields: [] }
+    }
+
+    // Handle CREATE INDEX (always succeeds)
+    if (sql.includes('CREATE INDEX IF NOT EXISTS')) {
+      return { rows: [] as T[], fields: [] }
+    }
+
+    // Handle BEGIN/COMMIT/ROLLBACK
+    if (sql === 'BEGIN' || sql === 'COMMIT' || sql === 'ROLLBACK') {
+      return { rows: [] as T[], fields: [] }
+    }
+
+    // Handle SELECT from migrations table (before rollback_history check)
+    if (sql.includes('SELECT') && sql.includes('_migrations"') && !sql.includes('rollback_history')) {
+      // If querying by ID (WHERE id = $1)
+      if (sql.includes('WHERE id =') && params?.[0]) {
+        const id = params[0] as string
+        const record = this.migrationRecords.get(id)
+        return { rows: record ? [record] as T[] : [] as T[], fields: [] }
+      }
+      // Otherwise return all records sorted by version
+      const rows = Array.from(this.migrationRecords.values())
+        .sort((a, b) => a.version - b.version)
+      return { rows: rows as T[], fields: [] }
+    }
+
+    // Handle SELECT from rollback history
+    if (sql.includes('SELECT') && sql.includes('rollback_history')) {
+      return { rows: this.rollbackHistory as T[], fields: [] }
+    }
+
+    // Handle INSERT into migrations table (ON CONFLICT DO UPDATE)
+    if (sql.includes('INSERT INTO') && sql.includes('_migrations"') && !sql.includes('rollback_history')) {
+      const id = params?.[0] as string
+      const name = params?.[1] as string
+      const version = params?.[2] as number
+      const checksum = params?.[3] as string
+      const executionTime = params?.[4] as number
+      const status = sql.includes("'applied'") ? 'applied' : sql.includes("'failed'") ? 'failed' : 'pending'
+
+      this.migrationRecords.set(id, {
+        id,
+        name,
+        version,
+        checksum,
+        status,
+        applied_at: new Date().toISOString(),
+        execution_time_ms: executionTime,
+      })
+      return { rows: [] as T[], fields: [], affectedRows: 1 }
+    }
+
+    // Handle INSERT into rollback history
+    if (sql.includes('INSERT INTO') && sql.includes('rollback_history')) {
+      this.rollbackHistory.push({
+        rollback_id: params?.[0],
+        migration_id: params?.[1],
+        version: params?.[2],
+        execution_time_ms: params?.[3],
+        previous_status: params?.[4],
+        reason: params?.[5],
+        rolled_back_at: new Date().toISOString(),
+      })
+      return { rows: [] as T[], fields: [], affectedRows: 1 }
+    }
+
+    // Handle UPDATE migrations table (for rollback)
+    if (sql.includes('UPDATE') && sql.includes('_migrations"') && sql.includes('rolled_back')) {
+      const id = params?.[0] as string
+      const record = this.migrationRecords.get(id)
+      if (record) {
+        record.status = 'rolled_back'
+        record.applied_at = new Date().toISOString()
+      }
+      return { rows: [] as T[], fields: [], affectedRows: 1 }
+    }
+
+    // Handle DROP TABLE
+    if (sql.includes('DROP TABLE IF EXISTS') && sql.includes('CASCADE')) {
+      this.migrationRecords.clear()
+      this.rollbackHistory = []
+      return { rows: [] as T[], fields: [] }
+    }
+
+    // Handle advisory lock queries
+    if (sql.includes('pg_try_advisory_lock')) {
+      return { rows: [{ pg_try_advisory_lock: true }] as T[], fields: [] }
+    }
+    if (sql.includes('pg_advisory_unlock')) {
+      return { rows: [{ pg_advisory_unlock: true }] as T[], fields: [] }
+    }
+
+    // Default: assume it's a migration SQL (CREATE TABLE, DROP TABLE, etc.)
+    return { rows: [] as T[], fields: [] }
+  }
+
+  // Helper to pre-populate migration records (as if they were already applied)
+  addMigrationRecord(migration: Migration) {
+    this.migrationRecords.set(migration.id, {
+      id: migration.id,
+      name: migration.name,
+      version: migration.version,
+      checksum: 'test-checksum',
+      status: 'applied',
+      applied_at: new Date().toISOString(),
+      execution_time_ms: 10,
+    })
+  }
+
+  // Reset state
+  reset() {
+    this.queries = []
+    this.migrationRecords.clear()
+    this.rollbackHistory = []
+    this.shouldFail = false
+    this.failOnQuery = null
+  }
+}
+
+describe('Migration Rollback', () => {
+  let executor: MockQueryExecutor
+  let migrations: Migration[]
+  let registry: MigrationRegistry
+  let runner: MigrationRunner
+
+  beforeEach(() => {
+    executor = new MockQueryExecutor()
+
+    migrations = [
+      defineMigration({
+        id: '0001_create_users',
+        name: 'Create users table',
+        version: 1,
+        up: 'CREATE TABLE users (id SERIAL PRIMARY KEY, email TEXT)',
+        down: 'DROP TABLE users',
+      }),
+      defineMigration({
+        id: '0002_add_posts',
+        name: 'Add posts table',
+        version: 2,
+        up: 'CREATE TABLE posts (id SERIAL PRIMARY KEY, title TEXT)',
+        down: 'DROP TABLE posts',
+      }),
+      defineMigration({
+        id: '0003_add_comments',
+        name: 'Add comments table',
+        version: 3,
+        up: 'CREATE TABLE comments (id SERIAL PRIMARY KEY, content TEXT)',
+        down: 'DROP TABLE comments',
+      }),
+    ]
+
+    registry = createMigrationRegistry({ migrations })
+    runner = createMigrationRunner(executor, registry, { useLocking: false, debug: false })
+  })
+
+  describe('rollbackLast', () => {
+    it('should return null when no migrations are applied', async () => {
+      const result = await runner.rollbackLast()
+      expect(result).toBeNull()
+    })
+
+    it('should rollback the last applied migration', async () => {
+      // Apply migrations first
+      const migrateResult = await runner.migrate()
+
+      // All migrations should be applied now
+
+      // Check that all migrations were applied
+      expect(migrateResult.success).toBe(true)
+      expect(migrateResult.migrationsRun).toBe(3)
+
+      // Check current version
+      const versionBefore = await runner.getSchemaVersion()
+      expect(versionBefore.currentVersion).toBe(3)
+
+      // Rollback the last one
+      const result = await runner.rollbackLast()
+
+      expect(result).not.toBeNull()
+      expect(result?.success).toBe(true)
+      expect(result?.id).toBe('0003_add_comments')
+      expect(result?.version).toBe(3)
+    })
+
+    it('should support dry-run mode', async () => {
+      await runner.migrate()
+
+      const result = await runner.rollbackLast({ dryRun: true })
+
+      expect(result).not.toBeNull()
+      expect(result?.success).toBe(true)
+      expect(result?.isDryRun).toBe(true)
+      expect(result?.id).toBe('0003_add_comments')
+
+      // Verify no actual changes were made
+      const version = await runner.getSchemaVersion()
+      expect(version.currentVersion).toBe(3)
+    })
+
+    it('should throw error for migration without down SQL', async () => {
+      const noDownMigrations = [
+        defineMigration({
+          id: '0001_no_down',
+          name: 'No down migration',
+          version: 1,
+          up: 'CREATE TABLE test (id INT)',
+          // No down SQL
+        }),
+      ]
+
+      const noDownRegistry = createMigrationRegistry({ migrations: noDownMigrations })
+      const noDownRunner = createMigrationRunner(executor, noDownRegistry, { useLocking: false })
+
+      await noDownRunner.migrate()
+
+      await expect(noDownRunner.rollbackLast()).rejects.toThrow('no rollback SQL defined')
+    })
+
+    it('should throw error for non-reversible migration unless forced', async () => {
+      const nonReversibleMigrations = [
+        defineMigration({
+          id: '0001_non_reversible',
+          name: 'Non-reversible migration',
+          version: 1,
+          up: 'CREATE TABLE test (id INT)',
+          down: 'DROP TABLE test',
+          isReversible: false,
+        }),
+      ]
+
+      const nonReversibleRegistry = createMigrationRegistry({ migrations: nonReversibleMigrations })
+      const nonReversibleRunner = createMigrationRunner(executor, nonReversibleRegistry, { useLocking: false })
+
+      await nonReversibleRunner.migrate()
+
+      await expect(nonReversibleRunner.rollbackLast()).rejects.toThrow('non-reversible')
+
+      // Should work with force flag
+      const result = await nonReversibleRunner.rollbackLast({ force: true })
+      expect(result?.success).toBe(true)
+    })
+  })
+
+  describe('rollback', () => {
+    it('should rollback to a specific version', async () => {
+      await runner.migrate()
+
+      const result = await runner.rollback({ toVersion: 1 })
+
+      expect(result.success).toBe(true)
+      expect(result.fromVersion).toBe(3)
+      expect(result.toVersion).toBe(1)
+      expect(result.rolledBackCount).toBe(2)
+    })
+
+    it('should do nothing if already at or below target version', async () => {
+      await runner.migrate()
+
+      // Rollback to current version (should do nothing)
+      const result = await runner.rollback({ toVersion: 3 })
+
+      expect(result.success).toBe(true)
+      expect(result.rolledBackCount).toBe(0)
+    })
+
+    it('should support dry-run mode', async () => {
+      await runner.migrate()
+
+      const result = await runner.rollback({ toVersion: 1, dryRun: true })
+
+      expect(result.success).toBe(true)
+      expect(result.isDryRun).toBe(true)
+      expect(result.rolledBackCount).toBe(2)
+      expect(result.results.every((r) => r.isDryRun)).toBe(true)
+
+      // Verify no actual changes
+      const version = await runner.getSchemaVersion()
+      expect(version.currentVersion).toBe(3)
+    })
+
+    it('should report blockers for non-reversible migrations', async () => {
+      const mixedMigrations = [
+        defineMigration({
+          id: '0001_reversible',
+          name: 'Reversible',
+          version: 1,
+          up: 'CREATE TABLE t1 (id INT)',
+          down: 'DROP TABLE t1',
+        }),
+        defineMigration({
+          id: '0002_non_reversible',
+          name: 'Non-reversible',
+          version: 2,
+          up: 'CREATE TABLE t2 (id INT)',
+          down: 'DROP TABLE t2',
+          isReversible: false,
+        }),
+        defineMigration({
+          id: '0003_reversible',
+          name: 'Another reversible',
+          version: 3,
+          up: 'CREATE TABLE t3 (id INT)',
+          down: 'DROP TABLE t3',
+        }),
+      ]
+
+      const mixedRegistry = createMigrationRegistry({ migrations: mixedMigrations })
+      const mixedRunner = createMigrationRunner(executor, mixedRegistry, { useLocking: false })
+
+      await mixedRunner.migrate()
+
+      // Try to rollback to version 0 (all migrations)
+      const result = await mixedRunner.rollback({ toVersion: 0 })
+
+      expect(result.success).toBe(false)
+      expect(result.blockedBy).toBeDefined()
+      expect(result.blockedBy?.length).toBe(1)
+      expect(result.blockedBy?.[0].id).toBe('0002_non_reversible')
+      expect(result.blockedBy?.[0].reason).toContain('non-reversible')
+    })
+
+    it('should force rollback non-reversible migrations when forced', async () => {
+      const mixedMigrations = [
+        defineMigration({
+          id: '0001_reversible',
+          name: 'Reversible',
+          version: 1,
+          up: 'CREATE TABLE t1 (id INT)',
+          down: 'DROP TABLE t1',
+        }),
+        defineMigration({
+          id: '0002_non_reversible',
+          name: 'Non-reversible',
+          version: 2,
+          up: 'CREATE TABLE t2 (id INT)',
+          down: 'DROP TABLE t2',
+          isReversible: false,
+        }),
+      ]
+
+      const mixedRegistry = createMigrationRegistry({ migrations: mixedMigrations })
+      const mixedRunner = createMigrationRunner(executor, mixedRegistry, { useLocking: false })
+
+      await mixedRunner.migrate()
+
+      const result = await mixedRunner.rollback({ toVersion: 0, force: true })
+
+      expect(result.success).toBe(true)
+      expect(result.rolledBackCount).toBe(2)
+    })
+
+    it('should call progress callback', async () => {
+      await runner.migrate()
+
+      const progressEvents: RollbackProgressEvent[] = []
+
+      await runner.rollback({
+        toVersion: 1,
+        onProgress: (event) => progressEvents.push(event),
+      })
+
+      expect(progressEvents.length).toBeGreaterThan(0)
+      expect(progressEvents.some((e) => e.phase === 'starting')).toBe(true)
+      expect(progressEvents.some((e) => e.phase === 'completed')).toBe(true)
+    })
+
+    it('should stop on rollback failure', async () => {
+      await runner.migrate()
+
+      // Make the second rollback fail by setting flag
+      let rollbackCount = 0
+      const originalQuery = executor.query.bind(executor)
+      executor.query = async (sql: string, params?: unknown[]) => {
+        if (sql.includes('DROP TABLE') && !sql.includes('CASCADE')) {
+          rollbackCount++
+          if (rollbackCount === 2) {
+            throw new Error('Intentional failure')
+          }
+        }
+        return originalQuery(sql, params)
+      }
+
+      const result = await runner.rollback({ toVersion: 0 })
+
+      expect(result.success).toBe(false)
+      expect(result.results.some((r) => !r.success)).toBe(true)
+    })
+  })
+
+  describe('rollbackToVersion (legacy API)', () => {
+    it('should work with the legacy API', async () => {
+      await runner.migrate()
+
+      const result = await runner.rollbackToVersion(1)
+
+      expect(result.success).toBe(true)
+      expect(result.migrationsRun).toBe(2) // Actually rolled back
+    })
+  })
+
+  describe('planRollback', () => {
+    it('should return migrations to be rolled back', async () => {
+      await runner.migrate()
+
+      const plan = await runner.planRollback({ toVersion: 1 })
+
+      expect(plan.migrations.length).toBe(2)
+      expect(plan.migrations[0].id).toBe('0003_add_comments')
+      expect(plan.migrations[1].id).toBe('0002_add_posts')
+    })
+
+    it('should identify blockers', async () => {
+      const mixedMigrations = [
+        defineMigration({
+          id: '0001_ok',
+          name: 'OK',
+          version: 1,
+          up: 'CREATE TABLE t1 (id INT)',
+          down: 'DROP TABLE t1',
+        }),
+        defineMigration({
+          id: '0002_no_down',
+          name: 'No down',
+          version: 2,
+          up: 'CREATE TABLE t2 (id INT)',
+          // No down SQL
+        }),
+      ]
+
+      const mixedRegistry = createMigrationRegistry({ migrations: mixedMigrations })
+      const mixedRunner = createMigrationRunner(executor, mixedRegistry, { useLocking: false })
+
+      await mixedRunner.migrate()
+
+      const plan = await mixedRunner.planRollback({ toVersion: 0 })
+
+      expect(plan.blockers.length).toBe(1)
+      expect(plan.blockers[0].id).toBe('0002_no_down')
+      expect(plan.blockers[0].reason).toContain('No down SQL')
+    })
+  })
+
+  describe('isReversible', () => {
+    it('should return true for migrations with down SQL', () => {
+      const migration = defineMigration({
+        id: '0001_test',
+        name: 'Test',
+        version: 1,
+        up: 'CREATE TABLE t (id INT)',
+        down: 'DROP TABLE t',
+      })
+
+      expect(runner.isReversible(migration)).toBe(true)
+    })
+
+    it('should return false for migrations without down SQL', () => {
+      const migration = defineMigration({
+        id: '0001_test',
+        name: 'Test',
+        version: 1,
+        up: 'CREATE TABLE t (id INT)',
+      })
+
+      expect(runner.isReversible(migration)).toBe(false)
+    })
+
+    it('should return false for migrations marked as non-reversible', () => {
+      const migration = defineMigration({
+        id: '0001_test',
+        name: 'Test',
+        version: 1,
+        up: 'CREATE TABLE t (id INT)',
+        down: 'DROP TABLE t',
+        isReversible: false,
+      })
+
+      expect(runner.isReversible(migration)).toBe(false)
+    })
+  })
+
+  describe('getRollbackHistory', () => {
+    it('should return rollback history', async () => {
+      await runner.migrate()
+      await runner.rollbackLast()
+
+      const history = await runner.getRollbackHistory()
+
+      expect(history.length).toBe(1)
+      expect(history[0].migration_id).toBe('0003_add_comments')
+      expect(history[0].version).toBe(3)
+    })
+  })
+
+  describe('event handling', () => {
+    it('should emit rollback events', async () => {
+      const events: Array<{ type: string }> = []
+
+      runner.onRollbackEvent((event) => {
+        events.push({ type: event.type })
+      })
+
+      await runner.migrate()
+      await runner.rollbackLast()
+
+      expect(events.some((e) => e.type === 'rollback_started')).toBe(true)
+      expect(events.some((e) => e.type === 'rollback_completed')).toBe(true)
+    })
+
+    it('should emit batch rollback events', async () => {
+      const events: Array<{ type: string }> = []
+
+      runner.onRollbackEvent((event) => {
+        events.push({ type: event.type })
+      })
+
+      await runner.migrate()
+      await runner.rollback({ toVersion: 1 })
+
+      expect(events.some((e) => e.type === 'batch_rollback_started')).toBe(true)
+      expect(events.some((e) => e.type === 'batch_rollback_completed')).toBe(true)
+    })
+  })
+})
+
+describe('AutoMigrator Rollback', () => {
+  let executor: MockQueryExecutor
+  let migrations: Migration[]
+
+  beforeEach(() => {
+    executor = new MockQueryExecutor()
+
+    migrations = [
+      defineMigration({
+        id: '0001_create_users',
+        name: 'Create users table',
+        version: 1,
+        up: 'CREATE TABLE users (id SERIAL PRIMARY KEY)',
+        down: 'DROP TABLE users',
+      }),
+      defineMigration({
+        id: '0002_add_posts',
+        name: 'Add posts table',
+        version: 2,
+        up: 'CREATE TABLE posts (id SERIAL PRIMARY KEY)',
+        down: 'DROP TABLE posts',
+      }),
+      defineMigration({
+        id: '0003_non_reversible',
+        name: 'Non-reversible migration',
+        version: 3,
+        up: 'ALTER TABLE users ADD COLUMN data JSONB',
+        down: 'ALTER TABLE users DROP COLUMN data',
+        isReversible: false,
+      }),
+    ]
+  })
+
+  it('should check if migration is reversible', async () => {
+    const { AutoMigrator } = await import('./auto-migrator')
+    const migrator = new AutoMigrator({ migrations, useLocking: false })
+
+    expect(migrator.isMigrationReversible('0001_create_users')).toBe(true)
+    expect(migrator.isMigrationReversible('0002_add_posts')).toBe(true)
+    expect(migrator.isMigrationReversible('0003_non_reversible')).toBe(false)
+    expect(migrator.isMigrationReversible('unknown')).toBe(false)
+  })
+
+  it('should get non-reversible migrations', async () => {
+    const { AutoMigrator } = await import('./auto-migrator')
+    const migrator = new AutoMigrator({ migrations, useLocking: false })
+
+    const nonReversible = migrator.getNonReversibleMigrations()
+
+    expect(nonReversible.length).toBe(1)
+    expect(nonReversible[0].id).toBe('0003_non_reversible')
+  })
+
+  it('should rollback via AutoMigrator', async () => {
+    const { AutoMigrator } = await import('./auto-migrator')
+    const migrator = new AutoMigrator({ migrations, useLocking: false })
+
+    await migrator.ensureMigrated(executor)
+
+    const result = await migrator.rollback(executor, { toVersion: 1, force: true })
+
+    expect(result.success).toBe(true)
+    expect(result.rolledBackCount).toBe(2)
+  })
+
+  it('should plan rollback via AutoMigrator', async () => {
+    const { AutoMigrator } = await import('./auto-migrator')
+    const migrator = new AutoMigrator({ migrations, useLocking: false })
+
+    await migrator.ensureMigrated(executor)
+
+    const plan = await migrator.planRollback(executor, { toVersion: 0 })
+
+    expect(plan.migrations.length).toBe(2) // Only reversible ones
+    expect(plan.blockers.length).toBe(1) // The non-reversible one
+  })
+})