@friggframework/core 2.0.0--canary.461.61382d8.0 → 2.0.0--canary.461.3d6d8ad.0

package/database/use-cases/check-encryption-health-use-case.test.js

@@ -1,192 +0,0 @@
-/**
- * Tests for CheckEncryptionHealthUseCase
- * 
- * Tests encryption configuration detection and health checking
- */
-
-const { CheckEncryptionHealthUseCase } = require('./check-encryption-health-use-case');
-
-describe('CheckEncryptionHealthUseCase', () => {
-    let originalEnv;
-
-    beforeEach(() => {
-        // Save original env
-        originalEnv = { ...process.env };
-    });
-
-    afterEach(() => {
-        // Restore original env
-        process.env = originalEnv;
-    });
-
-    describe('_getEncryptionConfiguration()', () => {
-        it('should prefer KMS over AES when both are configured', async () => {
-            process.env.STAGE = 'production';
-            process.env.KMS_KEY_ARN = 'arn:aws:kms:us-east-1:123:key/abc';
-            process.env.AES_KEY_ID = 'aes-key-123';
-            process.env.AES_KEY = 'some-aes-key';
-
-            const mockTestEncryption = {
-                execute: jest.fn().mockResolvedValue({ success: true }),
-            };
-
-            const useCase = new CheckEncryptionHealthUseCase({
-                testEncryptionUseCase: mockTestEncryption,
-            });
-
-            const result = await useCase.execute();
-
-            expect(result.mode).toBe('kms'); // KMS should be preferred over AES
-            expect(result.debug.hasKMS).toBe(true);
-            expect(result.debug.hasAES).toBe(true);
-        });
-
-        it('should use AES when only AES is configured', async () => {
-            process.env.STAGE = 'production';
-            process.env.AES_KEY_ID = 'aes-key-123';
-            process.env.AES_KEY = 'some-aes-key';
-            delete process.env.KMS_KEY_ARN;
-
-            const mockTestEncryption = {
-                execute: jest.fn().mockResolvedValue({ status: 'healthy', encryptionWorks: true }),
-            };
-
-            const useCase = new CheckEncryptionHealthUseCase({
-                testEncryptionUseCase: mockTestEncryption,
-            });
-
-            const result = await useCase.execute();
-
-            expect(result.mode).toBe('aes');
-            expect(result.status).toBe('healthy');
-            expect(result.encryptionWorks).toBe(true);
-        });
-
-        it('should use KMS when only KMS is configured', async () => {
-            process.env.STAGE = 'production';
-            process.env.KMS_KEY_ARN = 'arn:aws:kms:us-east-1:123:key/abc';
-            delete process.env.AES_KEY_ID;
-            delete process.env.AES_KEY;
-
-            const mockTestEncryption = {
-                execute: jest.fn().mockResolvedValue({ status: 'healthy', encryptionWorks: true }),
-            };
-
-            const useCase = new CheckEncryptionHealthUseCase({
-                testEncryptionUseCase: mockTestEncryption,
-            });
-
-            const result = await useCase.execute();
-
-            expect(result.mode).toBe('kms');
-            expect(result.status).toBe('healthy');
-            expect(result.encryptionWorks).toBe(true);
-        });
-
-        it('should bypass encryption for dev stage', async () => {
-            process.env.STAGE = 'dev';
-            process.env.KMS_KEY_ARN = 'arn:aws:kms:us-east-1:123:key/abc';
-
-            const useCase = new CheckEncryptionHealthUseCase({
-                testEncryptionUseCase: { execute: jest.fn() },
-            });
-
-            const result = await useCase.execute();
-
-            expect(result.bypassed).toBe(true);
-            expect(result.stage).toBe('dev');
-        });
-
-        it('should not bypass encryption for production stage', async () => {
-            process.env.STAGE = 'production';
-            process.env.KMS_KEY_ARN = 'arn:aws:kms:us-east-1:123:key/abc';
-
-            const mockTestEncryption = {
-                execute: jest.fn().mockResolvedValue({ success: true }),
-            };
-
-            const useCase = new CheckEncryptionHealthUseCase({
-                testEncryptionUseCase: mockTestEncryption,
-            });
-
-            const result = await useCase.execute();
-
-            expect(result.bypassed).toBe(false);
-            expect(result.stage).toBe('production');
-        });
-
-        it('should use qa stage correctly (not in bypass list)', async () => {
-            process.env.STAGE = 'qa';
-            process.env.KMS_KEY_ARN = 'arn:aws:kms:us-east-1:123:key/abc';
-
-            const mockTestEncryption = {
-                execute: jest.fn().mockResolvedValue({ success: true }),
-            };
-
-            const useCase = new CheckEncryptionHealthUseCase({
-                testEncryptionUseCase: mockTestEncryption,
-            });
-
-            const result = await useCase.execute();
-
-            expect(result.bypassed).toBe(false);
-            expect(result.stage).toBe('qa');
-            expect(result.mode).toBe('kms');
-        });
-
-        it('should return mode none when no encryption keys configured', async () => {
-            process.env.STAGE = 'production';
-            delete process.env.KMS_KEY_ARN;
-            delete process.env.AES_KEY_ID;
-            delete process.env.AES_KEY;
-
-            const useCase = new CheckEncryptionHealthUseCase({
-                testEncryptionUseCase: { execute: jest.fn() },
-            });
-
-            const result = await useCase.execute();
-
-            expect(result.status).toBe('disabled');
-            expect(result.mode).toBe('none');
-            expect(result.bypassed).toBe(false);
-            expect(result.testResult).toBe('No encryption keys configured');
-        });
-    });
-
-    describe('execute() - bypass scenarios', () => {
-        it('should return disabled status when encryption is bypassed', async () => {
-            process.env.STAGE = 'dev';
-            process.env.KMS_KEY_ARN = 'arn:aws:kms:us-east-1:123:key/abc';
-
-            const useCase = new CheckEncryptionHealthUseCase({
-                testEncryptionUseCase: { execute: jest.fn() },
-            });
-
-            const result = await useCase.execute();
-
-            expect(result.status).toBe('disabled');
-            expect(result.bypassed).toBe(true);
-            expect(result.stage).toBe('dev');
-            expect(result.testResult).toBe('Encryption bypassed for this stage');
-            expect(result.encryptionWorks).toBe(false);
-        });
-
-        it('should return disabled status when no encryption keys configured', async () => {
-            process.env.STAGE = 'production';
-            delete process.env.KMS_KEY_ARN;
-            delete process.env.AES_KEY_ID;
-
-            const useCase = new CheckEncryptionHealthUseCase({
-                testEncryptionUseCase: { execute: jest.fn() },
-            });
-
-            const result = await useCase.execute();
-
-            expect(result.status).toBe('disabled');
-            expect(result.bypassed).toBe(false);
-            expect(result.mode).toBe('none');
-            expect(result.testResult).toBe('No encryption keys configured');
-        });
-    });
-});
-

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

