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

package/handlers/webhook-flow.integration.test.js

@@ -0,0 +1,356 @@
+jest.mock('../database/config', () => ({
+    DB_TYPE: 'mongodb',
+    getDatabaseType: jest.fn(() => 'mongodb'),
+    PRISMA_LOG_LEVEL: 'error,warn',
+    PRISMA_QUERY_LOGGING: false,
+}));
+
+const { IntegrationBase } = require('../integrations/integration-base');
+const { IntegrationEventDispatcher } = require('./integration-event-dispatcher');
+const { QueuerUtil } = require('../queues');
+
+// Mock AWS SQS
+jest.mock('aws-sdk', () => {
+    const mockSQS = {
+        sendMessage: jest.fn((params, callback) => {
+            callback(null, { MessageId: 'mock-message-id-123' });
+        }),
+    };
+    return {
+        SQS: jest.fn(() => mockSQS),
+        config: { update: jest.fn() },
+    };
+});
+
+class WebhookTestIntegration extends IntegrationBase {
+    static Definition = {
+        name: 'webhook-test',
+        version: '1.0.0',
+        modules: {},
+        webhooks: true,
+    };
+
+    constructor(params) {
+        super(params);
+        this.webhookData = null;
+    }
+
+    // Override for custom signature verification
+    async onWebhookReceived({ req, res }) {
+        const signature = req.headers['x-custom-signature'];
+
+        if (signature && signature !== 'valid-signature-123') {
+            return res.status(401).json({ error: 'Invalid signature' });
+        }
+
+        await this.queueWebhook({
+            integrationId: req.params.integrationId,
+            body: req.body,
+            headers: req.headers,
+            query: req.query,
+        });
+
+        res.status(200).json({ received: true, verified: !!signature });
+    }
+
+    // Override for webhook processing
+    async onWebhook({ data }) {
+        this.webhookData = data;
+        return { processed: true, webhookData: data };
+    }
+}
+
+describe('Webhook Flow Integration Test', () => {
+    describe('End-to-End Webhook Flow', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+            process.env.WEBHOOK_TEST_QUEUE_URL = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
+        });
+
+        it('should complete full webhook flow: HTTP → Queue → Worker', async () => {
+            // Step 1: Simulate HTTP webhook received
+            const integration = new WebhookTestIntegration();
+            const dispatcher = new IntegrationEventDispatcher(integration);
+
+            const req = {
+                body: { event: 'item.created', itemId: '12345' },
+                params: { integrationId: 'int-789' },
+                headers: { 'content-type': 'application/json' },
+                query: {},
+            };
+            const res = {
+                status: jest.fn().mockReturnThis(),
+                json: jest.fn(),
+            };
+
+            // Execute WEBHOOK_RECEIVED
+            await dispatcher.dispatchHttp({
+                event: 'WEBHOOK_RECEIVED',
+                req,
+                res,
+                next: jest.fn(),
+            });
+
+            // Verify HTTP response
+            expect(res.status).toHaveBeenCalledWith(200);
+            expect(res.json).toHaveBeenCalledWith({ received: true, verified: false });
+
+            // Verify message was queued
+            const AWS = require('aws-sdk');
+            const mockSQS = new AWS.SQS();
+            expect(mockSQS.sendMessage).toHaveBeenCalled();
+
+            const queueCall = mockSQS.sendMessage.mock.calls[0][0];
+            expect(queueCall.QueueUrl).toBe(process.env.WEBHOOK_TEST_QUEUE_URL);
+
+            const queuedMessage = JSON.parse(queueCall.MessageBody);
+            expect(queuedMessage.event).toBe('ON_WEBHOOK');
+            expect(queuedMessage.data.integrationId).toBe('int-789');
+            expect(queuedMessage.data.body).toEqual({ event: 'item.created', itemId: '12345' });
+
+            // Step 2: Simulate worker processing from queue
+            const workerIntegration = new WebhookTestIntegration();
+            const workerDispatcher = new IntegrationEventDispatcher(workerIntegration);
+
+            const result = await workerDispatcher.dispatchJob({
+                event: 'ON_WEBHOOK',
+                data: queuedMessage.data,
+                context: {},
+            });
+
+            // Verify processing result
+            expect(result.processed).toBe(true);
+            expect(result.webhookData).toEqual(queuedMessage.data);
+            expect(workerIntegration.webhookData).not.toBeNull();
+        });
+
+        it('should support custom signature verification', async () => {
+            const integration = new WebhookTestIntegration();
+            const dispatcher = new IntegrationEventDispatcher(integration);
+
+            const reqInvalid = {
+                body: { event: 'test' },
+                params: {},
+                headers: { 'x-custom-signature': 'invalid-sig' },
+                query: {},
+            };
+            const resInvalid = {
+                status: jest.fn().mockReturnThis(),
+                json: jest.fn(),
+            };
+
+            // Test invalid signature
+            await dispatcher.dispatchHttp({
+                event: 'WEBHOOK_RECEIVED',
+                req: reqInvalid,
+                res: resInvalid,
+                next: jest.fn(),
+            });
+
+            expect(resInvalid.status).toHaveBeenCalledWith(401);
+            expect(resInvalid.json).toHaveBeenCalledWith({ error: 'Invalid signature' });
+
+            // Test valid signature
+            const reqValid = {
+                body: { event: 'test' },
+                params: {},
+                headers: { 'x-custom-signature': 'valid-signature-123' },
+                query: {},
+            };
+            const resValid = {
+                status: jest.fn().mockReturnThis(),
+                json: jest.fn(),
+            };
+
+            await dispatcher.dispatchHttp({
+                event: 'WEBHOOK_RECEIVED',
+                req: reqValid,
+                res: resValid,
+                next: jest.fn(),
+            });
+
+            expect(resValid.status).toHaveBeenCalledWith(200);
+            expect(resValid.json).toHaveBeenCalledWith({ received: true, verified: true });
+        });
+
+        it('should handle webhooks without integration ID', async () => {
+            const integration = new WebhookTestIntegration();
+            const dispatcher = new IntegrationEventDispatcher(integration);
+
+            const req = {
+                body: { event: 'system.event' },
+                params: {}, // No integrationId
+                headers: {},
+                query: {},
+            };
+            const res = {
+                status: jest.fn().mockReturnThis(),
+                json: jest.fn(),
+            };
+
+            await dispatcher.dispatchHttp({
+                event: 'WEBHOOK_RECEIVED',
+                req,
+                res,
+                next: jest.fn(),
+            });
+
+            // Should queue with integrationId: null
+            const AWS = require('aws-sdk');
+            const mockSQS = new AWS.SQS();
+            const queuedMessage = JSON.parse(mockSQS.sendMessage.mock.calls[0][0].MessageBody);
+
+            expect(queuedMessage.data.integrationId).toBeNull();
+        });
+
+        it('should preserve webhook headers and query params', async () => {
+            const integration = new WebhookTestIntegration();
+            const dispatcher = new IntegrationEventDispatcher(integration);
+
+            const req = {
+                body: { event: 'test' },
+                params: { integrationId: 'int-456' },
+                headers: {
+                    'x-webhook-id': 'webhook-123',
+                    'x-custom-header': 'value',
+                },
+                query: { timestamp: '2025-10-15', version: '2' },
+            };
+            const res = {
+                status: jest.fn().mockReturnThis(),
+                json: jest.fn(),
+            };
+
+            await dispatcher.dispatchHttp({
+                event: 'WEBHOOK_RECEIVED',
+                req,
+                res,
+                next: jest.fn(),
+            });
+
+            const AWS = require('aws-sdk');
+            const mockSQS = new AWS.SQS();
+            const queuedMessage = JSON.parse(mockSQS.sendMessage.mock.calls[0][0].MessageBody);
+
+            expect(queuedMessage.data.headers).toEqual(req.headers);
+            expect(queuedMessage.data.query).toEqual(req.query);
+        });
+    });
+
+    describe('Default Webhook Handlers', () => {
+        it('should use default WEBHOOK_RECEIVED handler if not overridden', async () => {
+            // Integration without custom handler
+            class DefaultWebhookIntegration extends IntegrationBase {
+                static Definition = {
+                    name: 'default-webhook',
+                    version: '1.0.0',
+                    modules: {},
+                    webhooks: true,
+                };
+            }
+
+            process.env.DEFAULT_WEBHOOK_QUEUE_URL = 'https://sqs.us-east-1.amazonaws.com/123456789/default-queue';
+
+            const integration = new DefaultWebhookIntegration();
+            const dispatcher = new IntegrationEventDispatcher(integration);
+
+            const req = {
+                body: { test: 'data' },
+                params: {},
+                headers: {},
+                query: {},
+            };
+            const res = {
+                status: jest.fn().mockReturnThis(),
+                json: jest.fn(),
+            };
+
+            await dispatcher.dispatchHttp({
+                event: 'WEBHOOK_RECEIVED',
+                req,
+                res,
+                next: jest.fn(),
+            });
+
+            // Should use default handler
+            expect(res.status).toHaveBeenCalledWith(200);
+            expect(res.json).toHaveBeenCalledWith({ received: true });
+        });
+
+        it('should use default ON_WEBHOOK handler if not overridden', async () => {
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+
+            class DefaultWebhookIntegration extends IntegrationBase {
+                static Definition = {
+                    name: 'default-webhook-worker',
+                    version: '1.0.0',
+                    modules: {},
+                    webhooks: true,
+                };
+            }
+
+            const integration = new DefaultWebhookIntegration();
+            const dispatcher = new IntegrationEventDispatcher(integration);
+
+            const webhookData = { body: { test: 'data' } };
+
+            await dispatcher.dispatchJob({
+                event: 'ON_WEBHOOK',
+                data: webhookData,
+                context: {},
+            });
+
+            // Default handler logs the data
+            expect(consoleSpy).toHaveBeenCalledWith('Webhook received:', webhookData);
+
+            consoleSpy.mockRestore();
+        });
+    });
+
+    describe('Error Handling', () => {
+        it('should handle queueing errors gracefully', async () => {
+            const AWS = require('aws-sdk');
+            const mockSQS = new AWS.SQS();
+            mockSQS.sendMessage.mockImplementation((params, callback) => {
+                callback(new Error('Queue is full'), null);
+            });
+
+            process.env.WEBHOOK_TEST_QUEUE_URL = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
+
+            const integration = new WebhookTestIntegration();
+            const dispatcher = new IntegrationEventDispatcher(integration);
+
+            const req = {
+                body: { event: 'test' },
+                params: {},
+                headers: {},
+                query: {},
+            };
+            const res = {
+                status: jest.fn().mockReturnThis(),
+                json: jest.fn(),
+            };
+
+            // Should throw error when queueing fails
+            await expect(
+                dispatcher.dispatchHttp({
+                    event: 'WEBHOOK_RECEIVED',
+                    req,
+                    res,
+                    next: jest.fn(),
+                })
+            ).rejects.toThrow('Queue is full');
+        });
+
+        it('should throw error if queue URL not configured', async () => {
+            delete process.env.WEBHOOK_TEST_QUEUE_URL;
+
+            const integration = new WebhookTestIntegration();
+
+            await expect(
+                integration.queueWebhook({ test: 'data' })
+            ).rejects.toThrow('Queue URL not found for WEBHOOK_TEST_QUEUE_URL');
+        });
+    });
+});
+

