@friggframework/core 2.0.0-next.5 → 2.0.0-next.50

package/handlers/app-handler-helpers.js

@@ -0,0 +1,56 @@
+const { createHandler, flushDebugLog } = require('@friggframework/core');
+const express = require('express');
+const bodyParser = require('body-parser');
+const cors = require('cors');
+const Boom = require('@hapi/boom');
+const serverlessHttp = require('serverless-http');
+
+const createApp = (applyMiddleware) => {
+    const app = express();
+
+    app.use(bodyParser.json({ limit: '10mb' }));
+    app.use(bodyParser.urlencoded({ extended: true }));
+    app.use(
+        cors({
+            origin: '*',
+            allowedHeaders: '*',
+            methods: '*',
+            credentials: true,
+        })
+    );
+
+    if (applyMiddleware) applyMiddleware(app);
+
+    // Handle sending error response and logging server errors to console
+    app.use((err, req, res, next) => {
+        const boomError = err.isBoom ? err : Boom.boomify(err);
+        const {
+            output: { statusCode = 500 },
+        } = boomError;
+
+        if (statusCode >= 500) {
+            flushDebugLog(boomError);
+            res.status(statusCode).json({ error: 'Internal Server Error' });
+        } else {
+            res.status(statusCode).json({ error: err.message });
+        }
+    });
+
+    return app;
+};
+
+function createAppHandler(eventName, router, shouldUseDatabase = true) {
+    const app = createApp((app) => {
+        app.use(router);
+    });
+    return createHandler({
+        eventName,
+        method: serverlessHttp(app),
+        shouldUseDatabase,
+    });
+}
+
+module.exports = {
+    createApp,
+    createAppHandler,
+};

package/handlers/backend-utils.js

@@ -0,0 +1,180 @@
+const { Router } = require('express');
+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();
+    const { path, method, event } = routerObject;
+
+    console.log(
+        `Registering ${method} ${path} for ${IntegrationClass.Definition.name}`
+    );
+
+    router[method.toLowerCase()](path, async (req, res, next) => {
+        try {
+            const integrationInstance = new IntegrationClass();
+            const dispatcher = new IntegrationEventDispatcher(
+                integrationInstance
+            );
+            const result = await dispatcher.dispatchHttp({
+                event,
+                req,
+                res,
+                next,
+            });
+            res.json(result);
+        } catch (error) {
+            next(error);
+        }
+    });
+
+    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 {
+                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
+                );
+
+                return await dispatcher.dispatchJob({
+                    event: params.event,
+                    data: params.data,
+                    context: context,
+                });
+            } catch (error) {
+                console.error(
+                    `Error in ${params.event} for ${integrationClass.Definition.name}:`,
+                    error
+                );
+                throw error;
+            }
+        }
+    }
+    return QueueWorker;
+};
+
+module.exports = {
+    loadRouterFromObject,
+    createQueueWorker,
+};

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/integration-event-dispatcher.js

@@ -0,0 +1,54 @@
+/**
+ * Lightweight dispatcher that executes integration event handlers.
+ * @param {import('../integrations/integration-base')} integrationInstance Pre-instantiated integration.
+ */
+class IntegrationEventDispatcher {
+    constructor(integrationInstance) {
+        if (!integrationInstance) {
+            throw new Error('Integration instance is required');
+        }
+        this.integrationInstance = integrationInstance;
+    }
+
+    async dispatchHttp({ event, req, res, next }) {
+        const instance = this.integrationInstance;
+
+        const handler = this.findEventHandler(instance, event);
+
+        if (!handler) {
+            const name =
+                instance.constructor?.Definition?.name || 'integration';
+            throw new Error(`Event ${event} not registered for ${name}`);
+        }
+
+        return await handler.call(instance, { req, res, next });
+    }
+
+    async dispatchJob({ event, data, context }) {
+        const instance = this.integrationInstance;
+
+        const handler = this.findEventHandler(instance, event);
+
+        if (!handler) {
+            const name =
+                instance.constructor?.Definition?.name || 'integration';
+            throw new Error(`Event ${event} not registered for ${name}`);
+        }
+
+        return await handler.call(instance, { data, context });
+    }
+
+    findEventHandler(integration, event) {
+        if (integration.events && integration.events[event]) {
+            return integration.events[event].handler;
+        }
+
+        if (integration.defaultEvents && integration.defaultEvents[event]) {
+            return integration.defaultEvents[event].handler;
+        }
+
+        return null;
+    }
+}
+
+module.exports = { IntegrationEventDispatcher };