npm - @friggframework/core - Versions diffs - 2.0.0--canary.461.61382d8.0 → 2.0.0--canary.461.3d6d8ad.0 - Mend

@friggframework/core 2.0.0--canary.461.61382d8.0 → 2.0.0--canary.461.3d6d8ad.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (120) hide show

package/errors/fetch-error.test.js DELETED Viewed

@@ -1,79 +0,0 @@
-const fetch = require('node-fetch');
-const { stripIndent } = require('common-tags');
-const { FetchError } = require('./fetch-error');
-const FormData = require('form-data');
-describe('FetchError', () => {
-    it('can be instantiated with default arguments', () => {
-        const error = new FetchError();
-        expect(error).toHaveProperty('message');
-        expect(error).not.toHaveProperty('cause');
-    });
-    it('can be created asynchronously with default values', async () => {
-        const error = await FetchError.create();
-        expect(error).toHaveProperty('message');
-        expect(error).not.toHaveProperty('cause');
-    });
-    it('can be created asynchronously', async () => {
-        const resource = 'http://example.com';
-        const init = {};
-        const response = {
-            status: 500,
-            statusText: 'Space aliens!',
-            headers: Object.entries({ 'cache-control': '123' }), // needs to be an Iterable
-            text: async () => '<!doctype html>',
-        };
-        const error = await FetchError.create({
-            resource,
-            init,
-            response,
-        });
-        expect(error).toHaveProperty('message');
-        expect(error.message).toContain('GET http://example.com');
-        expect(error.message).toContain('500 Space aliens!');
-        expect(error.message).toContain('"cache-control": "123"');
-        expect(error.message).toContain('<!doctype html>');
-    });
-    it('can be passed an object for the body', async () => {
-        const error = new FetchError({ responseBody: { test: true } });
-        expect(error).toHaveProperty('message');
-        expect(error.message).toContain('"test": true');
-    });
-    it('ignores response body if already streamed', async () => {
-        const response = { bodyUsed: true };
-        const error = await FetchError.create({ response });
-        expect(error).toHaveProperty('message');
-        expect(error.message).toContain('<response body is unavailable>');
-    });
-    it.only('prints a formData body legibly', async () => {
-        const response = {
-            status: 500,
-            statusText: 'Space aliens!',
-            headers: Object.entries({ 'cache-control': '123' }), // needs to be an Iterable
-            text: async () => '<!doctype html>',
-        };
-        const params = new URLSearchParams();
-        params.append('test', 'test');
-        const init = {
-            method: 'POST',
-            credentials: 'include',
-            headers: {},
-            query: {},
-            body: params,
-            returnFullRes: false,
-        };
-        const error = await FetchError.create({ response, init });
-        expect(error).toHaveProperty('message');
-        expect(error.message).toContain('test=test');
-    });
-});

package/errors/halt-error.test.js DELETED Viewed

@@ -1,11 +0,0 @@
-const { HaltError } = require('./halt-error');
-describe('HaltError', () => {
-    it('can be instantiated', () => {
-        const rootError = new Error('Gremlinoids!!');
-        const error = new HaltError('STOP', { cause: rootError });
-        expect(error).toHaveProperty('message', 'STOP');
-        expect(error).toHaveProperty('cause', rootError);
-        expect(error).toHaveProperty('isHaltError', true);
-    });
-});

package/errors/validation-errors.test.js DELETED Viewed