package/handlers/workers/integration-defined-workers.test.js

@@ -0,0 +1,184 @@
+jest.mock('../../database/config', () => ({
+    DB_TYPE: 'mongodb',
+    getDatabaseType: jest.fn(() => 'mongodb'),
+    PRISMA_LOG_LEVEL: 'error,warn',
+    PRISMA_QUERY_LOGGING: false,
+}));
+
+const { createQueueWorker } = require('../backend-utils');
+const { IntegrationBase } = require('../../integrations/integration-base');
+const { IntegrationEventDispatcher } = require('../integration-event-dispatcher');
+
+class TestWebhookIntegration extends IntegrationBase {
+    static Definition = {
+        name: 'test-webhook',
+        version: '1.0.0',
+        modules: {},
+        webhooks: true,
+    };
+
+    constructor(params) {
+        super(params);
+        this.onWebhookCalled = false;
+        this.receivedData = null;
+    }
+
+    async onWebhook({ data }) {
+        this.onWebhookCalled = true;
+        this.receivedData = data;
+        return { processed: true, data };
+    }
+}
+
+describe('Webhook Queue Worker', () => {
+    describe('ON_WEBHOOK event processing', () => {
+        it('should process ON_WEBHOOK event without integration ID (unhydrated)', async () => {
+            const QueueWorker = createQueueWorker(TestWebhookIntegration);
+            const worker = new QueueWorker();
+
+            const params = {
+                event: 'ON_WEBHOOK',
+                data: {
+                    body: { webhookEvent: 'created', entityId: '123' },
+                    headers: { 'content-type': 'application/json' },
+                },
+            };
+
+            const sqsEvent = {
+                Records: [{ body: JSON.stringify(params) }],
+            };
+
+            // Should work with unhydrated instance without throwing
+            await expect(worker.run(sqsEvent, {})).resolves.not.toThrow();
+        });
+
+        it('should call ON_WEBHOOK handler with webhook data', async () => {
+            const QueueWorker = createQueueWorker(TestWebhookIntegration);
+            const worker = new QueueWorker();
+
+            const webhookData = {
+                body: { webhookEvent: 'created', entityId: '123' },
+                headers: { 'content-type': 'application/json' },
+                query: {},
+            };
+
+            const params = {
+                event: 'ON_WEBHOOK',
+                data: webhookData,
+            };
+
+            const sqsEvent = {
+                Records: [{ body: JSON.stringify(params) }],
+            };
+
+            await worker.run(sqsEvent, {});
+
+            // The handler should have been called
+        });
+
+        it('should handle multiple webhook messages in batch', async () => {
+            const QueueWorker = createQueueWorker(TestWebhookIntegration);
+            const worker = new QueueWorker();
+
+            const message1 = {
+                event: 'ON_WEBHOOK',
+                data: { body: { event: '1' } },
+            };
+            const message2 = {
+                event: 'ON_WEBHOOK',
+                data: { body: { event: '2' } },
+            };
+
+            const sqsEvent = {
+                Records: [
+                    { body: JSON.stringify(message1) },
+                    { body: JSON.stringify(message2) },
+                ],
+            };
+
+            await worker.run(sqsEvent, {});
+
+            // Should process both messages without error
+        });
+    });
+
+    describe('Error Handling', () => {
+        it('should throw error if ON_WEBHOOK handler fails', async () => {
+            const FailingIntegration = class extends TestWebhookIntegration {
+                async onWebhook({ data }) {
+                    throw new Error('Processing failed');
+                }
+            };
+
+            const FailingWorker = createQueueWorker(FailingIntegration);
+            const failingWorker = new FailingWorker();
+
+            const params = {
+                event: 'ON_WEBHOOK',
+                data: { body: { invalid: 'data' } },
+            };
+
+            const sqsEvent = {
+                Records: [{ body: JSON.stringify(params) }],
+            };
+
+            await expect(failingWorker.run(sqsEvent, {})).rejects.toThrow('Processing failed');
+        });
+
+        it('should log errors with integration context', async () => {
+            const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+
+            const FailingIntegration = class extends TestWebhookIntegration {
+                async onWebhook({ data }) {
+                    throw new Error('Test error');
+                }
+            };
+
+            const FailingWorker = createQueueWorker(FailingIntegration);
+            const failingWorker = new FailingWorker();
+
+            const params = {
+                event: 'ON_WEBHOOK',
+                data: { body: {} },
+            };
+
+            const sqsEvent = {
+                Records: [{ body: JSON.stringify(params) }],
+            };
+
+            await expect(failingWorker.run(sqsEvent, {})).rejects.toThrow();
+            expect(consoleSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Error in ON_WEBHOOK for test-webhook'),
+                expect.any(Error)
+            );
+
+            consoleSpy.mockRestore();
+        });
+    });
+
+    describe('Integration Hydration for webhooks with integrationId', () => {
+        it('should attempt to load integration when integrationId present', async () => {
+            // This test verifies the logic path - full integration test
+            // will verify actual DB loading with mocked repositories
+            const QueueWorker = createQueueWorker(TestWebhookIntegration);
+            const worker = new QueueWorker();
+
+            const params = {
+                event: 'ON_WEBHOOK',
+                data: {
+                    integrationId: 'integration-456',
+                    body: { webhookEvent: 'updated' },
+                },
+            };
+
+            const sqsEvent = {
+                Records: [{ body: JSON.stringify(params) }],
+            };
+
+            // This will fail trying to load the integration from DB
+            // but it proves the code path is attempted
+            await expect(worker.run(sqsEvent, {})).rejects.toThrow();
+        });
+    });
+});
+

package/index.js

@@ -43,6 +43,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,
@@ -130,6 +142,10 @@ module.exports = {
     createIntegrationRouter,
     getModulesDefinitionFromIntegrationClasses,
     LoadIntegrationContextUseCase,
+    CreateProcess,
+    UpdateProcessState,
+    UpdateProcessMetrics,
+    GetProcess,
 
     // application - Command factories for integration developers
     application,