@friggframework/core 2.0.0--canary.461.2ca8c89.0 → 2.0.0--canary.461.4f3c330.0

package/database/use-cases/get-migration-status-use-case.test.js

@@ -0,0 +1,215 @@
+/**
+ * Tests for GetMigrationStatusUseCase
+ */
+
+const {
+    GetMigrationStatusUseCase,
+    ValidationError,
+    NotFoundError,
+} = require('./get-migration-status-use-case');
+
+describe('GetMigrationStatusUseCase', () => {
+    let useCase;
+    let mockProcessRepository;
+
+    beforeEach(() => {
+        // Create mock repository
+        mockProcessRepository = {
+            findById: jest.fn(),
+        };
+
+        // Create use case with mock
+        useCase = new GetMigrationStatusUseCase({
+            processRepository: mockProcessRepository,
+        });
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('constructor', () => {
+        it('should throw error if processRepository not provided', () => {
+            expect(() => {
+                new GetMigrationStatusUseCase({});
+            }).toThrow('processRepository dependency is required');
+        });
+    });
+
+    describe('execute', () => {
+        it('should return migration status for COMPLETED process', async () => {
+            const mockProcess = {
+                id: 'process-123',
+                type: 'DATABASE_MIGRATION',
+                state: 'COMPLETED',
+                context: {
+                    dbType: 'postgresql',
+                    stage: 'production',
+                    migrationCommand: 'migrate deploy',
+                },
+                results: {
+                    success: true,
+                    duration: '2341ms',
+                    timestamp: '2025-10-18T10:30:00Z',
+                },
+                createdAt: new Date('2025-10-18T10:29:55Z'),
+                updatedAt: new Date('2025-10-18T10:30:02Z'),
+            };
+
+            mockProcessRepository.findById.mockResolvedValue(mockProcess);
+
+            const result = await useCase.execute({ processId: 'process-123' });
+
+            expect(mockProcessRepository.findById).toHaveBeenCalledWith('process-123');
+            expect(result).toEqual({
+                processId: 'process-123',
+                type: 'DATABASE_MIGRATION',
+                state: 'COMPLETED',
+                context: mockProcess.context,
+                results: mockProcess.results,
+                createdAt: mockProcess.createdAt,
+                updatedAt: mockProcess.updatedAt,
+            });
+        });
+
+        it('should return migration status for RUNNING process', async () => {
+            const mockProcess = {
+                id: 'process-456',
+                type: 'DATABASE_MIGRATION',
+                state: 'RUNNING',
+                context: {
+                    dbType: 'mongodb',
+                    stage: 'dev',
+                    startedAt: '2025-10-18T10:30:00Z',
+                },
+                results: {},
+                createdAt: new Date('2025-10-18T10:29:55Z'),
+                updatedAt: new Date('2025-10-18T10:30:00Z'),
+            };
+
+            mockProcessRepository.findById.mockResolvedValue(mockProcess);
+
+            const result = await useCase.execute({ processId: 'process-456' });
+
+            expect(result.state).toBe('RUNNING');
+            expect(result.context.dbType).toBe('mongodb');
+        });
+
+        it('should return migration status for FAILED process', async () => {
+            const mockProcess = {
+                id: 'process-789',
+                type: 'DATABASE_MIGRATION',
+                state: 'FAILED',
+                context: {
+                    dbType: 'postgresql',
+                    stage: 'production',
+                    failedAt: '2025-10-18T10:30:00Z',
+                },
+                results: {
+                    error: 'Migration failed: syntax error',
+                    errorType: 'MigrationError',
+                },
+                createdAt: new Date('2025-10-18T10:29:55Z'),
+                updatedAt: new Date('2025-10-18T10:30:00Z'),
+            };
+
+            mockProcessRepository.findById.mockResolvedValue(mockProcess);
+
+            const result = await useCase.execute({ processId: 'process-789' });
+
+            expect(result.state).toBe('FAILED');
+            expect(result.results.error).toContain('Migration failed');
+        });
+
+        it('should handle empty context and results', async () => {
+            const mockProcess = {
+                id: 'process-999',
+                type: 'DATABASE_MIGRATION',
+                state: 'INITIALIZING',
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+
+            mockProcessRepository.findById.mockResolvedValue(mockProcess);
+
+            const result = await useCase.execute({ processId: 'process-999' });
+
+            expect(result.context).toEqual({});
+            expect(result.results).toEqual({});
+        });
+
+        it('should throw NotFoundError if process does not exist', async () => {
+            mockProcessRepository.findById.mockResolvedValue(null);
+
+            await expect(
+                useCase.execute({ processId: 'nonexistent-123' })
+            ).rejects.toThrow(NotFoundError);
+
+            await expect(
+                useCase.execute({ processId: 'nonexistent-123' })
+            ).rejects.toThrow('Migration process not found: nonexistent-123');
+        });
+
+        it('should throw error if process is not a migration process', async () => {
+            const nonMigrationProcess = {
+                id: 'process-999',
+                type: 'CRM_SYNC', // Not a migration
+                state: 'RUNNING',
+                context: {},
+                results: {},
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+
+            mockProcessRepository.findById.mockResolvedValue(nonMigrationProcess);
+
+            await expect(
+                useCase.execute({ processId: 'process-999' })
+            ).rejects.toThrow('Process process-999 is not a migration process (type: CRM_SYNC)');
+        });
+
+        it('should throw ValidationError if processId is missing', async () => {
+            await expect(
+                useCase.execute({})
+            ).rejects.toThrow(ValidationError);
+
+            await expect(
+                useCase.execute({})
+            ).rejects.toThrow('processId is required');
+        });
+
+        it('should throw ValidationError if processId is not a string', async () => {
+            await expect(
+                useCase.execute({ processId: 123 })
+            ).rejects.toThrow('processId must be a string');
+        });
+
+        it('should handle repository errors', async () => {
+            mockProcessRepository.findById.mockRejectedValue(new Error('Database connection failed'));
+
+            await expect(
+                useCase.execute({ processId: 'process-123' })
+            ).rejects.toThrow('Database connection failed');
+        });
+    });
+
+    describe('NotFoundError', () => {
+        it('should have correct properties', () => {
+            const error = new NotFoundError('test message');
+            expect(error.name).toBe('NotFoundError');
+            expect(error.message).toBe('test message');
+            expect(error.statusCode).toBe(404);
+            expect(error instanceof Error).toBe(true);
+        });
+    });
+
+    describe('ValidationError', () => {
+        it('should have correct name', () => {
+            const error = new ValidationError('test message');
+            expect(error.name).toBe('ValidationError');
+            expect(error.message).toBe('test message');
+            expect(error instanceof Error).toBe(true);
+        });
+    });
+});
+

package/database/use-cases/trigger-database-migration-use-case.js

@@ -49,7 +49,7 @@ class TriggerDatabaseMigrationUseCase {
         this._validateParams({ userId, dbType, stage });
 
         // Create Process record for tracking
-        const process = await this.processRepository.create({
+        const migrationProcess = await this.processRepository.create({
             userId,
             integrationId: null, // System operation, not tied to integration
             name: 'database-migration',
@@ -63,7 +63,7 @@ class TriggerDatabaseMigrationUseCase {
             results: {},
         });
 
-        console.log(`Created migration process: ${process.id}`);
+        console.log(`Created migration process: ${migrationProcess.id}`);
 
         // Get queue URL from environment
         const queueUrl = process.env.DB_MIGRATION_QUEUE_URL;
@@ -78,20 +78,20 @@ class TriggerDatabaseMigrationUseCase {
         try {
             await this.queuerUtil.send(
                 {
-                    processId: process.id,
+                    processId: migrationProcess.id,
                     dbType,
                     stage,
                 },
                 queueUrl
             );
 
-            console.log(`Sent migration job to queue for process: ${process.id}`);
+            console.log(`Sent migration job to queue for process: ${migrationProcess.id}`);
         } catch (error) {
             console.error(`Failed to send migration to queue:`, error);
-            
+
             // Update process state to FAILED
             await this.processRepository.updateState(
-                process.id,
+                migrationProcess.id,
                 'FAILED',
                 {
                     error: 'Failed to queue migration job',
@@ -107,9 +107,9 @@ class TriggerDatabaseMigrationUseCase {
         // Return process info immediately (don't wait for migration completion)
         return {
             success: true,
-            processId: process.id,
-            state: process.state,
-            statusUrl: `/db-migrate/${process.id}`,
+            processId: migrationProcess.id,
+            state: migrationProcess.state,
+            statusUrl: `/db-migrate/${migrationProcess.id}`,
             message: 'Database migration queued successfully',
         };
     }

package/database/use-cases/trigger-database-migration-use-case.test.js

@@ -0,0 +1,265 @@
+/**
+ * Tests for TriggerDatabaseMigrationUseCase
+ */
+
+const {
+    TriggerDatabaseMigrationUseCase,
+    ValidationError,
+} = require('./trigger-database-migration-use-case');
+
+describe('TriggerDatabaseMigrationUseCase', () => {
+    let useCase;
+    let mockProcessRepository;
+    let mockQueuerUtil;
+    let originalEnv;
+
+    beforeEach(() => {
+        // Save original environment value
+        originalEnv = process.env.DB_MIGRATION_QUEUE_URL;
+
+        // Set test environment
+        process.env.DB_MIGRATION_QUEUE_URL = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
+
+        // Create mock repository
+        mockProcessRepository = {
+            create: jest.fn().mockResolvedValue({
+                id: 'process-123',
+                userId: 'user-456',
+                integrationId: null,
+                name: 'database-migration',
+                type: 'DATABASE_MIGRATION',
+                state: 'INITIALIZING',
+                context: {
+                    dbType: 'postgresql',
+                    stage: 'production',
+                },
+                results: {},
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            }),
+            updateState: jest.fn().mockResolvedValue(true),
+        };
+
+        // Create mock queuer util
+        mockQueuerUtil = {
+            send: jest.fn().mockResolvedValue({ MessageId: 'msg-123' }),
+        };
+
+        // Create use case with mocks
+        useCase = new TriggerDatabaseMigrationUseCase({
+            processRepository: mockProcessRepository,
+            queuerUtil: mockQueuerUtil,
+        });
+    });
+
+    afterEach(() => {
+        // Restore original environment
+        if (originalEnv !== undefined) {
+            process.env.DB_MIGRATION_QUEUE_URL = originalEnv;
+        } else {
+            delete process.env.DB_MIGRATION_QUEUE_URL;
+        }
+        jest.clearAllMocks();
+    });
+
+    describe('constructor', () => {
+        it('should throw error if processRepository not provided', () => {
+            expect(() => {
+                new TriggerDatabaseMigrationUseCase({});
+            }).toThrow('processRepository dependency is required');
+        });
+
+        it('should accept custom queuerUtil', () => {
+            const customQueuer = { send: jest.fn() };
+            const instance = new TriggerDatabaseMigrationUseCase({
+                processRepository: mockProcessRepository,
+                queuerUtil: customQueuer,
+            });
+
+            expect(instance.queuerUtil).toBe(customQueuer);
+        });
+    });
+
+    describe('execute', () => {
+        it('should create process and queue migration job', async () => {
+            const result = await useCase.execute({
+                userId: 'user-456',
+                dbType: 'postgresql',
+                stage: 'production',
+            });
+
+            // Verify process creation
+            expect(mockProcessRepository.create).toHaveBeenCalledWith({
+                userId: 'user-456',
+                integrationId: null,
+                name: 'database-migration',
+                type: 'DATABASE_MIGRATION',
+                state: 'INITIALIZING',
+                context: expect.objectContaining({
+                    dbType: 'postgresql',
+                    stage: 'production',
+                }),
+                results: {},
+            });
+
+            // Verify SQS message sent
+            expect(mockQueuerUtil.send).toHaveBeenCalledWith(
+                {
+                    processId: 'process-123',
+                    dbType: 'postgresql',
+                    stage: 'production',
+                },
+                'https://sqs.us-east-1.amazonaws.com/123456789/test-queue'
+            );
+
+            // Verify response
+            expect(result).toEqual({
+                success: true,
+                processId: 'process-123',
+                state: 'INITIALIZING',
+                statusUrl: '/db-migrate/process-123',
+                message: 'Database migration queued successfully',
+            });
+        });
+
+        it('should handle MongoDB dbType', async () => {
+            await useCase.execute({
+                userId: 'user-456',
+                dbType: 'mongodb',
+                stage: 'dev',
+            });
+
+            expect(mockProcessRepository.create).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    context: expect.objectContaining({
+                        dbType: 'mongodb',
+                        stage: 'dev',
+                    }),
+                })
+            );
+        });
+
+        it('should throw ValidationError if userId is missing', async () => {
+            await expect(
+                useCase.execute({
+                    dbType: 'postgresql',
+                    stage: 'production',
+                })
+            ).rejects.toThrow(ValidationError);
+
+            await expect(
+                useCase.execute({
+                    dbType: 'postgresql',
+                    stage: 'production',
+                })
+            ).rejects.toThrow('userId is required');
+        });
+
+        it('should throw ValidationError if userId is not a string', async () => {
+            await expect(
+                useCase.execute({
+                    userId: 123,
+                    dbType: 'postgresql',
+                    stage: 'production',
+                })
+            ).rejects.toThrow('userId must be a string');
+        });
+
+        it('should throw ValidationError if dbType is missing', async () => {
+            await expect(
+                useCase.execute({
+                    userId: 'user-456',
+                    stage: 'production',
+                })
+            ).rejects.toThrow('dbType is required');
+        });
+
+        it('should throw ValidationError if dbType is invalid', async () => {
+            await expect(
+                useCase.execute({
+                    userId: 'user-456',
+                    dbType: 'mysql',
+                    stage: 'production',
+                })
+            ).rejects.toThrow('Invalid dbType: "mysql"');
+        });
+
+        it('should throw ValidationError if stage is missing', async () => {
+            await expect(
+                useCase.execute({
+                    userId: 'user-456',
+                    dbType: 'postgresql',
+                })
+            ).rejects.toThrow('stage is required');
+        });
+
+        it('should throw ValidationError if stage is not a string', async () => {
+            await expect(
+                useCase.execute({
+                    userId: 'user-456',
+                    dbType: 'postgresql',
+                    stage: 123,
+                })
+            ).rejects.toThrow('stage must be a string');
+        });
+
+        it('should throw error if DB_MIGRATION_QUEUE_URL not set', async () => {
+            delete process.env.DB_MIGRATION_QUEUE_URL;
+
+            await expect(
+                useCase.execute({
+                    userId: 'user-456',
+                    dbType: 'postgresql',
+                    stage: 'production',
+                })
+            ).rejects.toThrow('DB_MIGRATION_QUEUE_URL environment variable is not set');
+        });
+
+        it('should update process to FAILED if queue send fails', async () => {
+            mockQueuerUtil.send.mockRejectedValue(new Error('SQS unavailable'));
+
+            await expect(
+                useCase.execute({
+                    userId: 'user-456',
+                    dbType: 'postgresql',
+                    stage: 'production',
+                })
+            ).rejects.toThrow('Failed to queue migration: SQS unavailable');
+
+            // Verify process was marked as failed
+            expect(mockProcessRepository.updateState).toHaveBeenCalledWith(
+                'process-123',
+                'FAILED',
+                {
+                    error: 'Failed to queue migration job',
+                    errorDetails: 'SQS unavailable',
+                }
+            );
+        });
+
+        it('should handle process creation failure', async () => {
+            mockProcessRepository.create.mockRejectedValue(new Error('Database error'));
+
+            await expect(
+                useCase.execute({
+                    userId: 'user-456',
+                    dbType: 'postgresql',
+                    stage: 'production',
+                })
+            ).rejects.toThrow('Database error');
+
+            // Should not attempt to send to queue if process creation fails
+            expect(mockQueuerUtil.send).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('ValidationError', () => {
+        it('should have correct name', () => {
+            const error = new ValidationError('test message');
+            expect(error.name).toBe('ValidationError');
+            expect(error.message).toBe('test message');
+            expect(error instanceof Error).toBe(true);
+        });
+    });
+});
+

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.461.2ca8c89.0",
+    "version": "2.0.0--canary.461.4f3c330.0",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
@@ -37,9 +37,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.461.2ca8c89.0",
-        "@friggframework/prettier-config": "2.0.0--canary.461.2ca8c89.0",
-        "@friggframework/test": "2.0.0--canary.461.2ca8c89.0",
+        "@friggframework/eslint-config": "2.0.0--canary.461.4f3c330.0",
+        "@friggframework/prettier-config": "2.0.0--canary.461.4f3c330.0",
+        "@friggframework/test": "2.0.0--canary.461.4f3c330.0",
         "@prisma/client": "^6.17.0",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -79,5 +79,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "2ca8c892d55c02f9040a052d8d077f6f2459e802"
+    "gitHead": "4f3c33010ab48c11f66a630ea72f75afc2e21762"
 }

package/handlers/workers/db-migration.test.js

@@ -1,437 +0,0 @@
-/**
- * Unit tests for Database Migration Lambda Handler
- *
- * Tests the db-migration Lambda handler which runs Prisma migrations
- * from within the VPC for CI/CD pipelines.
- */
-
-// Mock the use case module before requiring the handler
-jest.mock('../../database/use-cases/run-database-migration-use-case', () => {
-    const mockExecute = jest.fn();
-    return {
-        RunDatabaseMigrationUseCase: jest.fn().mockImplementation(() => ({
-            execute: mockExecute,
-        })),
-        MigrationError: class MigrationError extends Error {
-            constructor(message, context) {
-                super(message);
-                this.name = 'MigrationError';
-                this.context = context;
-            }
-        },
-        ValidationError: class ValidationError extends Error {
-            constructor(message) {
-                super(message);
-                this.name = 'ValidationError';
-            }
-        },
-        __mockExecute: mockExecute, // Expose for test access
-    };
-});
-
-const { handler } = require('./db-migration');
-const {
-    RunDatabaseMigrationUseCase,
-    MigrationError,
-    ValidationError,
-    __mockExecute: mockExecute,
-} = require('../../database/use-cases/run-database-migration-use-case');
-
-describe('db-migration Lambda Handler', () => {
-    let originalEnv;
-    let mockContext;
-
-    beforeEach(() => {
-        // Save original environment
-        originalEnv = { ...process.env };
-
-        // Setup mock context
-        mockContext = {
-            requestId: 'test-request-id',
-            functionName: 'test-function',
-            getRemainingTimeInMillis: jest.fn(() => 300000), // 5 minutes
-        };
-
-        // Reset all mocks
-        jest.clearAllMocks();
-
-        // Set default environment variables
-        process.env.DATABASE_URL = 'postgresql://user:pass@localhost:5432/test_db';
-        process.env.DB_TYPE = 'postgresql';
-        process.env.STAGE = 'production';
-
-        // Setup default mock implementation - successful migration
-        mockExecute.mockResolvedValue({
-            success: true,
-            dbType: 'postgresql',
-            stage: 'production',
-            command: 'deploy',
-            message: 'Database migration completed successfully',
-        });
-    });
-
-    afterEach(() => {
-        // Restore original environment
-        process.env = originalEnv;
-    });
-
-    describe('Successful Migrations', () => {
-        test('should successfully run PostgreSQL migration in production', async () => {
-            process.env.STAGE = 'production';
-            mockExecute.mockResolvedValue({
-                success: true,
-                dbType: 'postgresql',
-                stage: 'production',
-                command: 'deploy',
-                message: 'Database migration completed successfully',
-            });
-
-            const result = await handler({}, mockContext);
-
-            expect(result.statusCode).toBe(200);
-            const body = JSON.parse(result.body);
-            expect(body.success).toBe(true);
-            expect(body.message).toBe('Database migration completed successfully');
-            expect(body.dbType).toBe('postgresql');
-            expect(body.stage).toBe('production');
-            expect(body.migrationCommand).toBe('deploy');
-
-            // Verify use case was called with correct parameters
-            expect(mockExecute).toHaveBeenCalledWith({
-                dbType: 'postgresql',
-                stage: 'production',
-                verbose: true,
-            });
-        });
-
-        test('should successfully run PostgreSQL migration in development', async () => {
-            process.env.STAGE = 'dev';
-            mockExecute.mockResolvedValue({
-                success: true,
-                dbType: 'postgresql',
-                stage: 'dev',
-                command: 'dev',
-                message: 'Database migration completed successfully',
-            });
-
-            const result = await handler({}, mockContext);
-
-            expect(result.statusCode).toBe(200);
-            const body = JSON.parse(result.body);
-            expect(body.success).toBe(true);
-            expect(body.migrationCommand).toBe('dev');
-
-            expect(mockExecute).toHaveBeenCalledWith({
-                dbType: 'postgresql',
-                stage: 'dev',
-                verbose: true,
-            });
-        });
-
-        test('should successfully run MongoDB migration', async () => {
-            process.env.DB_TYPE = 'mongodb';
-            process.env.DATABASE_URL = 'mongodb://localhost:27017/test_db';
-            mockExecute.mockResolvedValue({
-                success: true,
-                dbType: 'mongodb',
-                stage: 'production',
-                command: 'db push',
-                message: 'Database migration completed successfully',
-            });
-
-            const result = await handler({}, mockContext);
-
-            expect(result.statusCode).toBe(200);
-            const body = JSON.parse(result.body);
-            expect(body.success).toBe(true);
-            expect(body.dbType).toBe('mongodb');
-            expect(body.migrationCommand).toBe('db push');
-
-            expect(mockExecute).toHaveBeenCalledWith({
-                dbType: 'mongodb',
-                stage: 'production',
-                verbose: true,
-            });
-        });
-
-        test('should use default values when environment variables are missing', async () => {
-            delete process.env.DB_TYPE;
-            delete process.env.STAGE;
-            mockExecute.mockResolvedValue({
-                success: true,
-                dbType: 'postgresql',
-                stage: 'production',
-                command: 'deploy',
-                message: 'Database migration completed successfully',
-            });
-
-            const result = await handler({}, mockContext);
-
-            expect(result.statusCode).toBe(200);
-            const body = JSON.parse(result.body);
-            expect(body.dbType).toBe('postgresql'); // Default
-            expect(body.stage).toBe('production'); // Default
-
-            expect(mockExecute).toHaveBeenCalledWith({
-                dbType: 'postgresql', // Default
-                stage: 'production',  // Default
-                verbose: true,
-            });
-        });
-    });
-
-    describe('Error Handling', () => {
-        test('should fail when DATABASE_URL is not set', async () => {
-            delete process.env.DATABASE_URL;
-
-            const result = await handler({}, mockContext);
-
-            expect(result.statusCode).toBe(500);
-            const body = JSON.parse(result.body);
-            expect(body.success).toBe(false);
-            expect(body.error).toContain('DATABASE_URL environment variable is not set');
-
-            // Verify use case was not called
-            expect(mockExecute).not.toHaveBeenCalled();
-        });
-
-        test('should fail when Prisma generate fails (MigrationError)', async () => {
-            mockExecute.mockRejectedValue(
-                new MigrationError('Failed to generate Prisma client: Schema file not found', {
-                    dbType: 'postgresql',
-                    stage: 'production',
-                    step: 'generate',
-                })
-            );
-
-            const result = await handler({}, mockContext);
-
-            expect(result.statusCode).toBe(500);
-            const body = JSON.parse(result.body);
-            expect(body.success).toBe(false);
-            expect(body.error).toContain('Failed to generate Prisma client');
-            expect(body.error).toContain('Schema file not found');
-            expect(body.errorType).toBe('MigrationError');
-        });
-
-        test('should fail when PostgreSQL migration fails', async () => {
-            mockExecute.mockRejectedValue(
-                new MigrationError('PostgreSQL migration failed: Migration conflict detected', {
-                    dbType: 'postgresql',
-                    stage: 'production',
-                    command: 'deploy',
-                    step: 'migrate',
-                })
-            );
-
-            const result = await handler({}, mockContext);
-
-            expect(result.statusCode).toBe(500);
-            const body = JSON.parse(result.body);
-            expect(body.success).toBe(false);
-            expect(body.error).toContain('PostgreSQL migration failed');
-            expect(body.error).toContain('Migration conflict detected');
-            expect(body.errorType).toBe('MigrationError');
-        });
-
-        test('should fail when MongoDB push fails', async () => {
-            process.env.DB_TYPE = 'mongodb';
-            mockExecute.mockRejectedValue(
-                new MigrationError('MongoDB push failed: Connection timeout', {
-                    dbType: 'mongodb',
-                    stage: 'production',
-                    command: 'db push',
-                    step: 'push',
-                })
-            );
-
-            const result = await handler({}, mockContext);
-
-            expect(result.statusCode).toBe(500);
-            const body = JSON.parse(result.body);
-            expect(body.success).toBe(false);
-            expect(body.error).toContain('MongoDB push failed');
-            expect(body.error).toContain('Connection timeout');
-            expect(body.errorType).toBe('MigrationError');
-        });
-
-        test('should fail for unsupported database type (ValidationError)', async () => {
-            process.env.DB_TYPE = 'mysql';
-            mockExecute.mockRejectedValue(
-                new ValidationError("Unsupported database type: mysql. Must be 'postgresql' or 'mongodb'.")
-            );
-
-            const result = await handler({}, mockContext);
-
-            expect(result.statusCode).toBe(400); // Validation errors return 400
-            const body = JSON.parse(result.body);
-            expect(body.success).toBe(false);
-            expect(body.error).toContain('Unsupported database type: mysql');
-            expect(body.errorType).toBe('ValidationError');
-        });
-
-        test('should handle unexpected errors gracefully', async () => {
-            mockExecute.mockRejectedValue(new Error('Unexpected error'));
-
-            const result = await handler({}, mockContext);
-
-            expect(result.statusCode).toBe(500);
-            const body = JSON.parse(result.body);
-            expect(body.success).toBe(false);
-            expect(body.error).toContain('Unexpected error');
-            expect(body.errorType).toBe('Error');
-            expect(body.stack).toBeUndefined(); // Stack NOT included in production (default stage)
-        });
-
-        test('should sanitize error messages containing credentials', async () => {
-            mockExecute.mockRejectedValue(
-                new MigrationError(
-                    'Connection failed to postgresql://user:password@host:5432/db',
-                    { dbType: 'postgresql', stage: 'production' }
-                )
-            );
-
-            const result = await handler({}, mockContext);
-
-            expect(result.statusCode).toBe(500);
-            const body = JSON.parse(result.body);
-            expect(body.success).toBe(false);
-            // Credentials should be sanitized
-            expect(body.error).toContain('postgresql://***:***@***');
-            expect(body.error).not.toContain('user:password');
-        });
-
-        test('should only include stack traces in development stages', async () => {
-            process.env.STAGE = 'dev';
-            mockExecute.mockRejectedValue(new Error('Test error'));
-
-            const result = await handler({}, mockContext);
-
-            const body = JSON.parse(result.body);
-            expect(body.stack).toBeDefined();
-        });
-
-        test('should not include stack traces in production stage', async () => {
-            process.env.STAGE = 'production';
-            mockExecute.mockRejectedValue(new Error('Test error'));
-
-            const result = await handler({}, mockContext);
-
-            const body = JSON.parse(result.body);
-            expect(body.stack).toBeUndefined();
-        });
-    });
-
-    describe('Environment Variable Handling', () => {
-        test('should sanitize DATABASE_URL in logs', async () => {
-            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-            process.env.DATABASE_URL = 'postgresql://user:password@very-long-host.amazonaws.com:5432/database';
-
-            await handler({}, mockContext);
-
-            // Verify URL credentials are masked in logs
-            expect(consoleSpy).toHaveBeenCalledWith(
-                expect.stringContaining('postgresql://***:***@')
-            );
-            expect(consoleSpy).not.toHaveBeenCalledWith(
-                expect.stringContaining('user:password')
-            );
-
-            consoleSpy.mockRestore();
-        });
-
-        test('should handle different stage values correctly', async () => {
-            const stages = ['dev', 'test', 'local', 'staging', 'production'];
-
-            for (const stage of stages) {
-                process.env.STAGE = stage;
-                const command = ['dev', 'test', 'local'].includes(stage) ? 'dev' : 'deploy';
-
-                jest.clearAllMocks();
-                mockExecute.mockResolvedValue({
-                    success: true,
-                    dbType: 'postgresql',
-                    stage,
-                    command,
-                    message: 'Database migration completed successfully',
-                });
-
-                const result = await handler({}, mockContext);
-
-                expect(result.statusCode).toBe(200);
-                const body = JSON.parse(result.body);
-                expect(body.stage).toBe(stage);
-                expect(mockExecute).toHaveBeenCalledWith({
-                    dbType: 'postgresql',
-                    stage,
-                    verbose: true,
-                });
-            }
-        });
-    });
-
-    describe('Response Format', () => {
-        test('should return properly formatted success response', async () => {
-            const result = await handler({}, mockContext);
-
-            expect(result).toHaveProperty('statusCode', 200);
-            expect(result).toHaveProperty('body');
-
-            const body = JSON.parse(result.body);
-            expect(body).toHaveProperty('success', true);
-            expect(body).toHaveProperty('message');
-            expect(body).toHaveProperty('dbType');
-            expect(body).toHaveProperty('stage');
-            expect(body).toHaveProperty('migrationCommand');
-            expect(body).toHaveProperty('timestamp');
-
-            // Verify timestamp is valid ISO string
-            expect(() => new Date(body.timestamp)).not.toThrow();
-        });
-
-        test('should return properly formatted error response', async () => {
-            delete process.env.DATABASE_URL;
-
-            const result = await handler({}, mockContext);
-
-            expect(result).toHaveProperty('statusCode', 500);
-            expect(result).toHaveProperty('body');
-
-            const body = JSON.parse(result.body);
-            expect(body).toHaveProperty('success', false);
-            expect(body).toHaveProperty('error');
-            expect(typeof body.error).toBe('string');
-        });
-    });
-
-    describe('Logging', () => {
-        test('should log migration progress', async () => {
-            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-
-            await handler({}, mockContext);
-
-            // Verify key log messages
-            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Database Migration Lambda Started'));
-            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Executing Database Migration'));
-            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Migration Summary'));
-
-            consoleSpy.mockRestore();
-        });
-
-        test('should log errors with details', async () => {
-            const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
-            const testError = new MigrationError('Test migration error', {
-                dbType: 'postgresql',
-                stage: 'production',
-            });
-            mockExecute.mockRejectedValue(testError);
-
-            await handler({}, mockContext);
-
-            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Migration Failed'));
-            expect(consoleSpy).toHaveBeenCalledWith('Error:', 'MigrationError', 'Test migration error');
-
-            consoleSpy.mockRestore();
-        });
-    });
-});