@dotdo/postgres 0.1.0

package/src/migration-tooling/external-migration.test.ts

@@ -0,0 +1,1864 @@
+/**
+ * Tests for External Database Migration Tooling (RED phase)
+ *
+ * These tests define the expected behavior for migrating from
+ * external databases (Neon, Supabase) to PGLite.
+ *
+ * Tests cover:
+ * 1. Schema export from external databases
+ * 2. Schema transformation to PGLite-compatible format
+ * 3. Data migration streaming
+ * 4. Connection string parsing
+ * 5. Progress reporting
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+
+// These imports will fail until implementation exists
+import {
+  // Schema export
+  SchemaExporter,
+  exportSchema,
+  type SchemaExportOptions,
+  type ExportedSchema,
+
+  // Schema transformation
+  SchemaTransformer,
+  transformSchema,
+  createPGLiteCompatibility,
+  type TransformOptions,
+  type TransformResult,
+  type PGLiteCompatibility,
+
+  // Schema validation
+  validateSchemaCompatibility,
+  type SchemaValidationResult,
+  type SchemaValidationOptions,
+  type SchemaValidationIssue,
+
+  // Data migration
+  DataMigrator,
+  createDataStream,
+  type DataMigrationOptions,
+  type MigrationStream,
+  type BatchConfig,
+
+  // Streaming metrics
+  createStreamingMetricsTracker,
+  type StreamingMetrics,
+  type ThroughputMetrics,
+
+  // Connection string parsing
+  parseConnectionString,
+  buildConnectionString,
+  detectProvider,
+  type ConnectionConfig,
+  type DatabaseProvider,
+
+  // Progress reporting
+  MigrationProgressReporter,
+  createProgressReporter,
+  type ProgressEvent,
+  type ProgressCallback,
+  type MigrationPhase,
+
+  // Error handling
+  MigrationError,
+  type MigrationErrorCode,
+} from './external-migration'
+
+// =============================================================================
+// 1. SCHEMA EXPORT TESTS
+// =============================================================================
+
+describe('SchemaExporter', () => {
+  describe('exportSchema', () => {
+    it('should export all tables from a database', async () => {
+      const options: SchemaExportOptions = {
+        connectionString: 'postgresql://user:pass@host:5432/db',
+        includeData: false,
+      }
+
+      const result = await exportSchema(options)
+
+      expect(result).toBeDefined()
+      expect(result.tables).toBeDefined()
+      expect(Array.isArray(result.tables)).toBe(true)
+    })
+
+    it('should export table with columns and constraints', async () => {
+      const options: SchemaExportOptions = {
+        connectionString: 'postgresql://user:pass@host:5432/db',
+        tables: ['users'],
+      }
+
+      const result = await exportSchema(options)
+
+      expect(result.tables).toHaveLength(1)
+      const usersTable = result.tables[0]
+      expect(usersTable.name).toBe('users')
+      expect(usersTable.columns).toBeDefined()
+      expect(usersTable.primaryKey).toBeDefined()
+      expect(usersTable.foreignKeys).toBeDefined()
+      expect(usersTable.indexes).toBeDefined()
+    })
+
+    it('should export views', async () => {
+      const options: SchemaExportOptions = {
+        connectionString: 'postgresql://user:pass@host:5432/db',
+        includeViews: true,
+      }
+
+      const result = await exportSchema(options)
+
+      expect(result.views).toBeDefined()
+      expect(Array.isArray(result.views)).toBe(true)
+    })
+
+    it('should export functions and triggers', async () => {
+      const options: SchemaExportOptions = {
+        connectionString: 'postgresql://user:pass@host:5432/db',
+        includeFunctions: true,
+        includeTriggers: true,
+      }
+
+      const result = await exportSchema(options)
+
+      expect(result.functions).toBeDefined()
+      expect(result.triggers).toBeDefined()
+    })
+
+    it('should export extensions list', async () => {
+      const options: SchemaExportOptions = {
+        connectionString: 'postgresql://user:pass@host:5432/db',
+        includeExtensions: true,
+      }
+
+      const result = await exportSchema(options)
+
+      expect(result.extensions).toBeDefined()
+      expect(Array.isArray(result.extensions)).toBe(true)
+    })
+
+    it('should filter tables by schema', async () => {
+      const options: SchemaExportOptions = {
+        connectionString: 'postgresql://user:pass@host:5432/db',
+        schemas: ['public', 'auth'],
+      }
+
+      const result = await exportSchema(options)
+
+      result.tables.forEach((table) => {
+        expect(['public', 'auth']).toContain(table.schema)
+      })
+    })
+
+    it('should exclude specified tables', async () => {
+      const options: SchemaExportOptions = {
+        connectionString: 'postgresql://user:pass@host:5432/db',
+        excludeTables: ['_migrations', 'schema_migrations'],
+      }
+
+      const result = await exportSchema(options)
+
+      const tableNames = result.tables.map((t) => t.name)
+      expect(tableNames).not.toContain('_migrations')
+      expect(tableNames).not.toContain('schema_migrations')
+    })
+
+    it('should handle connection errors gracefully', async () => {
+      const options: SchemaExportOptions = {
+        connectionString: 'postgresql://invalid:invalid@nonexistent:5432/db',
+      }
+
+      await expect(exportSchema(options)).rejects.toThrow(/connection|connect|ENOTFOUND/i)
+    })
+
+    it('should timeout on slow connections', async () => {
+      const options: SchemaExportOptions = {
+        connectionString: 'postgresql://user:pass@slow-host:5432/db',
+        timeout: 100, // 100ms timeout
+      }
+
+      await expect(exportSchema(options)).rejects.toThrow(/timeout/i)
+    })
+  })
+
+  describe('SchemaExporter class', () => {
+    let exporter: SchemaExporter
+
+    beforeEach(() => {
+      exporter = new SchemaExporter({
+        connectionString: 'postgresql://user:pass@host:5432/db',
+      })
+    })
+
+    it('should be instantiable with connection config', () => {
+      expect(exporter).toBeInstanceOf(SchemaExporter)
+    })
+
+    it('should connect and disconnect', async () => {
+      await expect(exporter.connect()).resolves.not.toThrow()
+      await expect(exporter.disconnect()).resolves.not.toThrow()
+    })
+
+    it('should list available schemas', async () => {
+      await exporter.connect()
+      const schemas = await exporter.listSchemas()
+
+      expect(Array.isArray(schemas)).toBe(true)
+      expect(schemas).toContain('public')
+      await exporter.disconnect()
+    })
+
+    it('should list tables in a schema', async () => {
+      await exporter.connect()
+      const tables = await exporter.listTables('public')
+
+      expect(Array.isArray(tables)).toBe(true)
+      await exporter.disconnect()
+    })
+
+    it('should get table details', async () => {
+      await exporter.connect()
+      const table = await exporter.getTableDetails('public', 'users')
+
+      expect(table.name).toBe('users')
+      expect(table.columns).toBeDefined()
+      expect(table.constraints).toBeDefined()
+      await exporter.disconnect()
+    })
+
+    it('should export to SQL DDL format', async () => {
+      await exporter.connect()
+      const ddl = await exporter.exportToSQL()
+
+      expect(typeof ddl).toBe('string')
+      expect(ddl).toContain('CREATE TABLE')
+      await exporter.disconnect()
+    })
+  })
+})
+
+// =============================================================================
+// 2. SCHEMA TRANSFORMATION TESTS
+// =============================================================================
+
+describe('SchemaTransformer', () => {
+  describe('transformSchema', () => {
+    it('should transform schema to PGLite-compatible format', async () => {
+      const schema: ExportedSchema = {
+        tables: [
+          {
+            name: 'users',
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'email', type: 'varchar(255)', nullable: false },
+            ],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [],
+            indexes: [],
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+      }
+
+      const result = await transformSchema(schema)
+
+      expect(result.schema).toBeDefined()
+      expect(result.sql).toBeDefined()
+      expect(result.warnings).toBeDefined()
+    })
+
+    it('should convert unsupported types to compatible alternatives', async () => {
+      const schema: ExportedSchema = {
+        tables: [
+          {
+            name: 'data',
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'location', type: 'geography(point)', nullable: true }, // PostGIS
+              { name: 'metadata', type: 'jsonb', nullable: true },
+            ],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [],
+            indexes: [],
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: ['postgis'],
+      }
+
+      const result = await transformSchema(schema)
+
+      // geography should be converted to text or similar
+      const dataTable = result.schema.tables.find((t) => t.name === 'data')
+      const locationCol = dataTable?.columns.find((c) => c.name === 'location')
+      expect(locationCol?.type).not.toBe('geography(point)')
+      expect(result.warnings.length).toBeGreaterThan(0)
+    })
+
+    it('should handle partitioned tables', async () => {
+      const schema: ExportedSchema = {
+        tables: [
+          {
+            name: 'events',
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'created_at', type: 'timestamp', nullable: false },
+            ],
+            primaryKey: { columns: ['id', 'created_at'] },
+            foreignKeys: [],
+            indexes: [],
+            partitioning: {
+              type: 'RANGE',
+              columns: ['created_at'],
+            },
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+      }
+
+      const result = await transformSchema(schema)
+
+      // PGLite doesn't support partitioning - should convert to regular table
+      expect(result.schema.tables[0].partitioning).toBeUndefined()
+      expect(result.warnings).toContainEqual(
+        expect.objectContaining({
+          type: 'unsupported_feature',
+          feature: 'partitioning',
+        })
+      )
+    })
+
+    it('should warn about unsupported extensions', async () => {
+      const schema: ExportedSchema = {
+        tables: [],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: ['postgis', 'pg_trgm', 'uuid-ossp'],
+      }
+
+      const result = await transformSchema(schema)
+
+      expect(result.warnings.some((w) => w.type === 'unsupported_extension')).toBe(true)
+      expect(result.unsupportedExtensions).toBeDefined()
+    })
+
+    it('should transform views to materialized table definitions', async () => {
+      const schema: ExportedSchema = {
+        tables: [],
+        views: [
+          {
+            name: 'active_users',
+            schema: 'public',
+            definition: 'SELECT * FROM users WHERE active = true',
+          },
+        ],
+        functions: [],
+        triggers: [],
+        extensions: [],
+      }
+
+      const options: TransformOptions = {
+        viewStrategy: 'materialize',
+      }
+
+      const result = await transformSchema(schema, options)
+
+      // View should be converted to a table
+      expect(result.schema.tables.some((t) => t.name === 'active_users')).toBe(true)
+      expect(result.warnings.some((w) => w.type === 'view_materialized')).toBe(true)
+    })
+
+    it('should preserve views when strategy is preserve', async () => {
+      const schema: ExportedSchema = {
+        tables: [],
+        views: [
+          {
+            name: 'active_users',
+            schema: 'public',
+            definition: 'SELECT * FROM users WHERE active = true',
+          },
+        ],
+        functions: [],
+        triggers: [],
+        extensions: [],
+      }
+
+      const options: TransformOptions = {
+        viewStrategy: 'preserve',
+      }
+
+      const result = await transformSchema(schema, options)
+
+      expect(result.schema.views).toHaveLength(1)
+    })
+
+    it('should handle circular foreign key dependencies', async () => {
+      const schema: ExportedSchema = {
+        tables: [
+          {
+            name: 'orders',
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'customer_id', type: 'integer', nullable: false },
+            ],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [
+              { columns: ['customer_id'], references: { table: 'customers', columns: ['id'] } },
+            ],
+            indexes: [],
+          },
+          {
+            name: 'customers',
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'latest_order_id', type: 'integer', nullable: true },
+            ],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [
+              { columns: ['latest_order_id'], references: { table: 'orders', columns: ['id'] } },
+            ],
+            indexes: [],
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+      }
+
+      const result = await transformSchema(schema)
+
+      // Should detect and handle circular dependency
+      expect(result.dependencyOrder).toBeDefined()
+      expect(result.warnings.some((w) => w.type === 'circular_dependency')).toBe(true)
+    })
+
+    it('should generate valid SQL output', async () => {
+      const schema: ExportedSchema = {
+        tables: [
+          {
+            name: 'users',
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'email', type: 'varchar(255)', nullable: false, unique: true },
+              { name: 'created_at', type: 'timestamp', nullable: false, default: 'now()' },
+            ],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [],
+            indexes: [{ name: 'idx_users_email', columns: ['email'], unique: true }],
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+      }
+
+      const result = await transformSchema(schema)
+
+      expect(result.sql).toContain('CREATE TABLE')
+      expect(result.sql).toContain('users')
+      expect(result.sql).toContain('PRIMARY KEY')
+      expect(result.sql).toMatch(/CREATE\s+(UNIQUE\s+)?INDEX/)
+    })
+  })
+
+  describe('PGLiteCompatibility', () => {
+    it('should check type compatibility', () => {
+      // This test defines the expected interface for PGLiteCompatibility
+      // The implementation should provide these methods
+      const supportedTypes = ['integer', 'varchar', 'text', 'jsonb', 'boolean', 'timestamp']
+      const unsupportedTypes = ['geography', 'geometry', 'ltree', 'cube']
+      const typeAlternatives: Record<string, string> = {
+        geography: 'text',
+        geometry: 'text',
+        ltree: 'text',
+        cube: 'text[]',
+      }
+
+      // Use the real implementation (already imported at top of file)
+      const compat: PGLiteCompatibility = createPGLiteCompatibility()
+
+      // These should be supported
+      expect(compat.isTypeSupported('integer')).toBe(true)
+      expect(compat.isTypeSupported('varchar(255)')).toBe(true)
+      expect(compat.isTypeSupported('jsonb')).toBe(true)
+
+      // These may not be fully supported
+      expect(compat.isTypeSupported('geography')).toBe(false)
+      expect(compat.getAlternativeType('geography')).toBe('text')
+    })
+  })
+})
+
+// =============================================================================
+// 3. DATA MIGRATION STREAMING TESTS
+// =============================================================================
+
+describe('DataMigrator', () => {
+  describe('createDataStream', () => {
+    it('should create a readable stream for table data', async () => {
+      const options: DataMigrationOptions = {
+        sourceConnection: 'postgresql://user:pass@source:5432/db',
+        table: 'users',
+        batchSize: 1000,
+      }
+
+      const stream = await createDataStream(options)
+
+      expect(stream).toBeDefined()
+      expect(typeof stream[Symbol.asyncIterator]).toBe('function')
+    })
+
+    it('should stream data in batches', async () => {
+      const options: DataMigrationOptions = {
+        sourceConnection: 'postgresql://user:pass@source:5432/db',
+        table: 'users',
+        batchSize: 100,
+      }
+
+      const stream = await createDataStream(options)
+      const batches: unknown[][] = []
+
+      for await (const batch of stream) {
+        batches.push(batch)
+        expect(batch.length).toBeLessThanOrEqual(100)
+      }
+
+      expect(batches.length).toBeGreaterThan(0)
+    })
+
+    it('should support cursor-based pagination', async () => {
+      const options: DataMigrationOptions = {
+        sourceConnection: 'postgresql://user:pass@source:5432/db',
+        table: 'users',
+        batchSize: 100,
+        cursorColumn: 'id',
+      }
+
+      const stream = await createDataStream(options)
+      let lastId = 0
+
+      for await (const batch of stream) {
+        const ids = batch.map((row: any) => row.id)
+        expect(Math.min(...ids)).toBeGreaterThan(lastId)
+        lastId = Math.max(...ids)
+      }
+    })
+
+    it('should support WHERE clause filtering', async () => {
+      const options: DataMigrationOptions = {
+        sourceConnection: 'postgresql://user:pass@source:5432/db',
+        table: 'users',
+        where: 'active = true AND created_at > $1',
+        whereParams: ['2024-01-01'],
+      }
+
+      const stream = await createDataStream(options)
+
+      for await (const batch of stream) {
+        for (const row of batch) {
+          expect(row.active).toBe(true)
+        }
+      }
+    })
+
+    it('should handle large blob/bytea columns', async () => {
+      const options: DataMigrationOptions = {
+        sourceConnection: 'postgresql://user:pass@source:5432/db',
+        table: 'files',
+        batchSize: 10, // Smaller batches for large data
+      }
+
+      const stream = await createDataStream(options)
+
+      for await (const batch of stream) {
+        for (const row of batch) {
+          if (row.content) {
+            expect(row.content).toBeInstanceOf(Buffer)
+          }
+        }
+      }
+    })
+
+    it('should resume from a checkpoint', async () => {
+      const options: DataMigrationOptions = {
+        sourceConnection: 'postgresql://user:pass@source:5432/db',
+        table: 'users',
+        batchSize: 100,
+        cursorColumn: 'id',
+        resumeFrom: { id: 500 }, // Resume from row 500
+      }
+
+      const stream = await createDataStream(options)
+      const firstBatch = await stream[Symbol.asyncIterator]().next()
+
+      if (!firstBatch.done) {
+        const ids = firstBatch.value.map((row: any) => row.id)
+        expect(Math.min(...ids)).toBeGreaterThan(500)
+      }
+    })
+  })
+
+  describe('DataMigrator class', () => {
+    let migrator: DataMigrator
+
+    beforeEach(() => {
+      migrator = new DataMigrator({
+        sourceConnection: 'postgresql://user:pass@source:5432/sourcedb',
+        targetConnection: 'pglite://local',
+      })
+    })
+
+    it('should migrate a single table', async () => {
+      const result = await migrator.migrateTable('users')
+
+      expect(result.table).toBe('users')
+      expect(result.rowsProcessed).toBeGreaterThan(0)
+      expect(result.success).toBe(true)
+    })
+
+    it('should migrate multiple tables in dependency order', async () => {
+      const result = await migrator.migrateTables(['orders', 'customers', 'products'])
+
+      expect(result.tablesProcessed).toHaveLength(3)
+      // customers should be migrated before orders due to FK
+      const customerIdx = result.tablesProcessed.findIndex((t) => t.table === 'customers')
+      const orderIdx = result.tablesProcessed.findIndex((t) => t.table === 'orders')
+      expect(customerIdx).toBeLessThan(orderIdx)
+    })
+
+    it('should support data transformation during migration', async () => {
+      const result = await migrator.migrateTable('users', {
+        transform: (row) => ({
+          ...row,
+          email: row.email.toLowerCase(),
+          migrated_at: new Date().toISOString(),
+        }),
+      })
+
+      expect(result.success).toBe(true)
+    })
+
+    it('should handle migration errors with rollback', async () => {
+      const result = await migrator.migrateTable('invalid_table')
+
+      expect(result.success).toBe(false)
+      expect(result.error).toBeDefined()
+      expect(result.rolledBack).toBe(true)
+    })
+
+    it('should support parallel table migrations', async () => {
+      const result = await migrator.migrateTables(['table_a', 'table_b', 'table_c'], {
+        parallel: true,
+        maxConcurrency: 2,
+      })
+
+      expect(result.tablesProcessed).toHaveLength(3)
+      expect(result.parallelExecution).toBe(true)
+    })
+
+    it('should validate data integrity after migration', async () => {
+      const result = await migrator.migrateTable('users', {
+        validateIntegrity: true,
+      })
+
+      expect(result.integrityChecks).toBeDefined()
+      expect(result.integrityChecks.rowCount).toBeDefined()
+      expect(result.integrityChecks.checksumValid).toBe(true)
+    })
+
+    it('should handle schema changes during migration', async () => {
+      // Simulate a schema where source has more columns than target
+      const result = await migrator.migrateTable('users', {
+        schemaMapping: {
+          ignoreColumns: ['internal_id', 'deleted_at'],
+          columnRenames: { user_name: 'username' },
+        },
+      })
+
+      expect(result.success).toBe(true)
+      expect(result.schemaWarnings).toBeDefined()
+    })
+  })
+
+  describe('BatchConfig', () => {
+    it('should configure optimal batch size based on table size', async () => {
+      const migrator = new DataMigrator({
+        sourceConnection: 'postgresql://user:pass@source:5432/db',
+        targetConnection: 'pglite://local',
+      })
+
+      const config = await migrator.calculateOptimalBatchConfig('large_table')
+
+      expect(config.batchSize).toBeDefined()
+      expect(config.batchSize).toBeGreaterThan(0)
+      expect(config.estimatedBatches).toBeDefined()
+    })
+  })
+})
+
+// =============================================================================
+// 4. CONNECTION STRING PARSING TESTS
+// =============================================================================
+
+describe('Connection String Parsing', () => {
+  describe('parseConnectionString', () => {
+    it('should parse standard PostgreSQL connection string', () => {
+      const connString = 'postgresql://user:password@localhost:5432/mydb'
+      const config = parseConnectionString(connString)
+
+      expect(config.host).toBe('localhost')
+      expect(config.port).toBe(5432)
+      expect(config.user).toBe('user')
+      expect(config.password).toBe('password')
+      expect(config.database).toBe('mydb')
+    })
+
+    it('should parse postgres:// protocol', () => {
+      const connString = 'postgres://user:pass@host:5432/db'
+      const config = parseConnectionString(connString)
+
+      expect(config.host).toBe('host')
+      expect(config.protocol).toBe('postgres')
+    })
+
+    it('should parse connection string with SSL parameters', () => {
+      const connString = 'postgresql://user:pass@host:5432/db?sslmode=require&sslrootcert=/path/to/cert'
+      const config = parseConnectionString(connString)
+
+      expect(config.ssl).toBeDefined()
+      expect(config.ssl?.mode).toBe('require')
+      expect(config.ssl?.rootCert).toBe('/path/to/cert')
+    })
+
+    it('should handle URL-encoded passwords', () => {
+      const connString = 'postgresql://user:p%40ss%2Fword@host:5432/db'
+      const config = parseConnectionString(connString)
+
+      expect(config.password).toBe('p@ss/word')
+    })
+
+    it('should parse Neon connection string format', () => {
+      const connString =
+        'postgresql://user:pass@ep-cool-name-123456.us-east-2.aws.neon.tech/neondb?sslmode=require'
+      const config = parseConnectionString(connString)
+
+      expect(config.host).toBe('ep-cool-name-123456.us-east-2.aws.neon.tech')
+      expect(config.provider).toBe('neon')
+      expect(config.ssl?.mode).toBe('require')
+    })
+
+    it('should parse Supabase connection string format', () => {
+      const connString =
+        'postgresql://postgres:password@db.projectref.supabase.co:5432/postgres'
+      const config = parseConnectionString(connString)
+
+      expect(config.host).toBe('db.projectref.supabase.co')
+      expect(config.provider).toBe('supabase')
+    })
+
+    it('should parse connection string with schema option', () => {
+      const connString = 'postgresql://user:pass@host:5432/db?schema=custom_schema'
+      const config = parseConnectionString(connString)
+
+      expect(config.schema).toBe('custom_schema')
+    })
+
+    it('should handle connection string with options', () => {
+      const connString =
+        'postgresql://user:pass@host:5432/db?connect_timeout=10&application_name=migrator'
+      const config = parseConnectionString(connString)
+
+      expect(config.options?.connect_timeout).toBe('10')
+      expect(config.options?.application_name).toBe('migrator')
+    })
+
+    it('should throw on invalid connection string', () => {
+      expect(() => parseConnectionString('invalid')).toThrow(/invalid/i)
+      expect(() => parseConnectionString('')).toThrow()
+      expect(() => parseConnectionString('http://not-postgres')).toThrow()
+    })
+
+    it('should handle connection string without port', () => {
+      const connString = 'postgresql://user:pass@host/db'
+      const config = parseConnectionString(connString)
+
+      expect(config.port).toBe(5432) // Default PostgreSQL port
+    })
+
+    it('should parse Unix socket connection', () => {
+      // Unix socket connections use a special format with empty host
+      const connString = 'postgresql://user:pass@localhost/db?host=/var/run/postgresql'
+      const config = parseConnectionString(connString)
+
+      expect(config.socketPath).toBe('/var/run/postgresql')
+    })
+  })
+
+  describe('buildConnectionString', () => {
+    it('should build connection string from config', () => {
+      const config: ConnectionConfig = {
+        host: 'localhost',
+        port: 5432,
+        user: 'user',
+        password: 'password',
+        database: 'mydb',
+      }
+
+      const connString = buildConnectionString(config)
+
+      expect(connString).toBe('postgresql://user:password@localhost:5432/mydb')
+    })
+
+    it('should URL-encode special characters in password', () => {
+      const config: ConnectionConfig = {
+        host: 'localhost',
+        port: 5432,
+        user: 'user',
+        password: 'p@ss/word',
+        database: 'mydb',
+      }
+
+      const connString = buildConnectionString(config)
+
+      expect(connString).toContain('p%40ss%2Fword')
+    })
+
+    it('should include SSL options', () => {
+      const config: ConnectionConfig = {
+        host: 'localhost',
+        port: 5432,
+        user: 'user',
+        password: 'pass',
+        database: 'db',
+        ssl: { mode: 'require' },
+      }
+
+      const connString = buildConnectionString(config)
+
+      expect(connString).toContain('sslmode=require')
+    })
+  })
+
+  describe('detectProvider', () => {
+    it('should detect Neon provider', () => {
+      const connString =
+        'postgresql://user:pass@ep-cool-name.us-east-2.aws.neon.tech/db'
+      expect(detectProvider(connString)).toBe('neon')
+    })
+
+    it('should detect Supabase provider', () => {
+      const connString = 'postgresql://postgres:pass@db.xyz.supabase.co:5432/postgres'
+      expect(detectProvider(connString)).toBe('supabase')
+    })
+
+    it('should detect Railway provider', () => {
+      const connString =
+        'postgresql://postgres:pass@containers-us-west-1.railway.app:5432/railway'
+      expect(detectProvider(connString)).toBe('railway')
+    })
+
+    it('should detect Render provider', () => {
+      const connString = 'postgresql://user:pass@dpg-abc.oregon-postgres.render.com/db'
+      expect(detectProvider(connString)).toBe('render')
+    })
+
+    it('should return generic for unknown providers', () => {
+      const connString = 'postgresql://user:pass@localhost:5432/db'
+      expect(detectProvider(connString)).toBe('generic')
+    })
+
+    it('should detect AWS RDS', () => {
+      const connString =
+        'postgresql://user:pass@mydb.123456789012.us-east-1.rds.amazonaws.com:5432/db'
+      expect(detectProvider(connString)).toBe('aws-rds')
+    })
+
+    it('should detect Google Cloud SQL', () => {
+      const connString =
+        'postgresql://user:pass@/db?host=/cloudsql/project:region:instance'
+      expect(detectProvider(connString)).toBe('gcp-cloudsql')
+    })
+  })
+})
+
+// =============================================================================
+// 5. PROGRESS REPORTING TESTS
+// =============================================================================
+
+describe('MigrationProgressReporter', () => {
+  describe('createProgressReporter', () => {
+    it('should create a progress reporter instance', () => {
+      const reporter = createProgressReporter()
+
+      expect(reporter).toBeDefined()
+      expect(typeof reporter.onProgress).toBe('function')
+      expect(typeof reporter.report).toBe('function')
+    })
+
+    it('should emit progress events', async () => {
+      const reporter = createProgressReporter()
+      const events: ProgressEvent[] = []
+
+      reporter.onProgress((event) => {
+        events.push(event)
+      })
+
+      reporter.report({
+        phase: 'schema_export',
+        progress: 50,
+        message: 'Exporting tables...',
+      })
+
+      expect(events).toHaveLength(1)
+      expect(events[0].phase).toBe('schema_export')
+      expect(events[0].progress).toBe(50)
+    })
+
+    it('should support multiple listeners', async () => {
+      const reporter = createProgressReporter()
+      let count = 0
+
+      reporter.onProgress(() => count++)
+      reporter.onProgress(() => count++)
+
+      reporter.report({ phase: 'schema_export', progress: 0 })
+
+      expect(count).toBe(2)
+    })
+
+    it('should allow unsubscribing from events', () => {
+      const reporter = createProgressReporter()
+      const events: ProgressEvent[] = []
+
+      const unsubscribe = reporter.onProgress((event) => events.push(event))
+
+      reporter.report({ phase: 'schema_export', progress: 0 })
+      expect(events).toHaveLength(1)
+
+      unsubscribe()
+
+      reporter.report({ phase: 'schema_export', progress: 50 })
+      expect(events).toHaveLength(1) // Should not have increased
+    })
+  })
+
+  describe('Progress phases', () => {
+    let reporter: MigrationProgressReporter
+
+    beforeEach(() => {
+      reporter = createProgressReporter()
+    })
+
+    it('should report schema export progress', () => {
+      const events: ProgressEvent[] = []
+      reporter.onProgress((e) => events.push(e))
+
+      reporter.startPhase('schema_export')
+      reporter.report({ phase: 'schema_export', progress: 50, message: 'Exporting tables' })
+      reporter.endPhase('schema_export')
+
+      expect(events.some((e) => e.phase === 'schema_export' && e.progress === 0)).toBe(true)
+      expect(events.some((e) => e.phase === 'schema_export' && e.progress === 100)).toBe(true)
+    })
+
+    it('should report schema transformation progress', () => {
+      const events: ProgressEvent[] = []
+      reporter.onProgress((e) => events.push(e))
+
+      reporter.startPhase('schema_transform')
+      reporter.report({
+        phase: 'schema_transform',
+        progress: 30,
+        details: { currentTable: 'users' },
+      })
+      reporter.endPhase('schema_transform')
+
+      expect(events.some((e) => e.phase === 'schema_transform')).toBe(true)
+    })
+
+    it('should report data migration progress', () => {
+      const events: ProgressEvent[] = []
+      reporter.onProgress((e) => events.push(e))
+
+      reporter.startPhase('data_migration')
+      reporter.report({
+        phase: 'data_migration',
+        progress: 25,
+        details: {
+          table: 'users',
+          rowsProcessed: 2500,
+          totalRows: 10000,
+          bytesTransferred: 1024000,
+        },
+      })
+
+      expect(events.some((e) => e.details?.rowsProcessed === 2500)).toBe(true)
+    })
+
+    it('should report validation progress', () => {
+      const events: ProgressEvent[] = []
+      reporter.onProgress((e) => events.push(e))
+
+      reporter.startPhase('validation')
+      reporter.report({
+        phase: 'validation',
+        progress: 75,
+        details: { checksCompleted: 3, totalChecks: 4 },
+      })
+
+      expect(events.some((e) => e.phase === 'validation')).toBe(true)
+    })
+
+    it('should report errors', () => {
+      const events: ProgressEvent[] = []
+      reporter.onProgress((e) => events.push(e))
+
+      reporter.reportError({
+        phase: 'data_migration',
+        error: new Error('Connection lost'),
+        recoverable: true,
+      })
+
+      const errorEvent = events.find((e) => e.error)
+      expect(errorEvent).toBeDefined()
+      expect(errorEvent?.error?.message).toBe('Connection lost')
+      expect(errorEvent?.recoverable).toBe(true)
+    })
+
+    it('should track overall progress across phases', () => {
+      const events: ProgressEvent[] = []
+      reporter.onProgress((e) => events.push(e))
+
+      reporter.startPhase('schema_export')
+      reporter.endPhase('schema_export')
+      reporter.startPhase('schema_transform')
+      reporter.endPhase('schema_transform')
+      reporter.startPhase('data_migration')
+
+      const lastEvent = events[events.length - 1]
+      expect(lastEvent.overallProgress).toBeDefined()
+      expect(lastEvent.overallProgress).toBeGreaterThan(0)
+    })
+  })
+
+  describe('MigrationProgressReporter class', () => {
+    it('should support progress callbacks during migration', async () => {
+      const migrator = new DataMigrator({
+        sourceConnection: 'postgresql://user:pass@source:5432/db',
+        targetConnection: 'pglite://local',
+      })
+
+      const progressEvents: ProgressEvent[] = []
+
+      await migrator.migrateTable('users', {
+        onProgress: (event) => progressEvents.push(event),
+      })
+
+      expect(progressEvents.length).toBeGreaterThan(0)
+      expect(progressEvents.some((e) => e.phase === 'data_migration')).toBe(true)
+    })
+
+    it('should provide ETA estimation', () => {
+      const reporter = createProgressReporter()
+      const events: ProgressEvent[] = []
+      reporter.onProgress((e) => events.push(e))
+
+      // Simulate progress over time
+      reporter.startPhase('data_migration')
+      reporter.report({
+        phase: 'data_migration',
+        progress: 25,
+        details: { rowsProcessed: 2500, totalRows: 10000 },
+      })
+
+      // Wait a bit and report more progress
+      reporter.report({
+        phase: 'data_migration',
+        progress: 50,
+        details: { rowsProcessed: 5000, totalRows: 10000 },
+      })
+
+      const lastEvent = events[events.length - 1]
+      expect(lastEvent.estimatedTimeRemaining).toBeDefined()
+    })
+
+    it('should provide throughput metrics', () => {
+      const reporter = createProgressReporter()
+      const events: ProgressEvent[] = []
+      reporter.onProgress((e) => events.push(e))
+
+      reporter.startPhase('data_migration')
+      reporter.report({
+        phase: 'data_migration',
+        progress: 50,
+        details: {
+          rowsProcessed: 5000,
+          totalRows: 10000,
+          bytesTransferred: 5000000,
+          elapsedMs: 5000,
+        },
+      })
+
+      const lastEvent = events[events.length - 1]
+      expect(lastEvent.throughput).toBeDefined()
+      expect(lastEvent.throughput?.rowsPerSecond).toBeDefined()
+      expect(lastEvent.throughput?.bytesPerSecond).toBeDefined()
+    })
+
+    it('should generate migration summary', async () => {
+      const reporter = createProgressReporter()
+
+      reporter.startPhase('schema_export')
+      reporter.endPhase('schema_export')
+      reporter.startPhase('data_migration')
+      reporter.endPhase('data_migration')
+      reporter.startPhase('validation')
+      reporter.endPhase('validation')
+
+      const summary = reporter.getSummary()
+
+      expect(summary.phases).toBeDefined()
+      expect(summary.totalDuration).toBeDefined()
+      expect(summary.phaseDurations).toBeDefined()
+      expect(summary.success).toBe(true)
+    })
+  })
+
+  describe('ProgressEvent types', () => {
+    it('should have correct structure for schema export events', () => {
+      const event: ProgressEvent = {
+        phase: 'schema_export',
+        progress: 50,
+        timestamp: Date.now(),
+        message: 'Exporting tables',
+        details: {
+          tablesExported: 5,
+          totalTables: 10,
+        },
+      }
+
+      expect(event.phase).toBe('schema_export')
+      expect(event.details?.tablesExported).toBe(5)
+    })
+
+    it('should have correct structure for data migration events', () => {
+      const event: ProgressEvent = {
+        phase: 'data_migration',
+        progress: 75,
+        timestamp: Date.now(),
+        message: 'Migrating users table',
+        details: {
+          table: 'users',
+          rowsProcessed: 7500,
+          totalRows: 10000,
+          bytesTransferred: 15000000,
+          currentBatch: 8,
+          totalBatches: 10,
+        },
+      }
+
+      expect(event.phase).toBe('data_migration')
+      expect(event.details?.table).toBe('users')
+    })
+  })
+})
+
+// =============================================================================
+// INTEGRATION TESTS
+// =============================================================================
+
+describe('Migration Tooling Integration', () => {
+  it('should perform full migration from Neon to PGLite', async () => {
+    const sourceConnection =
+      'postgresql://user:pass@ep-cool-name.us-east-2.aws.neon.tech/neondb?sslmode=require'
+
+    // 1. Export schema
+    const schema = await exportSchema({
+      connectionString: sourceConnection,
+      includeData: false,
+    })
+
+    // 2. Transform schema
+    const transformed = await transformSchema(schema)
+
+    // 3. Create data migrator
+    const migrator = new DataMigrator({
+      sourceConnection,
+      targetConnection: 'pglite://local',
+    })
+
+    // 4. Track progress
+    const progressEvents: ProgressEvent[] = []
+
+    // 5. Migrate data
+    const result = await migrator.migrateAll({
+      schema: transformed.schema,
+      onProgress: (event) => progressEvents.push(event),
+    })
+
+    expect(result.success).toBe(true)
+    expect(progressEvents.length).toBeGreaterThan(0)
+  })
+
+  it('should perform full migration from Supabase to PGLite', async () => {
+    const sourceConnection =
+      'postgresql://postgres:pass@db.projectref.supabase.co:5432/postgres'
+
+    const schema = await exportSchema({
+      connectionString: sourceConnection,
+      excludeTables: ['auth.users', 'storage.objects'], // Supabase internal tables
+    })
+
+    const transformed = await transformSchema(schema, {
+      viewStrategy: 'preserve',
+    })
+
+    const migrator = new DataMigrator({
+      sourceConnection,
+      targetConnection: 'pglite://local',
+    })
+
+    const result = await migrator.migrateAll({
+      schema: transformed.schema,
+      validateIntegrity: true,
+    })
+
+    expect(result.success).toBe(true)
+    expect(result.integrityChecks?.checksumValid).toBe(true)
+  })
+
+  it('should handle incremental migration with checkpoints', async () => {
+    const sourceConnection = 'postgresql://user:pass@host:5432/db'
+
+    const migrator = new DataMigrator({
+      sourceConnection,
+      targetConnection: 'pglite://local',
+    })
+
+    // Start migration
+    const checkpoint1 = await migrator.migrateTable('large_table', {
+      batchSize: 1000,
+      stopAfterBatches: 5,
+    })
+
+    expect(checkpoint1.checkpoint).toBeDefined()
+    expect(checkpoint1.completed).toBe(false)
+
+    // Resume from checkpoint
+    const checkpoint2 = await migrator.migrateTable('large_table', {
+      batchSize: 1000,
+      resumeFrom: checkpoint1.checkpoint,
+    })
+
+    expect(checkpoint2.rowsProcessed).toBeGreaterThan(checkpoint1.rowsProcessed)
+  })
+})
+
+// =============================================================================
+// 6. SCHEMA COMPATIBILITY VALIDATION TESTS
+// =============================================================================
+
+describe('Schema Compatibility Validation', () => {
+  describe('validateSchemaCompatibility', () => {
+    it('should validate a compatible schema successfully', () => {
+      const schema: ExportedSchema = {
+        tables: [
+          {
+            name: 'users',
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'email', type: 'varchar(255)', nullable: false },
+              { name: 'created_at', type: 'timestamp', nullable: false },
+            ],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [],
+            indexes: [],
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: ['uuid-ossp'],
+      }
+
+      const result = validateSchemaCompatibility(schema)
+
+      expect(result.isCompatible).toBe(true)
+      expect(result.errorCount).toBe(0)
+    })
+
+    it('should detect unsupported types', () => {
+      const schema: ExportedSchema = {
+        tables: [
+          {
+            name: 'geo_data',
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'location', type: 'geography', nullable: true },
+              { name: 'boundary', type: 'geometry', nullable: true },
+            ],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [],
+            indexes: [],
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+      }
+
+      const result = validateSchemaCompatibility(schema)
+
+      expect(result.summary.unsupportedTypes).toBeGreaterThan(0)
+      expect(result.issues.some(i => i.code === 'UNSUPPORTED_TYPE')).toBe(true)
+      expect(result.issues.some(i => i.column === 'location')).toBe(true)
+    })
+
+    it('should detect unsupported extensions', () => {
+      const schema: ExportedSchema = {
+        tables: [],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: ['postgis', 'pg_trgm', 'vector'],
+      }
+
+      const result = validateSchemaCompatibility(schema)
+
+      expect(result.summary.unsupportedExtensions).toBe(3)
+      expect(result.issues.filter(i => i.code === 'UNSUPPORTED_EXTENSION')).toHaveLength(3)
+    })
+
+    it('should detect unsupported features like partitioning', () => {
+      const schema: ExportedSchema = {
+        tables: [
+          {
+            name: 'events',
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'created_at', type: 'timestamp', nullable: false },
+            ],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [],
+            indexes: [],
+            partitioning: {
+              type: 'RANGE',
+              columns: ['created_at'],
+            },
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+      }
+
+      const result = validateSchemaCompatibility(schema)
+
+      expect(result.summary.unsupportedFeatures).toBe(1)
+      expect(result.issues.some(i => i.code === 'UNSUPPORTED_FEATURE')).toBe(true)
+    })
+
+    it('should detect reserved keyword names', () => {
+      const schema: ExportedSchema = {
+        tables: [
+          {
+            name: 'order',  // Reserved keyword
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'user', type: 'integer', nullable: false },  // Reserved keyword
+            ],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [],
+            indexes: [],
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+      }
+
+      const result = validateSchemaCompatibility(schema)
+
+      expect(result.summary.namingIssues).toBeGreaterThan(0)
+      expect(result.issues.some(i => i.code === 'RESERVED_KEYWORD_NAME')).toBe(true)
+    })
+
+    it('should detect missing referenced tables in foreign keys', () => {
+      const schema: ExportedSchema = {
+        tables: [
+          {
+            name: 'orders',
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'customer_id', type: 'integer', nullable: false },
+            ],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [
+              { columns: ['customer_id'], references: { table: 'customers', columns: ['id'] } },
+            ],
+            indexes: [],
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+      }
+
+      const result = validateSchemaCompatibility(schema)
+
+      expect(result.summary.constraintIssues).toBe(1)
+      expect(result.issues.some(i => i.code === 'MISSING_REFERENCED_TABLE')).toBe(true)
+    })
+
+    it('should support strict mode treating warnings as errors', () => {
+      const schema: ExportedSchema = {
+        tables: [
+          {
+            name: 'data',
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'location', type: 'geography', nullable: true },  // Has alternative
+            ],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [],
+            indexes: [],
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+      }
+
+      const normalResult = validateSchemaCompatibility(schema)
+      expect(normalResult.isCompatible).toBe(true)  // Warning only, not an error
+
+      const strictResult = validateSchemaCompatibility(schema, { strict: true })
+      expect(strictResult.isCompatible).toBe(false)  // Warning becomes error in strict mode
+    })
+
+    it('should allow skipping specific validation checks', () => {
+      const schema: ExportedSchema = {
+        tables: [
+          {
+            name: 'data',
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'location', type: 'geography', nullable: true },
+            ],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [],
+            indexes: [],
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: ['postgis'],
+      }
+
+      const fullResult = validateSchemaCompatibility(schema)
+      const skippedResult = validateSchemaCompatibility(schema, {
+        skipChecks: ['types', 'extensions'],
+      })
+
+      expect(fullResult.totalIssues).toBeGreaterThan(skippedResult.totalIssues)
+      expect(skippedResult.summary.unsupportedTypes).toBe(0)
+      expect(skippedResult.summary.unsupportedExtensions).toBe(0)
+    })
+
+    it('should support custom type mappings', () => {
+      const schema: ExportedSchema = {
+        tables: [
+          {
+            name: 'data',
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'custom_type', type: 'my_custom_type', nullable: true },
+            ],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [],
+            indexes: [],
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+      }
+
+      const withoutMapping = validateSchemaCompatibility(schema)
+      const withMapping = validateSchemaCompatibility(schema, {
+        customTypeMappings: { 'my_custom_type': 'text' },
+      })
+
+      expect(withoutMapping.summary.unsupportedTypes).toBe(1)
+      expect(withMapping.summary.unsupportedTypes).toBe(0)
+    })
+
+    it('should calculate complexity score', () => {
+      const simpleSchema: ExportedSchema = {
+        tables: [
+          {
+            name: 'simple',
+            schema: 'public',
+            columns: [{ name: 'id', type: 'serial', nullable: false }],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [],
+            indexes: [],
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+      }
+
+      const complexSchema: ExportedSchema = {
+        tables: Array(15).fill(null).map((_, i) => ({
+          name: `table_${i}`,
+          schema: 'public',
+          columns: [
+            { name: 'id', type: 'serial', nullable: false },
+            { name: 'location', type: 'geography', nullable: true },
+          ],
+          primaryKey: { columns: ['id'] },
+          foreignKeys: [],
+          indexes: [],
+        })),
+        views: [],
+        functions: Array(10).fill(null).map((_, i) => ({
+          name: `func_${i}`,
+          schema: 'public',
+          definition: 'SELECT 1',
+          language: 'sql',
+        })),
+        triggers: [],
+        extensions: ['postgis', 'pg_trgm'],
+      }
+
+      const simpleResult = validateSchemaCompatibility(simpleSchema)
+      const complexResult = validateSchemaCompatibility(complexSchema)
+
+      expect(simpleResult.complexityScore).toBeLessThan(complexResult.complexityScore)
+      expect(complexResult.complexityScore).toBeGreaterThanOrEqual(1)
+      expect(complexResult.complexityScore).toBeLessThanOrEqual(10)
+    })
+
+    it('should provide suggestions for issues', () => {
+      const schema: ExportedSchema = {
+        tables: [
+          {
+            name: 'data',
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'location', type: 'geography', nullable: true },
+            ],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [],
+            indexes: [],
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+      }
+
+      const result = validateSchemaCompatibility(schema)
+      const typeIssue = result.issues.find(i => i.code === 'UNSUPPORTED_TYPE')
+
+      expect(typeIssue).toBeDefined()
+      expect(typeIssue?.suggestion).toBeDefined()
+      expect(typeIssue?.suggestion?.length).toBeGreaterThan(0)
+    })
+
+    it('should indicate which issues are auto-fixable', () => {
+      const schema: ExportedSchema = {
+        tables: [
+          {
+            name: 'data',
+            schema: 'public',
+            columns: [
+              { name: 'id', type: 'serial', nullable: false },
+              { name: 'location', type: 'geography', nullable: true },  // Has alternative - auto-fixable
+              { name: 'custom', type: 'unknown_type', nullable: true },  // No alternative - not auto-fixable
+            ],
+            primaryKey: { columns: ['id'] },
+            foreignKeys: [],
+            indexes: [],
+          },
+        ],
+        views: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+      }
+
+      const result = validateSchemaCompatibility(schema)
+
+      const locationIssue = result.issues.find(i => i.column === 'location')
+      const customIssue = result.issues.find(i => i.column === 'custom')
+
+      expect(locationIssue?.autoFixable).toBe(true)
+      expect(customIssue?.autoFixable).toBe(false)
+    })
+  })
+})
+
+// =============================================================================
+// 7. STREAMING METRICS TESTS
+// =============================================================================
+
+describe('Streaming Metrics Tracker', () => {
+  describe('createStreamingMetricsTracker', () => {
+    it('should create a metrics tracker', () => {
+      const tracker = createStreamingMetricsTracker()
+
+      expect(tracker).toBeDefined()
+      expect(typeof tracker.start).toBe('function')
+      expect(typeof tracker.recordBatch).toBe('function')
+      expect(typeof tracker.getMetrics).toBe('function')
+      expect(typeof tracker.reset).toBe('function')
+    })
+
+    it('should track batch processing', () => {
+      const tracker = createStreamingMetricsTracker()
+
+      tracker.start()
+      tracker.recordBatch(100, 10000, 50)
+      tracker.recordBatch(100, 10000, 45)
+      tracker.recordBatch(100, 10000, 55)
+
+      const metrics = tracker.getMetrics()
+
+      expect(metrics.rowsProcessed).toBe(300)
+      expect(metrics.bytesTransferred).toBe(30000)
+      expect(metrics.batchesCompleted).toBe(3)
+      expect(metrics.avgRowsPerBatch).toBe(100)
+    })
+
+    it('should calculate throughput metrics', () => {
+      const tracker = createStreamingMetricsTracker()
+
+      tracker.start()
+      tracker.recordBatch(1000, 100000, 100)
+
+      const metrics = tracker.getMetrics()
+
+      expect(metrics.throughput).toBeDefined()
+      expect(metrics.throughput.rowsPerSecond).toBeGreaterThan(0)
+      expect(metrics.throughput.bytesPerSecond).toBeGreaterThan(0)
+    })
+
+    it('should track batch timing statistics', () => {
+      const tracker = createStreamingMetricsTracker()
+
+      tracker.start()
+      tracker.recordBatch(100, 10000, 50)
+      tracker.recordBatch(100, 10000, 100)
+      tracker.recordBatch(100, 10000, 25)
+
+      const metrics = tracker.getMetrics()
+
+      expect(metrics.batchTimings.min).toBe(25)
+      expect(metrics.batchTimings.max).toBe(100)
+      expect(metrics.batchTimings.avg).toBeCloseTo(58.33, 1)
+      expect(metrics.batchTimings.last).toBe(25)
+    })
+
+    it('should track memory usage', () => {
+      const tracker = createStreamingMetricsTracker()
+
+      tracker.start()
+      tracker.recordBatch(100, 10000, 50)
+
+      const metrics = tracker.getMetrics()
+
+      expect(metrics.memoryUsage).toBeDefined()
+      expect(metrics.memoryUsage.current).toBeGreaterThanOrEqual(0)
+      expect(metrics.memoryUsage.peak).toBeGreaterThanOrEqual(0)
+      expect(metrics.memoryUsage.available).toBeGreaterThan(0)
+    })
+
+    it('should reset all metrics', () => {
+      const tracker = createStreamingMetricsTracker()
+
+      tracker.start()
+      tracker.recordBatch(100, 10000, 50)
+      tracker.reset()
+
+      const metrics = tracker.getMetrics()
+
+      expect(metrics.rowsProcessed).toBe(0)
+      expect(metrics.bytesTransferred).toBe(0)
+      expect(metrics.batchesCompleted).toBe(0)
+    })
+
+    it('should calculate elapsed time', () => {
+      const tracker = createStreamingMetricsTracker()
+
+      tracker.start()
+      tracker.recordBatch(100, 10000, 50)
+
+      const metrics = tracker.getMetrics()
+
+      expect(metrics.startTime).toBeGreaterThan(0)
+      expect(metrics.lastUpdateTime).toBeGreaterThanOrEqual(metrics.startTime)
+      expect(metrics.elapsedMs).toBeGreaterThanOrEqual(0)
+    })
+  })
+})
+
+// =============================================================================
+// 8. MIGRATION ERROR TESTS
+// =============================================================================
+
+describe('MigrationError', () => {
+  describe('constructor', () => {
+    it('should create an error with code and message', () => {
+      const error = new MigrationError('CONNECTION_FAILED', 'Could not connect to database')
+
+      expect(error).toBeInstanceOf(Error)
+      expect(error).toBeInstanceOf(MigrationError)
+      expect(error.code).toBe('CONNECTION_FAILED')
+      expect(error.message).toContain('Could not connect to database')
+      expect(error.name).toBe('MigrationError')
+    })
+
+    it('should include context in the error message', () => {
+      const error = new MigrationError('TABLE_NOT_FOUND', 'Table does not exist', {
+        context: {
+          table: 'users',
+          connectionString: 'postgresql://user:pass@host:5432/db',
+        },
+      })
+
+      expect(error.message).toContain('table: users')
+      expect(error.message).toContain('connection:')
+      expect(error.message).not.toContain('pass')  // Password should be masked
+    })
+
+    it('should have default suggestions for error codes', () => {
+      const error = new MigrationError('CONNECTION_TIMEOUT', 'Connection timed out')
+
+      expect(error.suggestions).toBeDefined()
+      expect(error.suggestions.length).toBeGreaterThan(0)
+      expect(error.suggestions.some(s => s.toLowerCase().includes('timeout'))).toBe(true)
+    })
+
+    it('should allow custom suggestions', () => {
+      const error = new MigrationError('UNKNOWN_ERROR', 'Something went wrong', {
+        suggestions: ['Try again later', 'Check the logs'],
+      })
+
+      expect(error.suggestions).toEqual(['Try again later', 'Check the logs'])
+    })
+
+    it('should track recoverability', () => {
+      const recoverableError = new MigrationError('NETWORK_ERROR', 'Network issue', {
+        recoverable: true,
+      })
+
+      const unrecoverableError = new MigrationError('SCHEMA_INCOMPATIBLE', 'Schema mismatch', {
+        recoverable: false,
+      })
+
+      expect(recoverableError.recoverable).toBe(true)
+      expect(unrecoverableError.recoverable).toBe(false)
+    })
+
+    it('should preserve the original cause', () => {
+      const originalError = new Error('Original error')
+      const migrationError = new MigrationError('UNKNOWN_ERROR', 'Wrapped error', {
+        cause: originalError,
+      })
+
+      expect(migrationError.cause).toBe(originalError)
+    })
+  })
+
+  describe('toUserMessage', () => {
+    it('should format a user-friendly message', () => {
+      const error = new MigrationError('TABLE_NOT_FOUND', 'Table users not found', {
+        context: { table: 'users' },
+      })
+
+      const userMessage = error.toUserMessage()
+
+      expect(userMessage).toContain('Migration Error')
+      expect(userMessage).toContain('TABLE_NOT_FOUND')
+      expect(userMessage).toContain('Suggested actions')
+    })
+
+    it('should number the suggestions', () => {
+      const error = new MigrationError('CONNECTION_FAILED', 'Could not connect')
+
+      const userMessage = error.toUserMessage()
+
+      expect(userMessage).toMatch(/1\.\s+\w/)
+      expect(userMessage).toMatch(/2\.\s+\w/)
+    })
+  })
+
+  describe('error codes', () => {
+    const errorCodes: MigrationErrorCode[] = [
+      'CONNECTION_FAILED',
+      'CONNECTION_TIMEOUT',
+      'AUTHENTICATION_FAILED',
+      'DATABASE_NOT_FOUND',
+      'TABLE_NOT_FOUND',
+      'COLUMN_NOT_FOUND',
+      'SCHEMA_INCOMPATIBLE',
+      'DATA_VALIDATION_FAILED',
+      'MEMORY_LIMIT_EXCEEDED',
+      'NETWORK_ERROR',
+      'PERMISSION_DENIED',
+      'CONSTRAINT_VIOLATION',
+      'TYPE_CONVERSION_FAILED',
+      'BATCH_PROCESSING_FAILED',
+      'CHECKPOINT_INVALID',
+      'UNKNOWN_ERROR',
+    ]
+
+    it.each(errorCodes)('should have default suggestions for %s', (code) => {
+      const error = new MigrationError(code, 'Test error')
+
+      expect(error.suggestions).toBeDefined()
+      expect(error.suggestions.length).toBeGreaterThan(0)
+    })
+  })
+})