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

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

@@ -1,356 +0,0 @@
-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

@@ -1,184 +0,0 @@
-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/integrations/tests/use-cases/create-integration.test.js

@@ -1,131 +0,0 @@
-jest.mock('../../../database/config', () => ({
-    DB_TYPE: 'mongodb',
-    getDatabaseType: jest.fn(() => 'mongodb'),
-    PRISMA_LOG_LEVEL: 'error,warn',
-    PRISMA_QUERY_LOGGING: false,
-}));
-
-const { CreateIntegration } = require('../../use-cases/create-integration');
-const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
-const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
-const { DummyIntegration } = require('../doubles/dummy-integration-class');
-
-describe('CreateIntegration Use-Case', () => {
-    let integrationRepository;
-    let moduleFactory;
-    let useCase;
-
-    beforeEach(() => {
-        integrationRepository = new TestIntegrationRepository();
-        moduleFactory = new TestModuleFactory();
-        useCase = new CreateIntegration({
-            integrationRepository,
-            integrationClasses: [DummyIntegration],
-            moduleFactory,
-        });
-    });
-
-    describe('happy path', () => {
-        it('creates an integration and returns DTO', async () => {
-            const entities = ['entity-1'];
-            const userId = 'user-1';
-            const config = { type: 'dummy', foo: 'bar' };
-
-            const dto = await useCase.execute(entities, userId, config);
-
-            expect(dto.id).toBeDefined();
-            expect(dto.config).toEqual(config);
-            expect(dto.userId).toBe(userId);
-            expect(dto.entities).toEqual(entities);
-            expect(dto.status).toBe('NEW');
-        });
-
-        it('triggers ON_CREATE event with correct payload', async () => {
-            const entities = ['entity-1'];
-            const userId = 'user-1';
-            const config = { type: 'dummy', foo: 'bar' };
-
-            const dto = await useCase.execute(entities, userId, config);
-
-            const record = await integrationRepository.findIntegrationById(dto.id);
-            expect(record).toBeTruthy();
-
-            const history = integrationRepository.getOperationHistory();
-            const createOperation = history.find(op => op.operation === 'create');
-            expect(createOperation).toEqual({
-                operation: 'create',
-                id: dto.id,
-                userId,
-                config
-            });
-        });
-
-        it('loads modules for each entity', async () => {
-            const entities = ['entity-1', 'entity-2'];
-            const userId = 'user-1';
-            const config = { type: 'dummy' };
-
-            const dto = await useCase.execute(entities, userId, config);
-
-            expect(dto.entities).toEqual(entities);
-        });
-    });
-
-    describe('error cases', () => {
-        it('throws error when integration class is not found', async () => {
-            const entities = ['entity-1'];
-            const userId = 'user-1';
-            const config = { type: 'unknown-type' };
-
-            await expect(useCase.execute(entities, userId, config))
-                .rejects
-                .toThrow('No integration class found for type: unknown-type');
-        });
-
-        it('throws error when no integration classes provided', async () => {
-            const useCaseWithoutClasses = new CreateIntegration({
-                integrationRepository,
-                integrationClasses: [],
-                moduleFactory,
-            });
-
-            const entities = ['entity-1'];
-            const userId = 'user-1';
-            const config = { type: 'dummy' };
-
-            await expect(useCaseWithoutClasses.execute(entities, userId, config))
-                .rejects
-                .toThrow('No integration class found for type: dummy');
-        });
-    });
-
-    describe('edge cases', () => {
-        it('handles empty entities array', async () => {
-            const entities = [];
-            const userId = 'user-1';
-            const config = { type: 'dummy' };
-
-            const dto = await useCase.execute(entities, userId, config);
-
-            expect(dto.entities).toEqual([]);
-            expect(dto.id).toBeDefined();
-        });
-
-        it('handles complex config objects', async () => {
-            const entities = ['entity-1'];
-            const userId = 'user-1';
-            const config = {
-                type: 'dummy',
-                nested: {
-                    value: 123,
-                    array: [1, 2, 3],
-                    bool: true
-                }
-            };
-
-            const dto = await useCase.execute(entities, userId, config);
-
-            expect(dto.config).toEqual(config);
-        });
-    });
-});