@@ -1,171 +0,0 @@
-/**
- * Tests for GetMigrationStatusUseCase
- */
-
-const {
-    GetMigrationStatusUseCase,
-    ValidationError,
-    NotFoundError,
-} = require('./get-migration-status-use-case');
-
-describe('GetMigrationStatusUseCase', () => {
-    let useCase;
-    let mockMigrationStatusRepository;
-
-    beforeEach(() => {
-        // Create mock repository
-        mockMigrationStatusRepository = {
-            get: jest.fn(),
-        };
-
-        // Create use case with mock
-        useCase = new GetMigrationStatusUseCase({
-            migrationStatusRepository: mockMigrationStatusRepository,
-        });
-    });
-
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-
-    describe('constructor', () => {
-        it('should throw error if migrationStatusRepository not provided', () => {
-            expect(() => {
-                new GetMigrationStatusUseCase({});
-            }).toThrow('migrationStatusRepository 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'),
-            };
-
-            mockMigrationStatusRepository.get.mockResolvedValue(mockProcess);
-
-            const result = await useCase.execute('migration-123', 'production');
-
-            expect(mockMigrationStatusRepository.get).toHaveBeenCalledWith('migration-123', 'production');
-            expect(result).toEqual(mockProcess); // S3 repository returns full status object
-        });
-
-        it('should return migration status for RUNNING migration', async () => {
-            const mockProcess = {
-                migrationId: 'migration-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'),
-            };
-
-            mockMigrationStatusRepository.get.mockResolvedValue(mockProcess);
-
-            const result = await useCase.execute('migration-456', 'dev');
-
-            expect(result.state).toBe('RUNNING');
-            expect(result.context.dbType).toBe('mongodb');
-        });
-
-        it('should return migration status for FAILED migration', async () => {
-            const mockStatus = {
-                migrationId: 'migration-789',
-                stage: 'production',
-                state: 'FAILED',
-                progress: 0,
-                error: 'Migration failed: syntax error',
-                triggeredBy: 'admin',
-                triggeredAt: '2025-10-18T10:29:55Z',
-                completedAt: '2025-10-18T10:30:00Z',
-            };
-
-            mockMigrationStatusRepository.get.mockResolvedValue(mockStatus);
-
-            const result = await useCase.execute('migration-789', 'production');
-
-            expect(mockMigrationStatusRepository.get).toHaveBeenCalledWith('migration-789', 'production');
-            expect(result.state).toBe('FAILED');
-            expect(result.error).toContain('Migration failed');
-        });
-
-        // Removed - already covered by "should return minimal migration status"
-
-        it('should throw NotFoundError if migration does not exist', async () => {
-            mockMigrationStatusRepository.get.mockRejectedValue(new Error('Migration not found: nonexistent-123'));
-
-            await expect(
-                useCase.execute('nonexistent-123', 'dev')
-            ).rejects.toThrow(NotFoundError);
-
-            await expect(
-                useCase.execute('nonexistent-123', 'dev')
-            ).rejects.toThrow('Migration not found');
-        });
-
-        // Removed: S3 repository only stores migrations, no type validation needed
-
-        it('should throw ValidationError if migrationId is missing', async () => {
-            await expect(
-                useCase.execute(null)
-            ).rejects.toThrow(ValidationError);
-
-            await expect(
-                useCase.execute(undefined)
-            ).rejects.toThrow('migrationId is required');
-        });
-
-        it('should throw ValidationError if migrationId is not a string', async () => {
-            await expect(
-                useCase.execute(123)
-            ).rejects.toThrow('migrationId must be a string');
-        });
-
-        it('should handle repository errors', async () => {
-            mockMigrationStatusRepository.get.mockRejectedValue(new Error('S3 connection failed'));
-
-            await expect(
-                useCase.execute('migration-123', 'dev')
-            ).rejects.toThrow('S3 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/run-database-migration-use-case.test.js

@@ -1,310 +0,0 @@
-/**
- * Tests for Run Database Migration Use Case
- */
-
-const {
-    RunDatabaseMigrationUseCase,
-    MigrationError,
-    ValidationError,
-} = require('./run-database-migration-use-case');
-
-describe('RunDatabaseMigrationUseCase', () => {
-    let useCase;
-    let mockPrismaRunner;
-
-    beforeEach(() => {
-        // Mock prisma runner with all required methods
-        mockPrismaRunner = {
-            runPrismaGenerate: jest.fn(),
-            runPrismaMigrate: jest.fn(),
-            runPrismaDbPush: jest.fn(),
-            getMigrationCommand: jest.fn(),
-        };
-
-        useCase = new RunDatabaseMigrationUseCase({ prismaRunner: mockPrismaRunner });
-    });
-
-    describe('Constructor', () => {
-        it('should throw error if prismaRunner is not provided', () => {
-            expect(() => new RunDatabaseMigrationUseCase({})).toThrow('prismaRunner dependency is required');
-        });
-
-        it('should create instance with valid dependencies', () => {
-            expect(useCase).toBeInstanceOf(RunDatabaseMigrationUseCase);
-            expect(useCase.prismaRunner).toBe(mockPrismaRunner);
-        });
-    });
-
-    describe('Parameter Validation', () => {
-        it('should throw ValidationError if dbType is missing', async () => {
-            await expect(useCase.execute({ stage: 'production' })).rejects.toThrow(ValidationError);
-            await expect(useCase.execute({ stage: 'production' })).rejects.toThrow('dbType is required');
-        });
-
-        it('should throw ValidationError if dbType is not a string', async () => {
-            await expect(useCase.execute({ dbType: 123, stage: 'production' })).rejects.toThrow(ValidationError);
-            await expect(useCase.execute({ dbType: 123, stage: 'production' })).rejects.toThrow(
-                'dbType must be a string'
-            );
-        });
-
-        it('should throw ValidationError if stage is missing', async () => {
-            await expect(useCase.execute({ dbType: 'postgresql' })).rejects.toThrow(ValidationError);
-            await expect(useCase.execute({ dbType: 'postgresql' })).rejects.toThrow('stage is required');
-        });
-
-        it('should throw ValidationError if stage is not a string', async () => {
-            await expect(useCase.execute({ dbType: 'postgresql', stage: 123 })).rejects.toThrow(ValidationError);
-            await expect(useCase.execute({ dbType: 'postgresql', stage: 123 })).rejects.toThrow(
-                'stage must be a string'
-            );
-        });
-    });
-
-    describe('PostgreSQL Migrations', () => {
-        beforeEach(() => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({ success: true });
-            mockPrismaRunner.runPrismaMigrate.mockResolvedValue({ success: true });
-        });
-
-        it('should successfully run PostgreSQL production migration', async () => {
-            mockPrismaRunner.getMigrationCommand.mockReturnValue('deploy');
-
-            const result = await useCase.execute({
-                dbType: 'postgresql',
-                stage: 'production',
-                verbose: true,
-            });
-
-            expect(result).toEqual({
-                success: true,
-                dbType: 'postgresql',
-                stage: 'production',
-                command: 'deploy',
-                message: 'Database migration completed successfully',
-            });
-
-            expect(mockPrismaRunner.runPrismaGenerate).toHaveBeenCalledWith('postgresql', true);
-            expect(mockPrismaRunner.getMigrationCommand).toHaveBeenCalledWith('production');
-            expect(mockPrismaRunner.runPrismaMigrate).toHaveBeenCalledWith('deploy', true);
-            expect(mockPrismaRunner.runPrismaDbPush).not.toHaveBeenCalled();
-        });
-
-        it('should successfully run PostgreSQL development migration', async () => {
-            mockPrismaRunner.getMigrationCommand.mockReturnValue('dev');
-
-            const result = await useCase.execute({
-                dbType: 'postgresql',
-                stage: 'dev',
-            });
-
-            expect(result.success).toBe(true);
-            expect(result.command).toBe('dev');
-            expect(mockPrismaRunner.getMigrationCommand).toHaveBeenCalledWith('dev');
-            expect(mockPrismaRunner.runPrismaMigrate).toHaveBeenCalledWith('dev', false);
-        });
-
-        it('should throw MigrationError if Prisma generate fails', async () => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({
-                success: false,
-                error: 'Schema file not found',
-                output: 'Error output',
-            });
-
-            await expect(
-                useCase.execute({ dbType: 'postgresql', stage: 'production' })
-            ).rejects.toThrow(MigrationError);
-
-            await expect(
-                useCase.execute({ dbType: 'postgresql', stage: 'production' })
-            ).rejects.toThrow('Failed to generate Prisma client: Schema file not found');
-
-            expect(mockPrismaRunner.runPrismaMigrate).not.toHaveBeenCalled();
-        });
-
-        it('should throw MigrationError if PostgreSQL migration fails', async () => {
-            mockPrismaRunner.getMigrationCommand.mockReturnValue('deploy');
-            mockPrismaRunner.runPrismaMigrate.mockResolvedValue({
-                success: false,
-                error: 'Migration conflict detected',
-                output: 'Conflict output',
-            });
-
-            await expect(
-                useCase.execute({ dbType: 'postgresql', stage: 'production' })
-            ).rejects.toThrow(MigrationError);
-
-            await expect(
-                useCase.execute({ dbType: 'postgresql', stage: 'production' })
-            ).rejects.toThrow('PostgreSQL migration failed: Migration conflict detected');
-        });
-
-        it('should include context in MigrationError', async () => {
-            mockPrismaRunner.getMigrationCommand.mockReturnValue('deploy');
-            mockPrismaRunner.runPrismaMigrate.mockResolvedValue({
-                success: false,
-                error: 'Migration failed',
-                output: 'Error output',
-            });
-
-            try {
-                await useCase.execute({ dbType: 'postgresql', stage: 'production' });
-                fail('Should have thrown MigrationError');
-            } catch (error) {
-                expect(error).toBeInstanceOf(MigrationError);
-                expect(error.context).toEqual({
-                    dbType: 'postgresql',
-                    stage: 'production',
-                    command: 'deploy',
-                    step: 'migrate',
-                    output: 'Error output',
-                });
-            }
-        });
-    });
-
-    describe('MongoDB Migrations', () => {
-        beforeEach(() => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({ success: true });
-            mockPrismaRunner.runPrismaDbPush.mockResolvedValue({ success: true });
-        });
-
-        it('should successfully run MongoDB migration', async () => {
-            const result = await useCase.execute({
-                dbType: 'mongodb',
-                stage: 'production',
-                verbose: true,
-            });
-
-            expect(result).toEqual({
-                success: true,
-                dbType: 'mongodb',
-                stage: 'production',
-                command: 'db push',
-                message: 'Database migration completed successfully',
-            });
-
-            expect(mockPrismaRunner.runPrismaGenerate).toHaveBeenCalledWith('mongodb', true);
-            expect(mockPrismaRunner.runPrismaDbPush).toHaveBeenCalledWith(true, true); // verbose=true, nonInteractive=true
-            expect(mockPrismaRunner.runPrismaMigrate).not.toHaveBeenCalled();
-        });
-
-        it('should use non-interactive mode for MongoDB', async () => {
-            await useCase.execute({
-                dbType: 'mongodb',
-                stage: 'production',
-            });
-
-            // Second parameter should be true for non-interactive
-            expect(mockPrismaRunner.runPrismaDbPush).toHaveBeenCalledWith(false, true);
-        });
-
-        it('should throw MigrationError if MongoDB push fails', async () => {
-            mockPrismaRunner.runPrismaDbPush.mockResolvedValue({
-                success: false,
-                error: 'Connection timeout',
-            });
-
-            await expect(useCase.execute({ dbType: 'mongodb', stage: 'production' })).rejects.toThrow(
-                MigrationError
-            );
-
-            await expect(useCase.execute({ dbType: 'mongodb', stage: 'production' })).rejects.toThrow(
-                'MongoDB push failed: Connection timeout'
-            );
-        });
-    });
-
-    describe('Unsupported Database Types', () => {
-        beforeEach(() => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({ success: true });
-        });
-
-        it('should throw ValidationError for unsupported database type', async () => {
-            await expect(useCase.execute({ dbType: 'mysql', stage: 'production' })).rejects.toThrow(
-                ValidationError
-            );
-
-            await expect(useCase.execute({ dbType: 'mysql', stage: 'production' })).rejects.toThrow(
-                "Unsupported database type: mysql. Must be 'postgresql' or 'mongodb'."
-            );
-        });
-
-        it('should run Prisma generate before checking database type', async () => {
-            try {
-                await useCase.execute({ dbType: 'mysql', stage: 'production' });
-            } catch (error) {
-                // Expected error
-            }
-
-            expect(mockPrismaRunner.runPrismaGenerate).toHaveBeenCalledWith('mysql', false);
-        });
-    });
-
-    describe('Error Handling', () => {
-        it('should handle undefined error from Prisma generate', async () => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({
-                success: false,
-                error: undefined,
-            });
-
-            await expect(useCase.execute({ dbType: 'postgresql', stage: 'production' })).rejects.toThrow(
-                'Failed to generate Prisma client: Unknown error'
-            );
-        });
-
-        it('should handle undefined error from PostgreSQL migration', async () => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({ success: true });
-            mockPrismaRunner.getMigrationCommand.mockReturnValue('deploy');
-            mockPrismaRunner.runPrismaMigrate.mockResolvedValue({
-                success: false,
-                error: undefined,
-            });
-
-            await expect(useCase.execute({ dbType: 'postgresql', stage: 'production' })).rejects.toThrow(
-                'PostgreSQL migration failed: Unknown error'
-            );
-        });
-
-        it('should handle undefined error from MongoDB push', async () => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({ success: true });
-            mockPrismaRunner.runPrismaDbPush.mockResolvedValue({
-                success: false,
-                error: undefined,
-            });
-
-            await expect(useCase.execute({ dbType: 'mongodb', stage: 'production' })).rejects.toThrow(
-                'MongoDB push failed: Unknown error'
-            );
-        });
-    });
-
-    describe('Verbose Mode', () => {
-        beforeEach(() => {
-            mockPrismaRunner.runPrismaGenerate.mockResolvedValue({ success: true });
-            mockPrismaRunner.runPrismaMigrate.mockResolvedValue({ success: true });
-            mockPrismaRunner.getMigrationCommand.mockReturnValue('deploy');
-        });
-
-        it('should pass verbose flag to all Prisma operations', async () => {
-            await useCase.execute({
-                dbType: 'postgresql',
-                stage: 'production',
-                verbose: true,
-            });
-
-            expect(mockPrismaRunner.runPrismaGenerate).toHaveBeenCalledWith('postgresql', true);
-            expect(mockPrismaRunner.runPrismaMigrate).toHaveBeenCalledWith('deploy', true);
-        });
-
-        it('should default verbose to false', async () => {
-            await useCase.execute({
-                dbType: 'postgresql',
-                stage: 'production',
-            });
-
-            expect(mockPrismaRunner.runPrismaGenerate).toHaveBeenCalledWith('postgresql', false);
-            expect(mockPrismaRunner.runPrismaMigrate).toHaveBeenCalledWith('deploy', false);
-        });
-    });
-});