@friggframework/core 2.0.0-next.44 → 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,141 +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);
-        });
-    });
-});

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