@@ -1,120 +0,0 @@
-const {
-    RequiredPropertyError,
-    ParameterTypeError,
-} = require('./validation-errors');
-describe('RequiredPropertyError', () => {
-    it('can be instantiated with default arguments', () => {
-        const error = new RequiredPropertyError();
-        expect(error).toHaveProperty(
-            'message',
-            'Key "" is a required parameter.'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-    it('allows setting the key name of the error', () => {
-        const error = new RequiredPropertyError({ key: 'abc' });
-        expect(error).toHaveProperty(
-            'message',
-            'Key "abc" is a required parameter.'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-    it('allows setting the parent of the error', () => {
-        const error = new RequiredPropertyError({ parent: class Xyz {} });
-        expect(error).toHaveProperty(
-            'message',
-            '(Xyz) Key "" is a required parameter.'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-    it('passes cause through to the Error parent class', () => {
-        const error = new RequiredPropertyError(
-            {
-                parent: class Qrs {},
-                key: 'def',
-            },
-            { cause: new Error('Gremlins!!') }
-        );
-        const expectedMessage = '(Qrs) Key "def" is a required parameter.';
-        expect(error).toHaveProperty('message', expectedMessage);
-        expect(error).toHaveProperty('cause');
-        expect(error.cause).toHaveProperty('message', 'Gremlins!!');
-    });
-});
-describe('ParameterTypeError', () => {
-    it('can be instantiated with default arguments', () => {
-        const error = new ParameterTypeError();
-        expect(error).toHaveProperty(
-            'message',
-            'Expected value "" to be of type ""'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-    it('allows setting the key name of the error', () => {
-        const error = new ParameterTypeError({ key: 'abc' });
-        expect(error).toHaveProperty(
-            'message',
-            'Expected key "abc" with value "" to be of type ""'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-    it('allows setting the parent of the error', () => {
-        const error = new ParameterTypeError({ parent: class Xyz {} });
-        expect(error).toHaveProperty(
-            'message',
-            '(Xyz) Expected value "" to be of type ""'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-    it('allows setting the value of the error', () => {
-        const error = new ParameterTypeError({ value: 1 });
-        expect(error).toHaveProperty(
-            'message',
-            'Expected value "1" to be of type ""'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-    it('allows setting the expected type of the error', () => {
-        const error = new ParameterTypeError({ expectedType: class Xyz {} });
-        expect(error).toHaveProperty(
-            'message',
-            'Expected value "" to be of type "Xyz"'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-    it('allows setting the expected type of the error to Array', () => {
-        const error = new ParameterTypeError({ expectedType: Array });
-        expect(error).toHaveProperty(
-            'message',
-            'Expected value "" to be of type "Array"'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-    it('passes cause through to the Error parent class', () => {
-        const rootError = new Error('Gremlins!!');
-        const error = new ParameterTypeError(
-            {
-                parent: class Parent {},
-                key: 'clé',
-                expectedType: class Expected {},
-                value: 'schmalue',
-            },
-            { cause: rootError }
-        );
-        const expectedMessage =
-            '(Parent) Expected key "clé" with value "schmalue" to be of type "Expected"';
-        expect(error).toHaveProperty('message', expectedMessage);
-        expect(error).toHaveProperty('cause', rootError);
-    });
-});

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

@@ -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 DELETED Viewed

@@ -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/db-migration.test.js DELETED Viewed

@@ -1,51 +0,0 @@
-/**
- * Adapter Layer Tests - Database Migration Router
- *
- * CRITICAL TEST: Verify handler loads without app definition
- *
- * Business logic is tested in:
- * - database/use-cases/trigger-database-migration-use-case.test.js (14 tests)
- * - database/use-cases/get-migration-status-use-case.test.js (11 tests)
- *
- * Following hexagonal architecture principles:
- * - Handlers are thin adapters (HTTP → Use Case → HTTP)
- * - Use cases contain all business logic (fully tested)
- * - Repositories are infrastructure adapters (tested separately)
- */
-process.env.ADMIN_API_KEY = 'test-admin-key';
-process.env.DB_MIGRATION_QUEUE_URL = 'https://sqs.test/queue';
-// Mock infrastructure dependencies to prevent app definition loading
-jest.mock('../../integrations/repositories/process-repository-postgres', () => ({
-    ProcessRepositoryPostgres: jest.fn(() => ({
-        create: jest.fn(),
-        findById: jest.fn(),
-    })),
-}));
-describe('Database Migration Router - Adapter Layer', () => {
-    it('should load without requiring app definition (critical bug fix)', () => {
-        // Before fix: createProcessRepository() → getDatabaseType() → loads app definition → requires integrations → CRASH
-        // After fix: ProcessRepositoryPostgres instantiated directly → no app definition → SUCCESS
-        expect(() => {
-            require('./db-migration');
-        }).not.toThrow();
-    });
-    it('should export handler and router', () => {
-        const { handler, router } = require('./db-migration');
-        expect(typeof handler).toBe('function');
-        expect(typeof router).toBe('function');
-        expect(router.stack).toBeDefined();
-    });
-    it('should hardcode dbType as postgresql (migrations are PostgreSQL-only)', () => {
-        // Migration infrastructure is only created for PostgreSQL deployments
-        // So we can safely hardcode dbType instead of requiring it from request
-        const router = require('./db-migration').router;
-        expect(router).toBeDefined();
-        // Test will pass if handler doesn't crash when dbType is omitted from request
-    });
-});