@friggframework/core 2.0.0-next.10 → 2.0.0-next.100

package/handlers/app-handler-helpers.js

@@ -3,7 +3,6 @@ const express = require('express');
 const bodyParser = require('body-parser');
 const cors = require('cors');
 const Boom = require('@hapi/boom');
-const loadUserManager = require('./routers/middleware/loadUser');
 const serverlessHttp = require('serverless-http');
 
 const createApp = (applyMiddleware) => {
@@ -14,12 +13,12 @@ const createApp = (applyMiddleware) => {
     app.use(
         cors({
             origin: '*',
+            allowedHeaders: '*',
+            methods: '*',
             credentials: true,
         })
     );
 
-    app.use(loadUserManager);
-
     if (applyMiddleware) applyMiddleware(app);
 
     // Handle sending error response and logging server errors to console
@@ -33,6 +32,7 @@ const createApp = (applyMiddleware) => {
             flushDebugLog(boomError);
             res.status(statusCode).json({ error: 'Internal Server Error' });
         } else {
+            console.warn(`[Frigg] ${req.method} ${req.path} -> ${statusCode}: ${err.message}`);
             res.status(statusCode).json({ error: err.message });
         }
     });

package/handlers/backend-utils.js

@@ -1,38 +1,48 @@
-const { createFriggBackend, Worker } = require('@friggframework/core');
-const {
-    findNearestBackendPackageJson,
-} = require('../../devtools/frigg-cli/utils/backend-path');
-const path = require('node:path');
-const fs = require('fs-extra');
-
-const backendPath = findNearestBackendPackageJson();
-if (!backendPath) {
-    throw new Error('Could not find backend package.json');
-}
-
-const backendDir = path.dirname(backendPath);
-const backendFilePath = path.join(backendDir, 'index.js');
-if (!fs.existsSync(backendFilePath)) {
-    throw new Error('Could not find index.js');
-}
-
-const backendJsFile = require(backendFilePath);
 const { Router } = require('express');
-const appDefinition = backendJsFile.Definition;
+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 backend = createFriggBackend(appDefinition);
 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 integration = new IntegrationClass({});
