@friggframework/core 2.0.0-next.43 → 2.0.0-next.45

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

@@ -138,4 +138,72 @@ describe('IntegrationEventDispatcher', () => {
             expect(TestIntegration.latestInstance.isHydrated).toBe(false);
         });
     });
+
+    describe('Webhook Events', () => {
+        it('should dispatch WEBHOOK_RECEIVED without hydration', async () => {
+            const integration = new TestIntegration();
+            integration.events.WEBHOOK_RECEIVED = {
+                handler: jest.fn().mockResolvedValue({ received: true })
+            };
+
+            const dispatcher = new IntegrationEventDispatcher(integration);
+            const req = { body: { test: 'data' }, params: {} };
+            const res = {};
+
+            await dispatcher.dispatchHttp({
+                event: 'WEBHOOK_RECEIVED',
+                req,
+                res,
+                next: jest.fn()
+            });
+
+            expect(integration.events.WEBHOOK_RECEIVED.handler).toHaveBeenCalledWith({
+                req,
+                res,
+                next: expect.any(Function)
+            });
+        });
+
+        it('should dispatch ON_WEBHOOK with job context', async () => {
+            const integration = new TestIntegration({ id: '123', userId: 'user1' });
+            integration.events.ON_WEBHOOK = {
+                handler: jest.fn().mockResolvedValue({ processed: true })
+            };
+
+            const dispatcher = new IntegrationEventDispatcher(integration);
+            const data = { integrationId: '123', body: { event: 'test' } };
+
+            await dispatcher.dispatchJob({
+                event: 'ON_WEBHOOK',
+                data,
+                context: {}
+            });
+
+            expect(integration.events.ON_WEBHOOK.handler).toHaveBeenCalledWith({
+                data,
+                context: {}
+            });
+            expect(integration.isHydrated).toBe(true);
+        });
+
+        it('should use default WEBHOOK_RECEIVED handler if not overridden', async () => {
+            const integration = new TestIntegration();
+            const dispatcher = new IntegrationEventDispatcher(integration);
+
+            const req = { body: { test: 'data' }, params: {}, headers: {}, query: {} };
+            const res = { status: jest.fn().mockReturnThis(), json: jest.fn() };
+
+            // Mock queueWebhook
+            integration.queueWebhook = jest.fn().mockResolvedValue('message-id');
+
+            const handler = dispatcher.findEventHandler(integration, 'WEBHOOK_RECEIVED');
+            expect(handler).toBeDefined();
+
+            await handler.call(integration, { req, res });
+
+            expect(integration.queueWebhook).toHaveBeenCalled();
+            expect(res.status).toHaveBeenCalledWith(200);
+            expect(res.json).toHaveBeenCalledWith({ received: true });
+        });
+    });
 });

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('/', 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('/: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/routers/integration-webhook-routers.test.js

@@ -0,0 +1,126 @@
+jest.mock('../../database/config', () => ({
+    DB_TYPE: 'mongodb',
+    getDatabaseType: jest.fn(() => 'mongodb'),
+    PRISMA_LOG_LEVEL: 'error,warn',
+    PRISMA_QUERY_LOGGING: false,
+}));
+
+jest.mock('../app-definition-loader', () => {
+    const { IntegrationBase } = require('../../integrations/integration-base');
+
+    class WebhookEnabledIntegration extends IntegrationBase {
+        static Definition = {
+            name: 'webhook-enabled',
+            version: '1.0.0',
+            modules: {},
+            webhooks: true,
+        };
+
+        constructor(params) {
+            super(params);
+            this.queueWebhook = jest.fn().mockResolvedValue('message-id');
+        }
+    }
+
+    class AdvancedWebhookIntegration extends IntegrationBase {
+        static Definition = {
+            name: 'advanced-webhook',
+            version: '1.0.0',
+            modules: {},
+            webhooks: {
+                enabled: true,
+            },
+        };
+
+        constructor(params) {
+            super(params);
+            this.events = {
+                WEBHOOK_RECEIVED: {
+                    handler: async ({ req, res }) => {
+                        // Custom signature verification
+                        const signature = req.headers['x-webhook-signature'];
+                        if (signature !== 'valid-signature') {
+                            return res.status(401).json({ error: 'Invalid signature' });
+                        }
+                        await this.queueWebhook({ body: req.body });
+                        res.status(200).json({ verified: true });
+                    },
+                },
+            };
+            this.queueWebhook = jest.fn().mockResolvedValue('message-id');
+        }
+    }
+
+    class NoWebhookIntegration extends IntegrationBase {
+        static Definition = {
+            name: 'no-webhook',
+            version: '1.0.0',
+            modules: {},
+        };
+    }
+
+    return {
+        loadAppDefinition: () => ({
+            integrations: [
+                WebhookEnabledIntegration,
+                AdvancedWebhookIntegration,
+                NoWebhookIntegration,
+            ],
+        }),
+    };
+});
+
+describe('Integration Webhook Routers', () => {
+    let handlers;
+
+    beforeEach(() => {
+        // Clear module cache to get fresh handlers
+        jest.resetModules();
+        jest.clearAllMocks();
+
+        // Re-require after mocking
+        handlers = require('./integration-webhook-routers').handlers;
+    });
+
+    describe('Handler Creation', () => {
+        it('should create webhook handlers for integrations with webhooks: true', () => {
+            expect(handlers['webhook-enabledWebhook']).toBeDefined();
+            expect(handlers['webhook-enabledWebhook'].handler).toBeDefined();
+        });
+
+        it('should create webhook handlers for integrations with webhooks.enabled: true', () => {
+            expect(handlers['advanced-webhookWebhook']).toBeDefined();
+            expect(handlers['advanced-webhookWebhook'].handler).toBeDefined();
+        });
+
+        it('should not create webhook handlers for integrations without webhooks', () => {
+            expect(handlers['no-webhookWebhook']).toBeUndefined();
+        });
+
+        it('should configure handlers to not use database connection', () => {
+            // Handlers are created with createAppHandler(..., false)
+            // This means shouldUseDatabase = false
+            // Actual behavior is tested in integration tests
+            expect(handlers['webhook-enabledWebhook']).toBeDefined();
+            expect(handlers['advanced-webhookWebhook']).toBeDefined();
+        });
+    });
+
+    describe('Webhook Configuration', () => {
+        it('should support boolean webhook configuration', () => {
+            // webhooks: true should enable webhook handling
+            expect(handlers['webhook-enabledWebhook']).toBeDefined();
+        });
+
+        it('should support object webhook configuration', () => {
+            // webhooks: { enabled: true } should enable webhook handling
+            expect(handlers['advanced-webhookWebhook']).toBeDefined();
+        });
+
+        it('should skip integrations with webhooks disabled', () => {
+            // webhooks: false or missing should not create handlers
+            expect(handlers['no-webhookWebhook']).toBeUndefined();
+        });
+    });
+});
+