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

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

@@ -1,147 +0,0 @@
-jest.mock('../database/config', () => ({
-    DB_TYPE: 'mongodb',
-    getDatabaseType: jest.fn(() => 'mongodb'),
-    PRISMA_LOG_LEVEL: 'error,warn',
-    PRISMA_QUERY_LOGGING: false,
-}));
-
-const { IntegrationEventDispatcher } = require('./integration-event-dispatcher');
-const { IntegrationBase } = require('../integrations/integration-base');
-
-class SimulatedAsanaIntegration extends IntegrationBase {
-    static Definition = {
-        name: 'asana',
-        version: '1.0.0',
-        modules: {},
-        routes: [
-            { path: '/auth', method: 'GET', event: 'AUTH_REQUEST' },
-            { path: '/auth/redirect/:provider', method: 'GET', event: 'AUTH_REDIRECT' },
-            { path: '/form', method: 'GET', event: 'LOAD_FORM' },
-        ],
-    };
-
-    constructor(params = {}) {
-        super(params);
-        this.events = {
-            AUTH_REQUEST: { handler: this.authRequest.bind(this) },
-            AUTH_REDIRECT: { handler: this.authRedirect.bind(this) },
-            LOAD_FORM: { handler: this.loadForm.bind(this) },
-        };
-    }
-
-    async authRequest() {
-        return {
-            success: true,
-            action: 'redirect',
-            hydrated: this.isHydrated,
-        };
-    }
-
-    async authRedirect({ req }) {
-        const { code } = req.query || {};
-        return {
-            success: true,
-            action: 'tokens_received',
-            receivedCode: code,
-            hydrated: this.isHydrated,
-        };
-    }
-
-    async loadForm() {
-        if (!this.isHydrated && SimulatedAsanaIntegration.testRecord) {
-            this.setIntegrationRecord({
-                record: SimulatedAsanaIntegration.testRecord.record,
-                modules: SimulatedAsanaIntegration.testRecord.modules,
-            });
-        }
-
-        this.assertHydrated('Integration not found - must authenticate first');
-
-        return {
-            success: true,
-            form: {
-                fields: ['field1', 'field2'],
-            },
-            integrationId: this.id,
-        };
-    }
-}
-
-describe('IntegrationEventDispatcher auth flow', () => {
-    const createDispatcher = () =>
-        new IntegrationEventDispatcher(new SimulatedAsanaIntegration());
-
-    beforeEach(() => {
-        SimulatedAsanaIntegration.testRecord = null;
-    });
-
-    it('handles auth request without hydration', async () => {
-        const dispatcher = createDispatcher();
-        const result = await dispatcher.dispatchHttp({
-            event: 'AUTH_REQUEST',
-            req: { params: { provider: 'asana' }, query: {} },
-            res: {},
-            next: jest.fn(),
-        });
-
-        expect(result).toEqual({ success: true, action: 'redirect', hydrated: false });
-    });
-
-    it('handles auth redirect without hydration', async () => {
-        const dispatcher = createDispatcher();
-        const result = await dispatcher.dispatchHttp({
-            event: 'AUTH_REDIRECT',
-            req: { params: { provider: 'asana' }, query: { code: 'abc123' } },
-            res: {},
-            next: jest.fn(),
-        });
-
-        expect(result).toEqual({
-            success: true,
-            action: 'tokens_received',
-            receivedCode: 'abc123',
-            hydrated: false,
-        });
-    });
-
-    it('throws for protected routes when no record is loaded', async () => {
-        const dispatcher = createDispatcher();
-        await expect(
-            dispatcher.dispatchHttp({
-                event: 'LOAD_FORM',
-                req: { query: {} },
-                res: {},
-                next: jest.fn(),
-            })
-        ).rejects.toThrow('Integration not found - must authenticate first');
-    });
-
-    it('allows handlers to hydrate explicitly before continuing', async () => {
-        SimulatedAsanaIntegration.testRecord = {
-            record: {
-                id: 'integration-123',
-                userId: 'user-456',
-                config: { type: 'asana' },
-                status: 'ENABLED',
-                version: '1.0.0',
-                messages: { errors: [], warnings: [] },
-                entities: [],
-            },
-            modules: [],
-        };
-
-        const dispatcher = createDispatcher();
-        const result = await dispatcher.dispatchHttp({
-            event: 'LOAD_FORM',
-            req: { query: {} },
-            res: {},
-            next: jest.fn(),
-        });
-
-        expect(result).toEqual({
-            success: true,
-            form: { fields: ['field1', 'field2'] },
-            integrationId: 'integration-123',
-        });
-    });
-});