-            await integration.loadModules();
-            await integration.registerEventHandlers();
-            const result = await integration.send(event, {req, res, next});
+            const integrationInstance = new IntegrationClass();
+            // initialize() registers dynamic user actions AND merges any Tier 3
+            // Integration Extension events into instance.events before dispatch.
+            await integrationInstance.initialize();
+            const dispatcher = new IntegrationEventDispatcher(
+                integrationInstance
+            );
+            const result = await dispatcher.dispatchHttp({
+                event,
+                req,
+                res,
+                next,
+            });
             res.json(result);
         } catch (error) {
             next(error);
@@ -41,38 +51,256 @@ 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,
+    });
+
+    let integrationRecord;
+    try {
+        integrationRecord = await integrationRepository.findIntegrationById(
+            integrationId
+        );
+    } catch (error) {
+        if (error.message?.includes('not found')) {
+            return null;
+        }
+        throw error;
+    }
+
+    const instance = await getIntegrationInstance.execute(
+        integrationId,
+        integrationRecord.userId
+    );
+
+    return instance;
+};
+
+// Returns false only when the integration is confirmed gone; a transient
+// lookup failure returns true so genuine errors keep their normal retry path.
+const integrationExists = async (integrationId) => {
+    const integrationRepository = createIntegrationRepository();
+    try {
+        const record = await integrationRepository.findIntegrationById(
+            integrationId
+        );
+        return Boolean(record);
+    } catch (error) {
+        if (error.message?.includes('not found')) {
+            return false;
+        }
+        return true;
+    }
+};
+
+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}`);
+    }
+
+    const instance = await getIntegrationInstance.execute(
+        process.integrationId,
+        process.userId
+    );
+
+    return instance;
+};
+
 const createQueueWorker = (integrationClass) => {
+    const integrationName = integrationClass.Definition.name;
+
     class QueueWorker extends Worker {
         async _run(params, context) {
+            const logCtx = {
+                integration: integrationName,
+                event: params.event,
+                processId: params.data?.processId,
+                integrationId: params.data?.integrationId,
+            };
+
             try {
-                let instance;
-                if (!params.integrationId) {
-                    instance = new integrationClass({});
-                    await instance.loadModules();
-                    // await instance.loadUserActions();
-                    await instance.registerEventHandlers();
+                let integrationInstance;
+
+                // Prioritize processId first (for sync handler compatibility),
+                // then integrationId (for ANY event type that needs hydration),
+                // fallback to unhydrated instance
+                if (params.data?.processId) {
+                    console.log(`[QueueWorker] hydrating by processId`, logCtx);
+                    integrationInstance = await loadIntegrationForProcess(
+                        params.data.processId,
+                        integrationClass
+                    );
+                    console.log(`[QueueWorker] hydrated`, {
+                        ...logCtx,
+                        integrationStatus: integrationInstance?.status,
+                        hydratedIntegrationId: integrationInstance?.id,
+                    });
+                    if (
+                        ['DISABLED', 'ERROR', 'IN_DELETION'].includes(
+                            integrationInstance?.status
+                        )
+                    ) {
+                        console.warn(
+                            `[${integrationName}] Integration for process ${params.data.processId} is ${integrationInstance.status}. Discarding ${params.event} message.`
+                        );
+                        return;
+                    }
+                } else if (params.data?.integrationId) {
                     console.log(
-                        `${params.event} for ${integrationClass.Definition.name} integration with no integrationId`
+                        `[QueueWorker] hydrating by integrationId`,
+                        logCtx
+                    );
+                    integrationInstance = await loadIntegrationForWebhook(
+                        params.data.integrationId
                     );
+                    if (!integrationInstance) {
+                        console.warn(
+                            `[${integrationName}] Integration ${params.data.integrationId} no longer exists. Discarding ${params.event} message.`
+                        );
+                        return;
+                    }
+                    console.log(`[QueueWorker] hydrated`, {
+                        ...logCtx,
+                        integrationStatus: integrationInstance?.status,
+                    });
+                    if (
+                        ['DISABLED', 'ERROR', 'IN_DELETION'].includes(
+                            integrationInstance.status
+                        )
+                    ) {
+                        console.warn(
+                            `[${integrationName}] Integration ${params.data.integrationId} is ${integrationInstance.status}. Discarding ${params.event} message.`
+                        );
+                        return;
+                    }
                 } else {
-                    instance =
-                        await integrationClass.getInstanceFromIntegrationId({
-                            integrationId: params.integrationId,
-                        });
+                    // 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.
                     console.log(
-                        `${params.event} for ${instance.integration.config.type} of integrationId: ${params.integrationId}`
+                        `[QueueWorker] no processId/integrationId — running dry instance`,
+                        logCtx
                     );
+                    integrationInstance = new integrationClass();
+                    // Merge Tier 3 Integration Extension events into instance.events
+                    // so extension-contributed queue events can be dispatched.
+                    await integrationInstance.initialize();
                 }
-                const res = await instance.send(params.event, {
+
+                const dispatcher = new IntegrationEventDispatcher(
+                    integrationInstance
+                );
+
+                console.log(
+                    `[QueueWorker] dispatching ${params.event}`,
+                    logCtx
+                );
+                const result = await dispatcher.dispatchJob({
+                    event: params.event,
                     data: params.data,
-                    context,
+                    context: context,
                 });
-                return res;
+                console.log(
+                    `[QueueWorker] ${params.event} dispatched ok`,
+                    logCtx
+                );
+                return result;
             } catch (error) {
+                // Integration deleted mid-flight: no retry can succeed once
+                // it's gone, so discard instead of sending it to the DLQ.
+                if (
+                    params.data?.integrationId &&
+                    !(await integrationExists(params.data.integrationId))
+                ) {
+                    console.warn(
+                        `[${integrationName}] Integration ${params.data.integrationId} was deleted mid-flight — discarding ${params.event} message (no retry)`
+                    );
+                    return;
+                }
+
                 console.error(
-                    `Error in ${params.event} for ${integrationClass.Definition.name}:`,
+                    `Error in ${params.event} for ${integrationName}:`,
                     error
                 );
+
+                // 4xx HTTP errors are permanent — the requester already
+                // attempted token refresh (401) and backoff (429/5xx).
+                // By the time a 4xx reaches here, retrying won't help.
+                // 408 (timeout) and 429 (rate limit) are excluded — both are transient.
+                const status = error.statusCode;
+                if (
+                    status &&
+                    status >= 400 &&
+                    status < 500 &&
+                    status !== 408 &&
+                    status !== 429
+                ) {
+                    error.isHaltError = true;
+                    console.warn(
+                        `[${integrationName}] Permanent ${status} error for ${params.event} — message will be discarded (no retry)`,
+                        {
+                            ...logCtx,
+                            errorName: error.name,
+                            errorMessage: error.message,
+                        }
+                    );
+                }
+
                 throw error;
             }
         }
@@ -81,7 +309,8 @@ const createQueueWorker = (integrationClass) => {
 };
 
 module.exports = {
-    ...backend,
     loadRouterFromObject,
     createQueueWorker,
+    integrationExists,
+    loadIntegrationForWebhook,
 };

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 };