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

package/handlers/backend-utils.js

@@ -3,6 +3,22 @@ const { Worker } = require('@friggframework/core');
 const {
     IntegrationEventDispatcher,
 } = require('./integration-event-dispatcher');
+const {
+    GetIntegrationInstance,
+} = require('../integrations/use-cases/get-integration-instance');
+const { ModuleFactory } = require('../modules/module-factory');
+const {
+    createProcessRepository,
+} = require('../integrations/repositories/process-repository-factory');
+const {
+    createIntegrationRepository,
+} = require('../integrations/repositories/integration-repository-factory');
+const {
+    createModuleRepository,
+} = require('../modules/repositories/module-repository-factory');
+const {
+    getModulesDefinitionFromIntegrationClasses,
+} = require('../integrations/utils/map-integration-dto');
 
 const loadRouterFromObject = (IntegrationClass, routerObject) => {
     const router = Router();
@@ -33,20 +49,119 @@ const loadRouterFromObject = (IntegrationClass, routerObject) => {
     return router;
 };
 
+const initializeRepositories = () => {
+    const processRepository = createProcessRepository();
+    const integrationRepository = createIntegrationRepository();
+    const moduleRepository = createModuleRepository();
+
+    return { processRepository, integrationRepository, moduleRepository };
+};
+
+const createModuleFactoryWithDefinitions = (
+    moduleRepository,
+    integrationClasses
+) => {
+    const moduleDefinitions =
+        getModulesDefinitionFromIntegrationClasses(integrationClasses);
+
+    return new ModuleFactory({
+        moduleRepository,
+        moduleDefinitions,
+    });
+};
+
+const loadIntegrationForWebhook = async (integrationId) => {
+    const { loadAppDefinition } = require('./app-definition-loader');
+    const { integrations: integrationClasses } = loadAppDefinition();
+
+    const { integrationRepository, moduleRepository } =
+        initializeRepositories();
+
+    const moduleFactory = createModuleFactoryWithDefinitions(
+        moduleRepository,
+        integrationClasses
+    );
+
+    const getIntegrationInstance = new GetIntegrationInstance({
+        integrationRepository,
+        integrationClasses,
+        moduleFactory,
+    });
+
+    const integrationRecord = await integrationRepository.findIntegrationById(
+        integrationId
+    );
+
+    return await getIntegrationInstance.execute(
+        integrationId,
+        integrationRecord.userId
+    );
+};
+
+const loadIntegrationForProcess = async (processId, integrationClass) => {
+    const { processRepository, integrationRepository, moduleRepository } =
+        initializeRepositories();
+
+    const moduleFactory = createModuleFactoryWithDefinitions(moduleRepository, [
+        integrationClass,
+    ]);
+
+    const getIntegrationInstance = new GetIntegrationInstance({
+        integrationRepository,
+        integrationClasses: [integrationClass],
+        moduleFactory,
+    });
+
+    if (!processId) {
+        throw new Error('processId is required in queue message data');
+    }
+
+    const process = await processRepository.findById(processId);
+
+    if (!process) {
+        throw new Error(`Process not found: ${processId}`);
+    }
+
+    return await getIntegrationInstance.execute(
+        process.integrationId,
+        process.userId
+    );
+};
+
 const createQueueWorker = (integrationClass) => {
     class QueueWorker extends Worker {
         async _run(params, context) {
             try {
-                const integrationInstance = new integrationClass();
+                let integrationInstance;
+                if (
+                    params.event === 'ON_WEBHOOK' &&
+                    params.data?.integrationId
+                ) {
+                    integrationInstance = await loadIntegrationForWebhook(
+                        params.data.integrationId
+                    );
+                } else if (params.data?.processId) {
+                    integrationInstance = await loadIntegrationForProcess(
+                        params.data.processId,
+                        integrationClass
+                    );
+                } else {
+                    // Instantiates a DRY integration class without database records.
+                    // There will be cases where we need to use helpers that the api modules can export.
+                    // Like for HubSpot, the answer is to do a reverse lookup for the integration by the entity external ID (HubSpot Portal ID),
+                    // and then you'll have the integration ID available to hydrate from.
+                    integrationInstance = new integrationClass();
+                }
+
                 const dispatcher = new IntegrationEventDispatcher(
                     integrationInstance
                 );
-                const res = await dispatcher.dispatchJob({
+
+                return await dispatcher.dispatchJob({
                     event: params.event,
                     data: params.data,
                     context: context,
                 });
-                return res;
             } catch (error) {
                 console.error(
                     `Error in ${params.event} for ${integrationClass.Definition.name}:`,

package/handlers/database-migration-handler.js

@@ -0,0 +1,227 @@
+/**
+ * Database Migration Handler for AWS Lambda
+ * 
+ * Executes Prisma migrations in a Lambda environment.
+ * Based on AWS best practices for running migrations in serverless environments.
+ * 
+ * Supported Commands:
+ * - deploy: Apply pending migrations to the database (production-safe)
+ * - reset: Reset database and apply all migrations (DANGEROUS - dev only)
+ * 
+ * Usage:
+ *   // Via Lambda invoke
+ *   {
+ *     "command": "deploy"  // or "reset"
+ *   }
+ * 
+ * Requirements:
+ * - Prisma CLI must be included in deployment or Lambda layer
+ * - DATABASE_URL environment variable must be set
+ * - VPC configuration for Aurora access
+ * 
+ * Reference: https://www.prisma.io/docs/guides/deployment/deployment-guides/deploying-to-aws-lambda
+ */
+
+const { execFile } = require('child_process');
+const path = require('path');
+
+/**
+ * Execute Prisma migration command
+ * 
+ * @param {string} command - Migration command ('deploy' or 'reset')
+ * @param {string} schemaPath - Path to Prisma schema file
+ * @returns {Promise<number>} Exit code
+ */
+async function executePrismaMigration(command, schemaPath) {
+    console.log(`Executing Prisma migration: ${command}`);
+    console.log(`Schema path: ${schemaPath}`);
+    console.log(`Database URL: ${process.env.DATABASE_URL ? '[SET]' : '[NOT SET]'}`);
+
+    return new Promise((resolve, reject) => {
+        // Build command arguments
+        const args = ['migrate', command];
+        
+        // Add command-specific options
+        if (command === 'reset') {
+            args.push('--force');           // Skip confirmation prompt
+            args.push('--skip-generate');   // Skip client generation (already done in layer)
+        }
+
+        // Add schema path if provided
+        if (schemaPath) {
+            args.push('--schema', schemaPath);
+        }
+
+        console.log(`Running: prisma ${args.join(' ')}`);
+        
+        // Execute Prisma CLI
+        execFile(
+            path.resolve('./node_modules/prisma/build/index.js'),
+            args,
+            {
+                env: {
+                    ...process.env,
+                    // Ensure Prisma uses the correct binary target
+                    PRISMA_CLI_BINARY_TARGETS: 'rhel-openssl-3.0.x',
+                }
+            },
+            (error, stdout, stderr) => {
+                // Log all output
+                if (stdout) {
+                    console.log('STDOUT:', stdout);
+                }
+                if (stderr) {
+                    console.error('STDERR:', stderr);
+                }
+
+                if (error) {
+                    console.error(`Migration ${command} exited with error:`, error.message);
+                    console.error(`Exit code: ${error.code || 1}`);
+                    resolve(error.code || 1);
+                } else {
+                    console.log(`Migration ${command} completed successfully`);
+                    resolve(0);
+                }
+            }
+        );
+    });
+}
+
+/**
+ * Validate migration command
+ */
+function validateCommand(command) {
+    const validCommands = ['deploy', 'reset'];
+    
+    if (!validCommands.includes(command)) {
+        throw new Error(
+            `Invalid migration command: "${command}". ` +
+            `Valid commands are: ${validCommands.join(', ')}`
+        );
+    }
+
+    // Extra validation for dangerous commands
+    if (command === 'reset') {
+        const stage = process.env.STAGE || process.env.NODE_ENV;
+        if (stage === 'production' || stage === 'prod') {
+            throw new Error(
+                'BLOCKED: "reset" command is not allowed in production environment. ' +
+                'This command would delete all data. Use "deploy" instead.'
+            );
+        }
+        console.warn('⚠️  WARNING: "reset" will DELETE all data and reset the database!');
+    }
+}
+
+/**
+ * Determine which Prisma schema to use based on database type
+ */
+function getSchemaPath() {
+    // In Lambda, schemas are in @friggframework/core/generated/
+    const baseSchemaPath = './node_modules/@friggframework/core/generated';
+    
+    // Check if Postgres is enabled
+    if (process.env.DATABASE_URL?.includes('postgresql') || process.env.DATABASE_URL?.includes('postgres')) {
+        const schemaPath = `${baseSchemaPath}/prisma-postgresql/schema.prisma`;
+        console.log(`Using PostgreSQL schema: ${schemaPath}`);
+        return schemaPath;
+    }
+    
+    // Check if MongoDB is enabled
+    if (process.env.DATABASE_URL?.includes('mongodb')) {
+        const schemaPath = `${baseSchemaPath}/prisma-mongodb/schema.prisma`;
+        console.log(`Using MongoDB schema: ${schemaPath}`);
+        return schemaPath;
+    }
+
+    // Default to PostgreSQL
+    console.log('DATABASE_URL not set or database type unknown, defaulting to PostgreSQL');
+    return `${baseSchemaPath}/prisma-postgresql/schema.prisma`;
+}
+
+/**
+ * Lambda handler for database migrations
+ * 
+ * @param {Object} event - Lambda event
+ * @param {string} event.command - Migration command ('deploy' or 'reset')
+ * @param {Object} context - Lambda context
+ * @returns {Promise<Object>} Migration result
+ */
+exports.handler = async (event, context) => {
+    const startTime = Date.now();
+    
+    console.log('='.repeat(60));
+    console.log('Database Migration Handler');
+    console.log('='.repeat(60));
+    console.log('Event:', JSON.stringify(event, null, 2));
+    console.log('Context:', JSON.stringify({
+        functionName: context.functionName,
+        functionVersion: context.functionVersion,
+        memoryLimitInMB: context.memoryLimitInMB,
+        logGroupName: context.logGroupName,
+    }, null, 2));
+    
+    try {
+        // Get migration command (default to 'deploy')
+        const command = event.command || 'deploy';
+        
+        // Validate command
+        validateCommand(command);
+        
+        // Check required environment variables
+        if (!process.env.DATABASE_URL) {
+            throw new Error(
+                'DATABASE_URL environment variable is not set. ' +
+                'Cannot connect to database for migrations.'
+            );
+        }
+        
+        // Determine schema path
+        const schemaPath = getSchemaPath();
+        
+        // Execute migration
+        const exitCode = await executePrismaMigration(command, schemaPath);
+        
+        const duration = Date.now() - startTime;
+        
+        if (exitCode === 0) {
+            const result = {
+                success: true,
+                command,
+                message: `Migration ${command} completed successfully`,
+                duration: `${duration}ms`,
+                timestamp: new Date().toISOString(),
+            };
+            
+            console.log('='.repeat(60));
+            console.log('Migration completed successfully');
+            console.log(JSON.stringify(result, null, 2));
+            console.log('='.repeat(60));
+            
+            return result;
+        } else {
+            throw new Error(`Migration ${command} failed with exit code ${exitCode}`);
+        }
+        
+    } catch (error) {
+        const duration = Date.now() - startTime;
+        
+        console.error('='.repeat(60));
+        console.error('Migration failed');
+        console.error('Error:', error.message);
+        console.error('Stack:', error.stack);
+        console.error('='.repeat(60));
+        
+        const errorResult = {
+            success: false,
+            command: event.command || 'unknown',
+            error: error.message,
+            duration: `${duration}ms`,
+            timestamp: new Date().toISOString(),
+        };
+        
+        // Return error (don't throw) so Lambda doesn't retry
+        return errorResult;
+    }
+};
+

package/handlers/routers/auth.js

@@ -3,7 +3,7 @@ const { createAppHandler } = require('./../app-handler-helpers');
 
 const router = createIntegrationRouter();
 
-router.route('/redirect/:appId').get((req, res) => {
+router.route('/api/integrations/redirect/:appId').get((req, res) => {
     res.redirect(
         `${process.env.FRONTEND_URI}/redirect/${req.params.appId
         }?${new URLSearchParams(req.query)}`

package/handlers/routers/db-migration.handler.js

@@ -0,0 +1,29 @@
+/**
+ * Database Migration Router Lambda Handler
+ *
+ * Minimal Lambda wrapper that avoids loading core/index.js
+ * (which would try to load user/** modules excluded from migration packages)
+ * 
+ * This handler is intentionally simpler than health.handler.js to avoid dependencies.
+ */
+
+const serverlessHttp = require('serverless-http');
+const express = require('express');
+const cors = require('cors');
+const dbMigrationRouter = require('./db-migration');
+
+// Create minimal Express app
+const app = express();
+app.use(cors());
+app.use(express.json());
+app.use(dbMigrationRouter);
+
+// Error handler
+app.use((err, req, res, next) => {
+    console.error('Error:', err);
+    res.status(500).json({ message: 'Internal Server Error' });
+});
+
+// Export as .handler property (Lambda config: db-migration.handler)
+module.exports.handler = serverlessHttp(app);
+

package/handlers/routers/db-migration.js

@@ -0,0 +1,256 @@
+/**
+ * Database Migration Router
+ *
+ * HTTP API for triggering and monitoring database migrations.
+ *
+ * Endpoints:
+ * - GET /db-migrate/status - Check if migrations are pending
+ * - POST /db-migrate - Trigger async migration (queues job)
+ * - GET /db-migrate/:processId - Check migration status
+ *
+ * Security:
+ * - Requires ADMIN_API_KEY header for all requests
+ *
+ * Architecture:
+ * - Router (Adapter Layer) → Use Cases (Domain) → Repositories (Infrastructure)
+ * - Follows DDD/Hexagonal architecture
+ */
+
+const { Router } = require('express');
+const catchAsyncError = require('express-async-handler');
+const { MigrationStatusRepositoryS3 } = require('../../database/repositories/migration-status-repository-s3');
+const {
+    TriggerDatabaseMigrationUseCase,
+    ValidationError: TriggerValidationError,
+} = require('../../database/use-cases/trigger-database-migration-use-case');
+const {
+    GetMigrationStatusUseCase,
+    ValidationError: GetValidationError,
+    NotFoundError,
+} = require('../../database/use-cases/get-migration-status-use-case');
+const { LambdaInvoker } = require('../../database/adapters/lambda-invoker');
+const {
+    GetDatabaseStateViaWorkerUseCase,
+} = require('../../database/use-cases/get-database-state-via-worker-use-case');
+
+const router = Router();
+
+// Dependency injection
+// Use S3 repository to avoid User table dependency (chicken-and-egg problem)
+const bucketName = process.env.S3_BUCKET_NAME || process.env.MIGRATION_STATUS_BUCKET;
+const migrationStatusRepository = new MigrationStatusRepositoryS3(bucketName);
+
+const triggerMigrationUseCase = new TriggerDatabaseMigrationUseCase({
+    migrationStatusRepository,
+    // Note: QueuerUtil is used directly in the use case (static utility)
+});
+const getStatusUseCase = new GetMigrationStatusUseCase({ migrationStatusRepository });
+
+// Lambda invocation for database state check (keeps router lightweight)
+const lambdaInvoker = new LambdaInvoker();
+const workerFunctionName = process.env.WORKER_FUNCTION_NAME ||
+    `${process.env.SERVICE || 'unknown'}-${process.env.STAGE || 'production'}-dbMigrationWorker`;
+
+const getDatabaseStateUseCase = new GetDatabaseStateViaWorkerUseCase({
+    lambdaInvoker,
+    workerFunctionName,
+});
+
+/**
+ * Admin API key validation middleware
+ * Matches pattern from health.js:72-88
+ */
+const validateApiKey = (req, res, next) => {
+    const apiKey = req.headers['x-frigg-admin-api-key'];
+
+    if (!apiKey || apiKey !== process.env.ADMIN_API_KEY) {
+        console.error('Unauthorized access attempt to db-migrate endpoint');
+        return res.status(401).json({
+            status: 'error',
+            message: 'Unauthorized - x-frigg-admin-api-key header required',
+        });
+    }
+
+    next();
+};
+
+// Apply API key validation to all routes
+router.use(validateApiKey);
+
+/**
+ * POST /db-migrate
+ *
+ * Trigger database migration (async via SQS queue)
+ *
+ * Request body:
+ * {
+ *   userId: string (optional, defaults to 'admin'),
+ *   dbType: 'postgresql' | 'mongodb',
+ *   stage: string (e.g., 'production', 'dev')
+ * }
+ *
+ * Response (202 Accepted):
+ * {
+ *   success: true,
+ *   processId: string,
+ *   state: 'INITIALIZING',
+ *   statusUrl: string,
+ *   message: string
+ * }
+ */
+router.post(
+    '/db-migrate',
+    catchAsyncError(async (req, res) => {
+        // Migration infrastructure is PostgreSQL-only, so hardcode dbType
+        const dbType = 'postgresql';
+        const { stage } = req.body;
+        // TODO: Extract userId from JWT token when auth is implemented
+        const userId = req.body.userId || 'admin';
+
+        console.log(`Migration trigger request: dbType=${dbType}, stage=${stage || 'auto-detect'}, userId=${userId}`);
+
+        try {
+            const result = await triggerMigrationUseCase.execute({
+                userId,
+                dbType,
+                stage,
+            });
+
+            // 202 Accepted - request accepted but not completed
+            res.status(202).json(result);
+        } catch (error) {
+            // Handle validation errors (400 Bad Request)
+            if (error instanceof TriggerValidationError) {
+                return res.status(400).json({
+                    success: false,
+                    error: error.message,
+                });
+            }
+
+            // Re-throw other errors for global error handler
+            throw error;
+        }
+    })
+);
+
+/**
+ * GET /db-migrate/status
+ *
+ * Check if database has pending migrations
+ * 
+ * Query params:
+ * - stage: string (optional, defaults to STAGE env var or 'production')
+ *
+ * Response (200 OK):
+ * {
+ *   upToDate: boolean,
+ *   pendingMigrations: number,
+ *   dbType: 'postgresql',
+ *   stage: string,
+ *   recommendation?: string (if migrations pending),
+ *   error?: string (if database check failed)
+ * }
+ */
+router.get(
+    '/db-migrate/status',
+    catchAsyncError(async (req, res) => {
+        const stage = req.query.stage || process.env.STAGE || 'production';
+
+        console.log(`Checking database state: stage=${stage}, worker=${workerFunctionName}`);
+
+        try {
+            // Invoke worker Lambda to check database state
+            const status = await getDatabaseStateUseCase.execute(stage);
+
+            res.status(200).json(status);
+        } catch (error) {
+            // Log full error for debugging
+            console.error('Database state check failed:', error);
+
+            // Return sanitized error to client
+            return res.status(500).json({
+                success: false,
+                error: 'Failed to check database state',
+                details: error.message,
+            });
+        }
+    })
+);
+
+/**
+ * GET /db-migrate/:migrationId
+ *
+ * Get migration status by migration ID
+ *
+ * Response (200 OK):
+ * {
+ *   processId: string,
+ *   type: 'DATABASE_MIGRATION',
+ *   state: 'INITIALIZING' | 'RUNNING' | 'COMPLETED' | 'FAILED',
+ *   context: {
+ *     dbType: string,
+ *     stage: string,
+ *     migrationCommand: string (if started)
+ *   },
+ *   results: {
+ *     success: boolean (if completed),
+ *     duration: string (if completed),
+ *     error: string (if failed)
+ *   },
+ *   createdAt: string,
+ *   updatedAt: string
+ * }
+ */
+router.get(
+    '/db-migrate/:migrationId',
+    catchAsyncError(async (req, res) => {
+        const { migrationId } = req.params;
+        const stage = req.query.stage || process.env.STAGE || 'production';
+
+        console.log(`Migration status request: migrationId=${migrationId}, stage=${stage}`);
+
+        try {
+            const status = await getStatusUseCase.execute(migrationId, stage);
+
+            res.status(200).json(status);
+        } catch (error) {
+            // Handle not found errors (404 Not Found)
+            if (error instanceof NotFoundError) {
+                return res.status(404).json({
+                    success: false,
+                    error: error.message,
+                });
+            }
+
+            // Handle validation errors (400 Bad Request)
+            if (error instanceof GetValidationError) {
+                return res.status(400).json({
+                    success: false,
+                    error: error.message,
+                });
+            }
+
+            // Re-throw other errors for global error handler
+            throw error;
+        }
+    })
+);
+
+// Minimal Lambda handler (avoids app-handler-helpers which loads core/index.js → user/**)
+const serverlessHttp = require('serverless-http');
+const express = require('express');
+const cors = require('cors');
+
+const app = express();
+app.use(cors());
+app.use(express.json());
+app.use(router);
+app.use((err, req, res, next) => {
+    console.error('Migration Router Error:', err);
+    res.status(500).json({ message: 'Internal Server Error' });
+});
+
+const handler = serverlessHttp(app);
+
+module.exports = { handler, router };
+