@friggframework/core 2.0.0--canary.454.e2a280d.0 → 2.0.0--canary.459.51231dd.0

package/database/utils/prisma-runner.test.js

@@ -1,486 +0,0 @@
-// Mock dependencies BEFORE requiring modules
-jest.mock('child_process', () => ({
-    execSync: jest.fn(),
-    spawn: jest.fn()
-}));
-jest.mock('fs', () => ({
-    existsSync: jest.fn(),
-    readFileSync: jest.fn(),
-    writeFileSync: jest.fn()
-}));
-
-const { execSync, spawn } = require('child_process');
-const fs = require('fs');
-const {
-    getPrismaSchemaPath,
-    runPrismaGenerate,
-    checkDatabaseState,
-    runPrismaMigrate,
-    runPrismaDbPush,
-    getMigrationCommand
-} = require('./prisma-runner');
-
-describe('Prisma Runner Utility', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        delete process.env.STAGE;
-        delete process.env.PRISMA_HIDE_UPDATE_MESSAGE;
-    });
-
-    afterEach(() => {
-        delete process.env.STAGE;
-        delete process.env.PRISMA_HIDE_UPDATE_MESSAGE;
-    });
-
-    describe('getPrismaSchemaPath()', () => {
-        it('should return correct path for MongoDB', () => {
-            fs.existsSync.mockReturnValue(true);
-
-            const path = getPrismaSchemaPath('mongodb');
-
-            expect(path).toContain('prisma-mongodb');
-            expect(path).toContain('schema.prisma');
-            expect(path).toContain('@friggframework/core');
-        });
-
-        it('should return correct path for PostgreSQL', () => {
-            fs.existsSync.mockReturnValue(true);
-
-            const path = getPrismaSchemaPath('postgresql');
-
-            expect(path).toContain('prisma-postgresql');
-            expect(path).toContain('schema.prisma');
-            expect(path).toContain('@friggframework/core');
-        });
-
-        it('should throw error when schema file does not exist', () => {
-            fs.existsSync.mockReturnValue(false);
-
-            expect(() => getPrismaSchemaPath('mongodb')).toThrow('Prisma schema not found');
-        });
-
-        it('should include helpful error message when schema missing', () => {
-            fs.existsSync.mockReturnValue(false);
-
-            expect(() => getPrismaSchemaPath('mongodb')).toThrow('@friggframework/core');
-        });
-
-        it('should use process.cwd() for base path', () => {
-            fs.existsSync.mockReturnValue(true);
-            const originalCwd = process.cwd();
-
-            const path = getPrismaSchemaPath('mongodb');
-
-            expect(path).toContain(originalCwd);
-        });
-
-        it('should accept custom project root', () => {
-            fs.existsSync.mockReturnValue(true);
-            const customRoot = '/custom/project';
-
-            const path = getPrismaSchemaPath('mongodb', customRoot);
-
-            expect(path).toContain(customRoot);
-        });
-    });
-
-    describe('runPrismaGenerate()', () => {
-        beforeEach(() => {
-            fs.existsSync.mockReturnValue(true);
-        });
-
-        it('should execute prisma generate successfully', async () => {
-            execSync.mockReturnValue('Generated successfully');
-
-            const result = await runPrismaGenerate('mongodb');
-
-            expect(result.success).toBe(true);
-            expect(execSync).toHaveBeenCalled();
-        });
-
-        it('should use correct schema path for MongoDB', async () => {
-            execSync.mockReturnValue('');
-
-            await runPrismaGenerate('mongodb');
-
-            const call = execSync.mock.calls[0][0];
-            expect(call).toContain('prisma generate');
-            expect(call).toContain('--schema');
-            expect(call).toContain('prisma-mongodb');
-        });
-
-        it('should use correct schema path for PostgreSQL', async () => {
-            execSync.mockReturnValue('');
-
-            await runPrismaGenerate('postgresql');
-
-            const call = execSync.mock.calls[0][0];
-            expect(call).toContain('prisma-postgresql');
-        });
-
-        it('should suppress telemetry when verbose false', async () => {
-            execSync.mockReturnValue('');
-
-            await runPrismaGenerate('mongodb', false);
-
-            const options = execSync.mock.calls[0][1];
-            expect(options.env.PRISMA_HIDE_UPDATE_MESSAGE).toBe('1');
-        });
-
-        it('should show output when verbose true', async () => {
-            execSync.mockReturnValue('Generated successfully');
-
-            await runPrismaGenerate('mongodb', true);
-
-            const options = execSync.mock.calls[0][1];
-            expect(options.stdio).toBe('inherit');
-        });
-
-        it('should hide output when verbose false', async () => {
-            execSync.mockReturnValue('');
-
-            await runPrismaGenerate('mongodb', false);
-
-            const options = execSync.mock.calls[0][1];
-            expect(options.stdio).toBe('pipe');
-        });
-
-        it('should handle generation failures with error details', async () => {
-            const error = new Error('Generation failed');
-            error.stdout = 'Schema validation error';
-            execSync.mockImplementation(() => {
-                throw error;
-            });
-
-            const result = await runPrismaGenerate('mongodb');
-
-            expect(result.success).toBe(false);
-            expect(result.error).toContain('Generation failed');
-        });
-
-        it('should include stdout in error output', async () => {
-            const error = new Error('Failed');
-            error.stdout = Buffer.from('Detailed error info');
-            execSync.mockImplementation(() => {
-                throw error;
-            });
-
-            const result = await runPrismaGenerate('mongodb');
-
-            expect(result.output).toContain('Detailed error info');
-        });
-
-        it('should handle schema syntax errors', async () => {
-            execSync.mockImplementation(() => {
-                throw new Error('Schema parsing failed');
-            });
-
-            const result = await runPrismaGenerate('mongodb');
-
-            expect(result.success).toBe(false);
-            expect(result.error).toBeDefined();
-        });
-    });
-
-    describe('checkDatabaseState()', () => {
-        beforeEach(() => {
-            fs.existsSync.mockReturnValue(true);
-        });
-
-        it('should return upToDate: true when migrations current (PostgreSQL)', async () => {
-            execSync.mockReturnValue('Database schema is up to date');
-
-            const result = await checkDatabaseState('postgresql');
-
-            expect(result.upToDate).toBe(true);
-        });
-
-        it('should return upToDate: true for MongoDB (N/A)', async () => {
-            const result = await checkDatabaseState('mongodb');
-
-            expect(result.upToDate).toBe(true);
-        });
-
-        it('should return pendingMigrations count when migrations pending', async () => {
-            execSync.mockReturnValue('3 migrations have not been applied');
-
-            const result = await checkDatabaseState('postgresql');
-
-            expect(result.upToDate).toBe(false);
-            expect(result.pendingMigrations).toBe(3);
-        });
-
-        it('should handle uninitialized database', async () => {
-            execSync.mockImplementation(() => {
-                throw new Error('No migrations found');
-            });
-
-            const result = await checkDatabaseState('postgresql');
-
-            expect(result.upToDate).toBe(false);
-            expect(result.error).toBeDefined();
-        });
-
-        it('should handle migrate status command errors', async () => {
-            execSync.mockImplementation(() => {
-                throw new Error('Migration status failed');
-            });
-
-            const result = await checkDatabaseState('postgresql');
-
-            expect(result.upToDate).toBe(false);
-            expect(result.error).toContain('Migration status failed');
-        });
-
-        it('should not run migrate status for MongoDB', async () => {
-            await checkDatabaseState('mongodb');
-
-            expect(execSync).not.toHaveBeenCalled();
-        });
-    });
-
-    describe('runPrismaMigrate()', () => {
-        let mockChildProcess;
-
-        beforeEach(() => {
-            fs.existsSync.mockReturnValue(true);
-            mockChildProcess = {
-                on: jest.fn((event, callback) => {
-                    if (event === 'close') {
-                        callback(0);
-                    }
-                }),
-                stdout: { on: jest.fn() },
-                stderr: { on: jest.fn() }
-            };
-            spawn.mockReturnValue(mockChildProcess);
-        });
-
-        it('should run migrate dev successfully', async () => {
-            const result = await runPrismaMigrate('dev');
-
-            expect(result.success).toBe(true);
-            expect(spawn).toHaveBeenCalled();
-        });
-
-        it('should run migrate deploy successfully', async () => {
-            const result = await runPrismaMigrate('deploy');
-
-            expect(result.success).toBe(true);
-            expect(spawn).toHaveBeenCalled();
-        });
-
-        it('should use correct command for dev mode', async () => {
-            await runPrismaMigrate('dev');
-
-            const args = spawn.mock.calls[0][1];
-            expect(args).toContain('migrate');
-            expect(args).toContain('dev');
-        });
-
-        it('should use correct command for deploy mode', async () => {
-            await runPrismaMigrate('deploy');
-
-            const args = spawn.mock.calls[0][1];
-            expect(args).toContain('migrate');
-            expect(args).toContain('deploy');
-        });
-
-        it('should handle migration failures with error', async () => {
-            mockChildProcess.on.mockImplementation((event, callback) => {
-                if (event === 'close') {
-                    callback(1); // Exit code 1
-                }
-            });
-
-            const result = await runPrismaMigrate('dev');
-
-            expect(result.success).toBe(false);
-            expect(result.error).toContain('exited with code 1');
-        });
-
-        it('should respect verbose flag', async () => {
-            await runPrismaMigrate('dev', true);
-
-            const options = spawn.mock.calls[0][2];
-            expect(options.stdio).toBe('inherit');
-        });
-
-        it('should handle process spawn errors', async () => {
-            mockChildProcess.on.mockImplementation((event, callback) => {
-                if (event === 'error') {
-                    callback(new Error('Spawn failed'));
-                }
-            });
-
-            const result = await runPrismaMigrate('dev');
-
-            expect(result.success).toBe(false);
-        });
-
-        it('should hide telemetry messages', async () => {
-            await runPrismaMigrate('dev');
-
-            const options = spawn.mock.calls[0][2];
-            expect(options.env.PRISMA_HIDE_UPDATE_MESSAGE).toBe('1');
-        });
-    });
-
-    describe('runPrismaDbPush()', () => {
-        let mockChildProcess;
-
-        beforeEach(() => {
-            fs.existsSync.mockReturnValue(true);
-            mockChildProcess = {
-                on: jest.fn((event, callback) => {
-                    if (event === 'close') {
-                        callback(0);
-                    }
-                }),
-                stdout: { on: jest.fn() },
-                stderr: { on: jest.fn() }
-            };
-            spawn.mockReturnValue(mockChildProcess);
-        });
-
-        it('should push schema successfully for MongoDB', async () => {
-            const result = await runPrismaDbPush();
-
-            expect(result.success).toBe(true);
-            expect(spawn).toHaveBeenCalled();
-        });
-
-        it('should use --skip-generate flag', async () => {
-            await runPrismaDbPush();
-
-            const args = spawn.mock.calls[0][1];
-            expect(args).toContain('--skip-generate');
-        });
-
-        it('should use db push command', async () => {
-            await runPrismaDbPush();
-
-            const args = spawn.mock.calls[0][1];
-            expect(args).toContain('db');
-            expect(args).toContain('push');
-        });
-
-        it('should handle push failures with error', async () => {
-            mockChildProcess.on.mockImplementation((event, callback) => {
-                if (event === 'close') {
-                    callback(1);
-                }
-            });
-
-            const result = await runPrismaDbPush();
-
-            expect(result.success).toBe(false);
-            expect(result.error).toContain('exited with code 1');
-        });
-
-        it('should respect verbose flag', async () => {
-            await runPrismaDbPush(true);
-
-            const options = spawn.mock.calls[0][2];
-            expect(options.stdio).toBe('inherit');
-        });
-
-        it('should use interactive mode (stdio: inherit)', async () => {
-            await runPrismaDbPush();
-
-            const options = spawn.mock.calls[0][2];
-            expect(options.stdio).toBe('inherit');
-        });
-
-        it('should handle schema validation errors', async () => {
-            mockChildProcess.on.mockImplementation((event, callback) => {
-                if (event === 'close') {
-                    callback(1);
-                }
-            });
-
-            const result = await runPrismaDbPush();
-
-            expect(result.success).toBe(false);
-        });
-    });
-
-    describe('getMigrationCommand()', () => {
-        it('should return dev for development stage', () => {
-            const command = getMigrationCommand('development');
-
-            expect(command).toBe('dev');
-        });
-
-        it('should return dev for dev stage', () => {
-            const command = getMigrationCommand('dev');
-
-            expect(command).toBe('dev');
-        });
-
-        it('should return dev for local stage', () => {
-            const command = getMigrationCommand('local');
-
-            expect(command).toBe('dev');
-        });
-
-        it('should return dev for test stage', () => {
-            const command = getMigrationCommand('test');
-
-            expect(command).toBe('dev');
-        });
-
-        it('should return deploy for production stage', () => {
-            const command = getMigrationCommand('production');
-
-            expect(command).toBe('deploy');
-        });
-
-        it('should return deploy for prod stage', () => {
-            const command = getMigrationCommand('prod');
-
-            expect(command).toBe('deploy');
-        });
-
-        it('should return deploy for staging stage', () => {
-            const command = getMigrationCommand('staging');
-
-            expect(command).toBe('deploy');
-        });
-
-        it('should default to dev when stage undefined', () => {
-            const command = getMigrationCommand();
-
-            expect(command).toBe('dev');
-        });
-
-        it('should read from STAGE environment variable when no argument', () => {
-            process.env.STAGE = 'production';
-
-            const command = getMigrationCommand();
-
-            expect(command).toBe('deploy');
-        });
-
-        it('should prioritize argument over STAGE env var', () => {
-            process.env.STAGE = 'production';
-
-            const command = getMigrationCommand('development');
-
-            expect(command).toBe('dev');
-        });
-
-        it('should handle case-insensitive stage names', () => {
-            expect(getMigrationCommand('DEVELOPMENT')).toBe('dev');
-            expect(getMigrationCommand('PRODUCTION')).toBe('deploy');
-            expect(getMigrationCommand('Dev')).toBe('dev');
-            expect(getMigrationCommand('Prod')).toBe('deploy');
-        });
-
-        it('should return deploy for unknown stages', () => {
-            const command = getMigrationCommand('unknown-stage');
-
-            expect(command).toBe('deploy');
-        });
-    });
-});

