@friggframework/core 2.0.0-next.44 → 2.0.0-next.46

package/handlers/routers/health.js

@@ -1,6 +1,16 @@
 const { Router } = require('express');
-const { moduleFactory, integrationFactory } = require('./../backend-utils');
 const { createAppHandler } = require('./../app-handler-helpers');
+const { loadAppDefinition } = require('./../app-definition-loader');
+const { ModuleFactory } = require('../../modules/module-factory');
+const {
+    getModulesDefinitionFromIntegrationClasses,
+} = require('../../integrations/utils/map-integration-dto');
+const {
+    createModuleRepository,
+} = require('../../modules/repositories/module-repository-factory');
+const {
+    createIntegrationRepository,
+} = require('../../integrations/repositories/integration-repository-factory');
 const {
     createHealthCheckRepository,
 } = require('../../database/repositories/health-check-repository-factory');
@@ -22,6 +32,28 @@ const {
 
 const router = Router();
 const healthCheckRepository = createHealthCheckRepository();
+
+// Load integrations and create factories just like auth router does
+// This verifies the system can properly load integrations
+let moduleFactory, integrationClasses;
+try {
+    const appDef = loadAppDefinition();
+    integrationClasses = appDef.integrations || [];
+
+    const moduleRepository = createModuleRepository();
+    const moduleDefinitions = getModulesDefinitionFromIntegrationClasses(integrationClasses);
+
+    moduleFactory = new ModuleFactory({
+        moduleRepository,
+        moduleDefinitions,
+    });
+} catch (error) {
+    console.error('Failed to load integrations for health check:', error.message);
+    // Factories will be undefined, health check will report unhealthy
+    moduleFactory = undefined;
+    integrationClasses = [];
+}
+
 const testEncryptionUseCase = new TestEncryptionUseCase({
     healthCheckRepository,
 });
@@ -34,11 +66,11 @@ const checkEncryptionHealthUseCase = new CheckEncryptionHealthUseCase({
 const checkExternalApisHealthUseCase = new CheckExternalApisHealthUseCase();
 const checkIntegrationsHealthUseCase = new CheckIntegrationsHealthUseCase({
     moduleFactory,
-    integrationFactory,
+    integrationClasses,
 });
 
 const validateApiKey = (req, res, next) => {
-    const apiKey = req.headers['x-api-key'];
+    const apiKey = req.headers['x-frigg-health-api-key'];
 
     if (req.path === '/health') {
         return next();
@@ -48,7 +80,7 @@ const validateApiKey = (req, res, next) => {
         console.error('Unauthorized access attempt to health endpoint');
         return res.status(401).json({
             status: 'error',
-            message: 'Unauthorized',
+            message: 'Unauthorized - x-frigg-health-api-key header required',
         });
     }
 
@@ -141,8 +173,11 @@ const detectVpcConfiguration = async () => {
             }
         }
 
-        results.isInVpc =
-            !results.hasInternetAccess || results.vpcEndpoints.length > 0;
+        // Check if Lambda is in VPC using VPC_ENABLED env var set by infrastructure
+        results.isInVpc = process.env.VPC_ENABLED === 'true' ||
+            (!results.hasInternetAccess && results.canResolvePublicDns) ||
+            results.vpcEndpoints.length > 0;
+
         results.canConnectToAws =
             results.hasInternetAccess || results.vpcEndpoints.length > 0;
     } catch (error) {

package/handlers/routers/integration-webhook-routers.js

@@ -0,0 +1,67 @@
+const { createAppHandler } = require('./../app-handler-helpers');
+const { loadAppDefinition } = require('../app-definition-loader');
+const { Router } = require('express');
+const { IntegrationEventDispatcher } = require('../integration-event-dispatcher');
+
+const handlers = {};
+const { integrations: integrationClasses } = loadAppDefinition();
+
+for (const IntegrationClass of integrationClasses) {
+    const webhookConfig = IntegrationClass.Definition.webhooks;
+
+    // Skip if webhooks not enabled
+    if (!webhookConfig || (typeof webhookConfig === 'object' && !webhookConfig.enabled)) {
+        continue;
+    }
+
+    const router = Router();
+    const basePath = `/api/${IntegrationClass.Definition.name}-integration/webhooks`;
+
+    console.log(`\n│ Configuring webhook routes for ${IntegrationClass.Definition.name}:`);
+
+    // General webhook route (no integration ID)
+    router.post(basePath, async (req, res, next) => {
+        try {
+            const integrationInstance = new IntegrationClass();
+            const dispatcher = new IntegrationEventDispatcher(integrationInstance);
+            await dispatcher.dispatchHttp({
+                event: 'WEBHOOK_RECEIVED',
+                req,
+                res,
+                next,
+            });
+        } catch (error) {
+            next(error);
+        }
+    });
+    console.log(`│ POST ${basePath}`);
+
+    // Integration-specific webhook route (with integration ID)
+    router.post(`${basePath}/:integrationId`, async (req, res, next) => {
+        try {
+            const integrationInstance = new IntegrationClass();
+            const dispatcher = new IntegrationEventDispatcher(integrationInstance);
+            await dispatcher.dispatchHttp({
+                event: 'WEBHOOK_RECEIVED',
+                req,
+                res,
+                next,
+            });
+        } catch (error) {
+            next(error);
+        }
+    });
+    console.log(`│ POST ${basePath}/:integrationId`);
+    console.log('│');
+
+    handlers[`${IntegrationClass.Definition.name}Webhook`] = {
+        handler: createAppHandler(
+            `HTTP Event: ${IntegrationClass.Definition.name} Webhook`,
+            router,
+            false  // shouldUseDatabase = false
+        ),
+    };
+}
+
+module.exports = { handlers };
+

package/handlers/use-cases/check-integrations-health-use-case.js

@@ -1,20 +1,32 @@
 class CheckIntegrationsHealthUseCase {
-    constructor({ moduleFactory, integrationFactory }) {
+    constructor({ moduleFactory, integrationClasses }) {
         this.moduleFactory = moduleFactory;
-        this.integrationFactory = integrationFactory;
+        this.integrationClasses = integrationClasses;
     }
 
     execute() {
-        const moduleTypes = Array.isArray(this.moduleFactory.moduleTypes)
-            ? this.moduleFactory.moduleTypes
+        const moduleDefinitions = (this.moduleFactory && this.moduleFactory.moduleDefinitions)
+            ? this.moduleFactory.moduleDefinitions
             : [];
 
-        const integrationTypes = Array.isArray(
-            this.integrationFactory.integrationTypes
-        )
-            ? this.integrationFactory.integrationTypes
+        const integrationClasses = Array.isArray(this.integrationClasses)
+            ? this.integrationClasses
             : [];
 
+        // Extract module names from definitions
+        const moduleTypes = Array.isArray(moduleDefinitions)
+            ? moduleDefinitions.map(def => def.moduleName || def.name || def.label || 'Unknown')
+            : [];
+
+        // Extract integration names from classes
+        const integrationNames = integrationClasses.map(IntegrationClass => {
+            try {
+                return IntegrationClass.Definition?.name || IntegrationClass.name || 'Unknown';
+            } catch {
+                return 'Unknown';
+            }
+        });
+
         return {
             status: 'healthy',
             modules: {
@@ -22,8 +34,8 @@ class CheckIntegrationsHealthUseCase {
                 available: moduleTypes,
             },
             integrations: {
-                count: integrationTypes.length,
-                available: integrationTypes,
+                count: integrationNames.length,
+                available: integrationNames,
             },
         };
     }

package/handlers/workers/db-migration.js

@@ -0,0 +1,352 @@
+/**
+ * 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');
+const {
+    CheckDatabaseStateUseCase,
+} = require('../../database/use-cases/check-database-state-use-case');
+const {
+    MigrationStatusRepositoryS3,
+} = require('../../database/repositories/migration-status-repository-s3');
+
+// Inject prisma-runner as dependency
+const prismaRunner = require('../../database/utils/prisma-runner');
+
+// Use S3 repository for migration status tracking (no User table dependency)
+const bucketName = process.env.S3_BUCKET_NAME || process.env.MIGRATION_STATUS_BUCKET;
+const migrationStatusRepository = new MigrationStatusRepositoryS3(bucketName);
+
+/**
+ * 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***:***@');
+}
+
+/**
+ * Extract migration parameters from SQS event or direct invocation
+ * @param {Object} event - Lambda event (SQS or direct)
+ * @returns {Object} Extracted parameters { migrationId, dbType, stage }
+ */
+function extractMigrationParams(event) {
+    let migrationId = null;
+    let stage = null;
+
+    // Migration infrastructure is PostgreSQL-only, so hardcode dbType
+    const dbType = 'postgresql';
+
+    // Check if this is an SQS event
+    if (event.Records && event.Records.length > 0) {
+        // SQS event - extract from message body
+        const message = JSON.parse(event.Records[0].body);
+        migrationId = message.migrationId;
+        stage = message.stage;
+
+        console.log('SQS event detected');
+        console.log(`  Migration ID: ${migrationId}`);
+        console.log(`  DB Type: ${dbType} (hardcoded - PostgreSQL-only)`);
+        console.log(`  Stage: ${stage}`);
+    } else {
+        // Direct invocation - use event properties or environment variables
+        migrationId = event.migrationId || null;
+        stage = event.stage || process.env.STAGE || 'production';
+
+        console.log('Direct invocation detected');
+        if (migrationId) {
+            console.log(`  Migration ID: ${migrationId}`);
+        }
+        console.log(`  DB Type: ${dbType} (hardcoded - PostgreSQL-only)`);
+        console.log(`  Stage: ${stage}`);
+    }
+
+    return { migrationId, dbType, stage };
+}
+
+/**
+ * Lambda handler entry point
+ * @param {Object} event - Lambda event (SQS message or direct invocation)
+ * @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));
+
+    // Extract migration parameters from event
+    const { migrationId, dbType, stage } = extractMigrationParams(event);
+
+    // Check for action parameter (direct invocation for status checks)
+    const action = event.action || 'migrate'; // Default to migration
+
+    // Handle checkStatus action
+    if (action === 'checkStatus') {
+        console.log(`\n========================================`);
+        console.log(`Action: checkStatus (dbType=${dbType}, stage=${stage})`);
+        console.log(`========================================`);
+
+        try {
+            const checkDbStateUseCase = new CheckDatabaseStateUseCase({ prismaRunner });
+            const status = await checkDbStateUseCase.execute(dbType, stage);
+
+            console.log('✓ Database state check completed');
+            console.log(`  Up to date: ${status.upToDate}`);
+            console.log(`  Pending migrations: ${status.pendingMigrations}`);
+
+            return {
+                statusCode: 200,
+                body: status,
+            };
+        } catch (error) {
+            console.error('❌ Database state check failed:', error.message);
+            return {
+                statusCode: 500,
+                body: {
+                    success: false,
+                    error: sanitizeError(error.message),
+                    upToDate: false,
+                },
+            };
+        }
+    }
+
+    // Otherwise, handle migration (existing code)
+    console.log(`\n========================================`);
+    console.log(`Action: migrate (migrationId=${migrationId || 'new'})`);
+    console.log(`========================================`);
+
+    // Get environment variables
+    const databaseUrl = process.env.DATABASE_URL;
+
+    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)}`);
+
+        // Update migration status to RUNNING (if migrationId provided)
+        if (migrationId) {
+            console.log(`\n✓ Updating migration status to RUNNING: ${migrationId}`);
+            await migrationStatusRepository.update({
+                migrationId,
+                stage,
+                state: 'RUNNING',
+                progress: 10,
+                startedAt: new Date().toISOString(),
+            });
+        }
+
+        // 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('========================================');
+
+        // Update migration status to COMPLETED (if migrationId provided)
+        if (migrationId) {
+            console.log(`\n✓ Updating migration status to COMPLETED: ${migrationId}`);
+            await migrationStatusRepository.update({
+                migrationId,
+                stage,
+                state: 'COMPLETED',
+                progress: 100,
+                completedAt: new Date().toISOString(),
+                migrationCommand: result.command,
+            });
+        }
+
+        // Return success response (adapter layer - HTTP mapping)
+        const responseBody = {
+            success: true,
+            message: result.message,
+            dbType: result.dbType,
+            stage: result.stage,
+            migrationCommand: result.command,
+            timestamp: new Date().toISOString(),
+        };
+
+        if (migrationId) {
+            responseBody.migrationId = migrationId;
+        }
+
+        return {
+            statusCode: 200,
+            body: JSON.stringify(responseBody),
+        };
+
+    } 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);
+
+        // Update migration status to FAILED (if migrationId provided)
+        if (migrationId) {
+            try {
+                console.log(`\n✓ Updating migration status to FAILED: ${migrationId}`);
+                await migrationStatusRepository.update({
+                    migrationId,
+                    stage,
+                    state: 'FAILED',
+                    progress: 0,
+                    error: sanitizedError,
+                    failedAt: new Date().toISOString(),
+                });
+            } catch (updateError) {
+                console.error('Failed to update migration status:', updateError.message);
+                // Continue - don't let status update failure block error response
+            }
+        }
+
+        const errorBody = {
+            success: false,
+            error: sanitizedError,
+            errorType: error.name || 'Error',
+            // Only include stack traces in development environments
+            ...(stage === 'dev' || stage === 'local' || stage === 'test' ? { stack: error.stack } : {}),
+        };
+
+        if (migrationId) {
+            errorBody.migrationId = migrationId;
+        }
+
+        return {
+            statusCode,
+            body: JSON.stringify(errorBody),
+        };
+    }
+};

package/index.js

@@ -33,6 +33,15 @@ const {
     UserRepositoryMongo,
     UserRepositoryPostgres,
 } = require('./user/repositories/user-repository-factory');
+const {
+    GetUserFromXFriggHeaders,
+} = require('./user/use-cases/get-user-from-x-frigg-headers');
+const {
+    GetUserFromAdopterJwt,
+} = require('./user/use-cases/get-user-from-adopter-jwt');
+const {
+    AuthenticateUser,
+} = require('./user/use-cases/authenticate-user');
 
 const {
     CredentialRepository,
@@ -43,6 +52,18 @@ const {
 const {
     IntegrationMappingRepository,
 } = require('./integrations/repositories/integration-mapping-repository');
+const {
+    CreateProcess,
+} = require('./integrations/use-cases/create-process');
+const {
+    UpdateProcessState,
+} = require('./integrations/use-cases/update-process-state');
+const {
+    UpdateProcessMetrics,
+} = require('./integrations/use-cases/update-process-metrics');
+const {
+    GetProcess,
+} = require('./integrations/use-cases/get-process');
 const { Cryptor } = require('./encrypt');
 const {
     BaseError,
@@ -111,6 +132,9 @@ module.exports = {
     createUserRepository,
     UserRepositoryMongo,
     UserRepositoryPostgres,
+    GetUserFromXFriggHeaders,
+    GetUserFromAdopterJwt,
+    AuthenticateUser,
     CredentialRepository,
     ModuleRepository,
     IntegrationMappingRepository,
@@ -130,6 +154,10 @@ module.exports = {
     createIntegrationRouter,
     getModulesDefinitionFromIntegrationClasses,
     LoadIntegrationContextUseCase,
+    CreateProcess,
+    UpdateProcessState,
+    UpdateProcessMetrics,
+    GetProcess,
 
     // application - Command factories for integration developers
     application,