package/handlers/integration-event-dispatcher.test.js

@@ -1,209 +0,0 @@
-jest.mock('../database/config', () => ({
-    DB_TYPE: 'mongodb',
-    getDatabaseType: jest.fn(() => 'mongodb'),
-    PRISMA_LOG_LEVEL: 'error,warn',
-    PRISMA_QUERY_LOGGING: false,
-}));
-
-const { IntegrationEventDispatcher } = require('./integration-event-dispatcher');
-const { IntegrationBase } = require('../integrations/integration-base');
-
-class TestIntegration extends IntegrationBase {
-    static Definition = {
-        name: 'test-integration',
-        version: '1.0.0',
-        modules: {},
-        routes: [
-            { path: '/auth', method: 'GET', event: 'AUTH_REQUEST' },
-            { path: '/data', method: 'GET', event: 'LOAD_DATA' },
-            { path: '/job', method: 'POST', event: 'TEST_EVENT' },
-            { path: '/dynamic', method: 'GET', event: 'DYNAMIC_EVENT' },
-        ],
-    };
-
-    constructor(params) {
-        super(params);
-        this.events = {
-            AUTH_REQUEST: { handler: this.authRequest.bind(this) },
-            LOAD_DATA: { handler: this.loadData.bind(this) },
-            TEST_EVENT: { handler: this.testHandler.bind(this) },
-        };
-    }
-
-    async authRequest() {
-        TestIntegration.latestInstance = this;
-        return {
-            success: true,
-            hydrated: this.isHydrated,
-        };
-    }
-
-    async loadData() {
-        this.assertHydrated('loadData requires hydration');
-        return { success: true };
-    }
-
-    async testHandler({ data }) {
-        TestIntegration.latestInstance = this;
-        return { received: data };
-    }
-
-    async initialize() {
-        this.events = {
-            ...this.events,
-            DYNAMIC_EVENT: { handler: this.dynamicHandler.bind(this) },
-        };
-    }
-
-    async dynamicHandler() {
-        TestIntegration.latestInstance = this;
-        return { dynamic: true };
-    }
-}
-
-describe('IntegrationEventDispatcher', () => {
-    const createDispatcher = () =>
-        new IntegrationEventDispatcher(new TestIntegration());
-
-    beforeEach(() => {
-        TestIntegration.latestInstance = null;
-    });
-
-    describe('dispatchHttp', () => {
-        it('creates a stateless integration instance for HTTP events', async () => {
-            const dispatcher = createDispatcher();
-            const result = await dispatcher.dispatchHttp({
-                event: 'AUTH_REQUEST',
-                req: {},
-                res: {},
-                next: jest.fn(),
-            });
-
-            expect(result).toEqual({ success: true, hydrated: false });
-            expect(TestIntegration.latestInstance).toBeInstanceOf(TestIntegration);
-            expect(TestIntegration.latestInstance.isHydrated).toBe(false);
-        });
-
-        it('calls initialize to register dynamic events', async () => {
-            const dispatcher = createDispatcher();
-            await dispatcher.integrationInstance.initialize();
-            const result = await dispatcher.dispatchHttp({
-                event: 'DYNAMIC_EVENT',
-                req: {},
-                res: {},
-                next: jest.fn(),
-            });
-
-            expect(result).toEqual({ dynamic: true });
-            expect(TestIntegration.latestInstance).toBeInstanceOf(TestIntegration);
-        });
-
-        it('throws when requesting an unknown event', async () => {
-            const dispatcher = createDispatcher();
-            await expect(
-                dispatcher.dispatchHttp({
-                    event: 'UNKNOWN',
-                    req: {},
-                    res: {},
-                    next: jest.fn(),
-                })
-            ).rejects.toThrow('Event UNKNOWN not registered for test-integration');
-        });
-
-        it('does not hydrate automatically for handlers that require data', async () => {
-            const dispatcher = createDispatcher();
-            await expect(
-                dispatcher.dispatchHttp({
-                    event: 'LOAD_DATA',
-                    req: {},
-                    res: {},
-                    next: jest.fn(),
-                })
-            ).rejects.toThrow('loadData requires hydration');
-        });
-    });
-
-    describe('dispatchJob', () => {
-        it('creates a stateless integration instance for job events', async () => {
-            const payload = { foo: 'bar' };
-            const dispatcher = createDispatcher();
-            const result = await dispatcher.dispatchJob({
-                event: 'TEST_EVENT',
-                data: payload,
-                context: {},
-            });
-
-            expect(result).toEqual({ received: payload });
-            expect(TestIntegration.latestInstance).toBeInstanceOf(TestIntegration);
-            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/health.test.js

@@ -1,210 +0,0 @@
-process.env.HEALTH_API_KEY = 'test-api-key';
-
-jest.mock('../../database/config', () => ({
-    DB_TYPE: 'mongodb',
-    getDatabaseType: jest.fn(() => 'mongodb'),
-    PRISMA_LOG_LEVEL: 'error,warn',
-    PRISMA_QUERY_LOGGING: false,
-}));
-
-jest.mock('mongoose', () => ({
-    set: jest.fn(),
-    connection: {
-        readyState: 1,
-        db: {
-            admin: () => ({
-                ping: jest.fn().mockResolvedValue(true)
-            })
-        }
-    }
-}));
-
-jest.mock('./../backend-utils', () => ({
-    moduleFactory: {
-        moduleTypes: ['test-module', 'another-module']
-    },
-    integrationFactory: {
-        integrationTypes: ['test-integration', 'another-integration']
-    }
-}));
-
-jest.mock('./../app-handler-helpers', () => ({
-    createAppHandler: jest.fn((name, router) => ({ name, router }))
-}));
-
-const { router } = require('./health');
-const mongoose = require('mongoose');
-
-const mockRequest = (path, headers = {}) => ({
-    path,
-    headers
-});
-
-const mockResponse = () => {
-    const res = {};
-    res.status = jest.fn().mockReturnValue(res);
-    res.json = jest.fn().mockReturnValue(res);
-    return res;
-};
-
-describe('Health Check Endpoints', () => {
-    beforeEach(() => {
-        mongoose.connection.readyState = 1;
-    });
-
-    describe('Middleware - validateApiKey', () => {
-        it('should allow access to /health without authentication', async () => {
-            expect(true).toBe(true);
-        });
-    });
-
-    describe('GET /health', () => {
-        it('should return basic health status', async () => {
-            const req = mockRequest('/health');
-            const res = mockResponse();
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health'
-            ).route.stack[0].handle;
-
-            await routeHandler(req, res);
-
-            expect(res.status).toHaveBeenCalledWith(200);
-            expect(res.json).toHaveBeenCalledWith({
-                status: 'ok',
-                timestamp: expect.any(String),
-                service: 'frigg-core-api'
-            });
-        });
-    });
-
-    describe('GET /health/detailed', () => {
-        it('should return detailed health status when healthy', async () => {
-            const req = mockRequest('/health/detailed', { 'x-api-key': 'test-api-key' });
-            const res = mockResponse();
-
-            const originalPromiseAll = Promise.all;
-            Promise.all = jest.fn().mockResolvedValue([
-                { name: 'github', status: 'healthy', reachable: true, statusCode: 200, responseTime: 100 },
-                { name: 'npm', status: 'healthy', reachable: true, statusCode: 200, responseTime: 150 }
-            ]);
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health/detailed'
-            ).route.stack[0].handle;
-
-            await routeHandler(req, res);
-            
-            Promise.all = originalPromiseAll;
-
-            expect(res.status).toHaveBeenCalledWith(200);
-            expect(res.json).toHaveBeenCalledWith(expect.objectContaining({
-                status: 'healthy',
-                service: 'frigg-core-api',
-                timestamp: expect.any(String),
-                checks: expect.objectContaining({
-                    database: expect.objectContaining({
-                        status: 'healthy',
-                        state: 'connected'
-                    }),
-                    integrations: expect.objectContaining({
-                        status: 'healthy'
-                    })
-                }),
-                responseTime: expect.any(Number)
-            }));
-
-            const response = res.json.mock.calls[0][0];
-            expect(response).not.toHaveProperty('version');
-            expect(response).not.toHaveProperty('uptime');
-            expect(response.checks).not.toHaveProperty('memory');
-            expect(response.checks.database).not.toHaveProperty('type');
-        });
-
-        it('should return 503 when database is disconnected', async () => {
-            mongoose.connection.readyState = 0;
-
-            const req = mockRequest('/health/detailed', { 'x-api-key': 'test-api-key' });
-            const res = mockResponse();
-
-            const originalPromiseAll = Promise.all;
-            Promise.all = jest.fn().mockResolvedValue([
-                { name: 'github', status: 'healthy', reachable: true, statusCode: 200, responseTime: 100 },
-                { name: 'npm', status: 'healthy', reachable: true, statusCode: 200, responseTime: 150 }
-            ]);
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health/detailed'
-            ).route.stack[0].handle;
-
-            await routeHandler(req, res);
-            
-            Promise.all = originalPromiseAll;
-
-            expect(res.status).toHaveBeenCalledWith(503);
-            expect(res.json).toHaveBeenCalledWith(expect.objectContaining({
-                status: 'unhealthy'
-            }));
-        });
-    });
-
-    describe('GET /health/live', () => {
-        it('should return alive status', async () => {
-            const req = mockRequest('/health/live', { 'x-api-key': 'test-api-key' });
-            const res = mockResponse();
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health/live'
-            ).route.stack[0].handle;
-
-            routeHandler(req, res);
-
-            expect(res.status).toHaveBeenCalledWith(200);
-            expect(res.json).toHaveBeenCalledWith({
-                status: 'alive',
-                timestamp: expect.any(String)
-            });
-        });
-    });
-
-    describe('GET /health/ready', () => {
-        it('should return ready when all checks pass', async () => {
-            const req = mockRequest('/health/ready', { 'x-api-key': 'test-api-key' });
-            const res = mockResponse();
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health/ready'
-            ).route.stack[0].handle;
-
-            await routeHandler(req, res);
-
-            expect(res.status).toHaveBeenCalledWith(200);
-            expect(res.json).toHaveBeenCalledWith({
-                ready: true,
-                timestamp: expect.any(String),
-                checks: {
-                    database: true,
-                    modules: true
-                }
-            });
-        });
-
-        it('should return 503 when database is not connected', async () => {
-            mongoose.connection.readyState = 0;
-
-            const req = mockRequest('/health/ready', { 'x-api-key': 'test-api-key' });
-            const res = mockResponse();
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health/ready'
-            ).route.stack[0].handle;
-
-            await routeHandler(req, res);
-
-            expect(res.status).toHaveBeenCalledWith(503);
-            expect(res.json).toHaveBeenCalledWith(expect.objectContaining({
-                ready: false
-            }));
-        });
-    });
-});

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

@@ -1,126 +0,0 @@
-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();
-        });
-    });
-});
-