package/handlers/workers/db-migration.js

@@ -1,208 +0,0 @@
-/**
- * Database Migration Lambda Handler
- *
- * Lambda function that runs Prisma database migrations from within the VPC,
- * enabling CI/CD pipelines to migrate databases without requiring public access.
- *
- * This handler uses the prisma-runner utilities from @friggframework/core,
- * ensuring consistency with the `frigg db:setup` command.
- *
- * Environment Variables Required:
- * - DATABASE_URL: PostgreSQL connection string (automatically set from Secrets Manager)
- * - DB_TYPE: Database type ('postgresql' or 'mongodb')
- * - STAGE: Deployment stage (determines migration command: 'dev' or 'deploy')
- *
- * Invocation:
- *   aws lambda invoke \
- *     --function-name my-app-production-dbMigrate \
- *     --region us-east-1 \
- *     response.json
- *
- * Success Response:
- *   {
- *     "statusCode": 200,
- *     "body": {
- *       "success": true,
- *       "message": "Database migration completed successfully",
- *       "dbType": "postgresql",
- *       "stage": "production",
- *       "migrationCommand": "deploy"
- *     }
- *   }
- *
- * Error Response:
- *   {
- *     "statusCode": 500,
- *     "body": {
- *       "success": false,
- *       "error": "Migration failed: ...",
- *       "stack": "Error: ..."
- *     }
- *   }
- */
-
-const {
-    RunDatabaseMigrationUseCase,
-    MigrationError,
-    ValidationError,
-} = require('../../database/use-cases/run-database-migration-use-case');
-
-// Inject prisma-runner as dependency
-const prismaRunner = require('../../database/utils/prisma-runner');
-
-/**
- * Sanitizes error messages to prevent credential leaks
- * @param {string} errorMessage - Error message that might contain credentials
- * @returns {string} Sanitized error message
- */
-function sanitizeError(errorMessage) {
-    if (!errorMessage) return 'Unknown error';
-
-    return String(errorMessage)
-        // Remove PostgreSQL connection strings
-        .replace(/postgresql:\/\/[^@\s]+@[^\s/]+/gi, 'postgresql://***:***@***')
-        // Remove MongoDB connection strings
-        .replace(/mongodb(\+srv)?:\/\/[^@\s]+@[^\s/]+/gi, 'mongodb$1://***:***@***')
-        // Remove password parameters
-        .replace(/password[=:]\s*[^\s,;)]+/gi, 'password=***')
-        // Remove API keys
-        .replace(/apikey[=:]\s*[^\s,;)]+/gi, 'apikey=***')
-        .replace(/api[_-]?key[=:]\s*[^\s,;)]+/gi, 'api_key=***')
-        // Remove tokens
-        .replace(/token[=:]\s*[^\s,;)]+/gi, 'token=***')
-        .replace(/bearer\s+[^\s,;)]+/gi, 'bearer ***');
-}
-
-/**
- * Sanitizes DATABASE_URL for safe logging
- * @param {string} url - Database URL
- * @returns {string} Sanitized URL
- */
-function sanitizeDatabaseUrl(url) {
-    if (!url) return '';
-
-    // Replace credentials in connection string
-    return url.replace(/(:\/\/)([^:]+):([^@]+)@/, '$1***:***@');
-}
-
-/**
- * Lambda handler entry point
- * @param {Object} event - Lambda event (not used, migrations don't need input)
- * @param {Object} context - Lambda context (contains AWS request ID, timeout info)
- * @returns {Promise<Object>} Response with statusCode and body
- */
-exports.handler = async (event, context) => {
-    console.log('========================================');
-    console.log('Database Migration Lambda Started');
-    console.log('========================================');
-    console.log('Event:', JSON.stringify(event, null, 2));
-    console.log('Context:', JSON.stringify({
-        requestId: context.requestId,
-        functionName: context.functionName,
-        remainingTimeInMillis: context.getRemainingTimeInMillis(),
-    }, null, 2));
-
-    // Get environment variables
-    const databaseUrl = process.env.DATABASE_URL;
-    const dbType = process.env.DB_TYPE || 'postgresql';
-    const stage = process.env.STAGE || 'production';
-
-    try {
-        // Validate DATABASE_URL is set
-        if (!databaseUrl) {
-            const error = 'DATABASE_URL environment variable is not set';
-            console.error('❌ Validation failed:', error);
-            return {
-                statusCode: 500,
-                body: JSON.stringify({
-                    success: false,
-                    error,
-                }),
-            };
-        }
-
-        console.log('✓ Environment validated');
-        console.log(`  Database Type: ${dbType}`);
-        console.log(`  Stage: ${stage}`);
-        console.log(`  Database URL: ${sanitizeDatabaseUrl(databaseUrl)}`);
-
-        // Create use case with dependencies (Dependency Injection)
-        const runDatabaseMigrationUseCase = new RunDatabaseMigrationUseCase({
-            prismaRunner,
-        });
-
-        console.log('\n========================================');
-        console.log('Executing Database Migration');
-        console.log('========================================');
-
-        // Execute use case (business logic layer)
-        const result = await runDatabaseMigrationUseCase.execute({
-            dbType,
-            stage,
-            verbose: true, // Enable verbose output for Lambda CloudWatch logs
-        });
-
-        console.log('✓ Database migration completed successfully');
-        console.log('\n========================================');
-        console.log('Migration Summary');
-        console.log('========================================');
-        console.log(`  Status: Success`);
-        console.log(`  Database: ${result.dbType}`);
-        console.log(`  Stage: ${result.stage}`);
-        console.log(`  Command: ${result.command}`);
-        console.log('========================================');
-
-        // Return success response (adapter layer - HTTP mapping)
-        return {
-            statusCode: 200,
-            body: JSON.stringify({
-                success: true,
-                message: result.message,
-                dbType: result.dbType,
-                stage: result.stage,
-                migrationCommand: result.command,
-                timestamp: new Date().toISOString(),
-            }),
-        };
-
-    } catch (error) {
-        console.error('\n========================================');
-        console.error('Migration Failed');
-        console.error('========================================');
-        console.error('Error:', error.name, error.message);
-
-        // Log full stack trace to CloudWatch (only visible to developers)
-        if (error.stack) {
-            console.error('Stack:', error.stack);
-        }
-
-        // Log context if available (from MigrationError)
-        if (error.context) {
-            console.error('Context:', JSON.stringify(error.context, null, 2));
-        }
-
-        // Map domain errors to HTTP status codes (adapter layer)
-        let statusCode = 500;
-        let errorMessage = error.message || 'Unknown error occurred';
-
-        if (error instanceof ValidationError) {
-            statusCode = 400; // Bad Request for validation errors
-        } else if (error instanceof MigrationError) {
-            statusCode = 500; // Internal Server Error for migration failures
-        }
-
-        // Sanitize error message before returning
-        const sanitizedError = sanitizeError(errorMessage);
-
-        return {
-            statusCode,
-            body: JSON.stringify({
-                success: false,
-                error: sanitizedError,
-                errorType: error.name || 'Error',
-                // Only include stack traces in development environments
-                ...(stage === 'dev' || stage === 'local' || stage === 'test' ? { stack: error.stack } : {}),
-            }),
-        };
-    }
-};