@friggframework/core 2.0.0--canary.397.e634da9.0 → 2.0.0--canary.398.ad248a6.0

package/integrations/tests/use-cases/get-possible-integrations.test.js

@@ -1,188 +0,0 @@
-const { GetPossibleIntegrations } = require('../../use-cases/get-possible-integrations');
-const { DummyIntegration } = require('../doubles/dummy-integration-class');
-
-describe('GetPossibleIntegrations Use-Case', () => {
-    describe('happy path', () => {
-        it('returns option details array for single integration', async () => {
-            const useCase = new GetPossibleIntegrations({ integrationClasses: [DummyIntegration] });
-            const result = await useCase.execute();
-
-            expect(Array.isArray(result)).toBe(true);
-            expect(result.length).toBe(1);
-            expect(result[0].display).toBeDefined();
-            expect(result[0].display.label).toBe('Dummy Integration');
-            expect(result[0].display.description).toBe('A dummy integration for testing');
-            expect(result[0].name).toBe('dummy');
-            expect(result[0].version).toBe('1.0.0');
-        });
-
-        it('returns multiple integration options', async () => {
-            class AnotherDummyIntegration {
-                static Definition = {
-                    name: 'another-dummy',
-                    version: '2.0.0',
-                    modules: { dummy: {} },
-                    display: {
-                        label: 'Another Dummy',
-                        description: 'Another test integration',
-                        detailsUrl: 'https://another.example.com',
-                        icon: 'another-icon'
-                    }
-                };
-
-                static getOptionDetails() {
-                    return {
-                        name: this.Definition.name,
-                        version: this.Definition.version,
-                        display: this.Definition.display
-                    };
-                }
-            }
-
-            const useCase = new GetPossibleIntegrations({
-                integrationClasses: [DummyIntegration, AnotherDummyIntegration]
-            });
-            const result = await useCase.execute();
-
-            expect(result.length).toBe(2);
-            expect(result[0].name).toBe('dummy');
-            expect(result[1].name).toBe('another-dummy');
-        });
-
-        it('includes all required display properties', async () => {
-            const useCase = new GetPossibleIntegrations({ integrationClasses: [DummyIntegration] });
-            const result = await useCase.execute();
-
-            const integration = result[0];
-            expect(integration.display.label).toBeDefined();
-            expect(integration.display.description).toBeDefined();
-            expect(integration.display.detailsUrl).toBeDefined();
-            expect(integration.display.icon).toBeDefined();
-        });
-    });
-
-    describe('error cases', () => {
-        it('returns empty array when no integration classes provided', async () => {
-            const useCase = new GetPossibleIntegrations({ integrationClasses: [] });
-            const result = await useCase.execute();
-
-            expect(Array.isArray(result)).toBe(true);
-            expect(result.length).toBe(0);
-        });
-
-        it('handles integration class without getOptionDetails method', async () => {
-            class InvalidIntegration {
-                static Definition = { name: 'invalid' };
-            }
-
-            const useCase = new GetPossibleIntegrations({ integrationClasses: [InvalidIntegration] });
-
-            await expect(useCase.execute()).rejects.toThrow();
-        });
-
-        it('handles integration class with incomplete Definition', async () => {
-            class IncompleteIntegration {
-                static Definition = {
-                    name: 'incomplete',
-                    modules: { dummy: {} }
-                };
-
-                static getOptionDetails() {
-                    return {
-                        name: this.Definition.name,
-                        version: this.Definition.version,
-                        display: this.Definition.display
-                    };
-                }
-            }
-
-            const useCase = new GetPossibleIntegrations({ integrationClasses: [IncompleteIntegration] });
-            const result = await useCase.execute();
-
-            expect(result.length).toBe(1);
-            expect(result[0].name).toBe('incomplete');
-            expect(result[0].display).toBeUndefined();
-        });
-    });
-
-    describe('edge cases', () => {
-        it('handles null integrationClasses parameter', async () => {
-            const useCase = new GetPossibleIntegrations({ integrationClasses: null });
-
-            await expect(useCase.execute()).rejects.toThrow();
-        });
-
-        it('handles undefined integrationClasses parameter', async () => {
-            const useCase = new GetPossibleIntegrations({ integrationClasses: undefined });
-
-            await expect(useCase.execute()).rejects.toThrow();
-        });
-
-        it('filters out null/undefined integration classes', async () => {
-            const useCase = new GetPossibleIntegrations({
-                integrationClasses: [DummyIntegration, null, undefined].filter(Boolean)
-            });
-            const result = await useCase.execute();
-
-            expect(result.length).toBe(1);
-            expect(result[0].name).toBe('dummy');
-        });
-
-        it('handles integration with complex display properties', async () => {
-            class ComplexIntegration {
-                static Definition = {
-                    name: 'complex',
-                    version: '3.0.0',
-                    modules: { dummy: {} },
-                    display: {
-                        label: 'Complex Integration with Special Characters! 🚀',
-                        description: 'A very long description that includes\nnewlines and\ttabs and special characters like émojis 🎉',
-                        detailsUrl: 'https://complex.example.com/with/path?param=value&other=123',
-                        icon: 'data:image/svg+xml;base64,PHN2Zz48L3N2Zz4=',
-                        category: 'Test & Development',
-                        tags: ['testing', 'development', 'complex']
-                    }
-                };
-
-                static getOptionDetails() {
-                    return {
-                        name: this.Definition.name,
-                        version: this.Definition.version,
-                        display: this.Definition.display
-                    };
-                }
-            }
-
-            const useCase = new GetPossibleIntegrations({ integrationClasses: [ComplexIntegration] });
-            const result = await useCase.execute();
-
-            expect(result[0].display.label).toContain('🚀');
-            expect(result[0].display.description).toContain('🎉');
-            expect(result[0].display.detailsUrl).toContain('?param=value');
-        });
-
-        it('preserves integration class order', async () => {
-            class FirstIntegration {
-                static Definition = { name: 'first', version: '1.0.0', modules: { dummy: {} }, display: { label: 'First' } };
-                static getOptionDetails() { return { name: this.Definition.name, version: this.Definition.version, display: this.Definition.display }; }
-            }
-            class SecondIntegration {
-                static Definition = { name: 'second', version: '1.0.0', modules: { dummy: {} }, display: { label: 'Second' } };
-                static getOptionDetails() { return { name: this.Definition.name, version: this.Definition.version, display: this.Definition.display }; }
-            }
-            class ThirdIntegration {
-                static Definition = { name: 'third', version: '1.0.0', modules: { dummy: {} }, display: { label: 'Third' } };
-                static getOptionDetails() { return { name: this.Definition.name, version: this.Definition.version, display: this.Definition.display }; }
-            }
-
-            const useCase = new GetPossibleIntegrations({
-                integrationClasses: [FirstIntegration, SecondIntegration, ThirdIntegration]
-            });
-            const result = await useCase.execute();
-
-            expect(result[0].name).toBe('first');
-            expect(result[1].name).toBe('second');
-            expect(result[2].name).toBe('third');
-        });
-    });
-}); 

package/integrations/tests/use-cases/update-integration-messages.test.js

@@ -1,142 +0,0 @@
-const { UpdateIntegrationMessages } = require('../../use-cases/update-integration-messages');
-const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
-
-describe('UpdateIntegrationMessages Use-Case', () => {
-    let integrationRepository;
-    let useCase;
-
-    beforeEach(() => {
-        integrationRepository = new TestIntegrationRepository();
-        useCase = new UpdateIntegrationMessages({ integrationRepository });
-    });
-
-    describe('happy path', () => {
-        it('adds message with correct details', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-            const timestamp = Date.now();
-
-            await useCase.execute(record.id, 'errors', 'Test Error', 'Error details here', timestamp);
-
-            const fetched = await integrationRepository.findIntegrationById(record.id);
-            expect(fetched.messages.errors.length).toBe(1);
-            expect(fetched.messages.errors[0]).toEqual({
-                title: 'Test Error',
-                message: 'Error details here',
-                timestamp: timestamp
-            });
-        });
-
-        it('adds multiple messages to same type', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await useCase.execute(record.id, 'errors', 'Error 1', 'First error', 1000);
-            await useCase.execute(record.id, 'errors', 'Error 2', 'Second error', 2000);
-
-            const fetched = await integrationRepository.findIntegrationById(record.id);
-            expect(fetched.messages.errors.length).toBe(2);
-            expect(fetched.messages.errors[0].title).toBe('Error 1');
-            expect(fetched.messages.errors[1].title).toBe('Error 2');
-        });
-
-        it('adds messages to different types', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await useCase.execute(record.id, 'errors', 'Error Title', 'Error body', 1000);
-            await useCase.execute(record.id, 'warnings', 'Warning Title', 'Warning body', 2000);
-            await useCase.execute(record.id, 'info', 'Info Title', 'Info body', 3000);
-
-            const fetched = await integrationRepository.findIntegrationById(record.id);
-            expect(fetched.messages.errors.length).toBe(1);
-            expect(fetched.messages.warnings.length).toBe(1);
-            expect(fetched.messages.info.length).toBe(1);
-        });
-
-        it('tracks message update operation', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-            integrationRepository.clearHistory();
-
-            await useCase.execute(record.id, 'logs', 'Log Entry', 'Log details', Date.now());
-
-            const history = integrationRepository.getOperationHistory();
-            const updateOperation = history.find(op => op.operation === 'updateMessages');
-            expect(updateOperation).toEqual({
-                operation: 'updateMessages',
-                id: record.id,
-                type: 'logs',
-                success: true
-            });
-        });
-    });
-
-    describe('error cases', () => {
-        it('returns false when integration not found', async () => {
-            const nonExistentId = 'non-existent-id';
-
-            const result = await useCase.execute(nonExistentId, 'errors', 'title', 'body', Date.now());
-
-            expect(result).toBe(false);
-        });
-
-        it('tracks failed message update operation', async () => {
-            const nonExistentId = 'non-existent-id';
-            integrationRepository.clearHistory();
-
-            await useCase.execute(nonExistentId, 'errors', 'title', 'body', Date.now());
-
-            const history = integrationRepository.getOperationHistory();
-            const updateOperation = history.find(op => op.operation === 'updateMessages');
-            expect(updateOperation).toEqual({
-                operation: 'updateMessages',
-                id: nonExistentId,
-                success: false
-            });
-        });
-    });
-
-    describe('edge cases', () => {
-        it('handles empty title and body', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await useCase.execute(record.id, 'info', '', '', Date.now());
-
-            const fetched = await integrationRepository.findIntegrationById(record.id);
-            expect(fetched.messages.info[0].title).toBe('');
-            expect(fetched.messages.info[0].message).toBe('');
-        });
-
-        it('handles null and undefined values', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await useCase.execute(record.id, 'warnings', null, undefined, null);
-
-            const fetched = await integrationRepository.findIntegrationById(record.id);
-            expect(fetched.messages.warnings[0].title).toBeNull();
-            expect(fetched.messages.warnings[0].message).toBeUndefined();
-            expect(fetched.messages.warnings[0].timestamp).toBeNull();
-        });
-
-        it('handles very long message content', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-            const longTitle = 'A'.repeat(1000);
-            const longBody = 'B'.repeat(5000);
-
-            await useCase.execute(record.id, 'errors', longTitle, longBody, Date.now());
-
-            const fetched = await integrationRepository.findIntegrationById(record.id);
-            expect(fetched.messages.errors[0].title).toBe(longTitle);
-            expect(fetched.messages.errors[0].message).toBe(longBody);
-        });
-
-        it('handles special characters in messages', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-            const specialTitle = '🚨 Error with émojis & spëcial chars';
-            const specialBody = 'Body with\nnewlines\tand\ttabs';
-
-            await useCase.execute(record.id, 'errors', specialTitle, specialBody, Date.now());
-
-            const fetched = await integrationRepository.findIntegrationById(record.id);
-            expect(fetched.messages.errors[0].title).toBe(specialTitle);
-            expect(fetched.messages.errors[0].message).toBe(specialBody);
-        });
-    });
-}); 

package/integrations/tests/use-cases/update-integration-status.test.js

@@ -1,103 +0,0 @@
-const { UpdateIntegrationStatus } = require('../../use-cases/update-integration-status');
-const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
-
-describe('UpdateIntegrationStatus Use-Case', () => {
-    let integrationRepository;
-    let useCase;
-
-    beforeEach(() => {
-        integrationRepository = new TestIntegrationRepository();
-        useCase = new UpdateIntegrationStatus({
-            integrationRepository,
-        });
-    });
-
-    describe('happy path', () => {
-        it('updates integration status', async () => {
-            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
-
-            const result = await useCase.execute(record.id, 'ACTIVE');
-
-            expect(result).toBe(true);
-
-            const updatedRecord = await integrationRepository.findIntegrationById(record.id);
-            expect(updatedRecord.status).toBe('ACTIVE');
-        });
-
-        it('tracks status update operation', async () => {
-            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
-            integrationRepository.clearHistory();
-
-            await useCase.execute(record.id, 'PAUSED');
-
-            const history = integrationRepository.getOperationHistory();
-            const updateOperation = history.find(op => op.operation === 'updateStatus');
-            expect(updateOperation).toEqual({
-                operation: 'updateStatus',
-                id: record.id,
-                status: 'PAUSED',
-                success: true
-            });
-        });
-
-        it('handles different status values', async () => {
-            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
-
-            const statuses = ['ACTIVE', 'PAUSED', 'ERROR', 'DISABLED'];
-
-            for (const status of statuses) {
-                await useCase.execute(record.id, status);
-                const updatedRecord = await integrationRepository.findIntegrationById(record.id);
-                expect(updatedRecord.status).toBe(status);
-            }
-        });
-    });
-
-    describe('error cases', () => {
-        it('returns false when integration not found', async () => {
-            const nonExistentId = 'non-existent-id';
-
-            const result = await useCase.execute(nonExistentId, 'ACTIVE');
-
-            expect(result).toBe(false);
-        });
-
-        it('tracks failed update operation', async () => {
-            const nonExistentId = 'non-existent-id';
-            integrationRepository.clearHistory();
-
-            await useCase.execute(nonExistentId, 'ACTIVE');
-
-            const history = integrationRepository.getOperationHistory();
-            const updateOperation = history.find(op => op.operation === 'updateStatus');
-            expect(updateOperation).toEqual({
-                operation: 'updateStatus',
-                id: nonExistentId,
-                status: 'ACTIVE',
-                success: false
-            });
-        });
-    });
-
-    describe('edge cases', () => {
-        it('handles null status value', async () => {
-            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
-
-            const result = await useCase.execute(record.id, null);
-
-            expect(result).toBe(true);
-            const updatedRecord = await integrationRepository.findIntegrationById(record.id);
-            expect(updatedRecord.status).toBeNull();
-        });
-
-        it('handles empty string status', async () => {
-            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
-
-            const result = await useCase.execute(record.id, '');
-
-            expect(result).toBe(true);
-            const updatedRecord = await integrationRepository.findIntegrationById(record.id);
-            expect(updatedRecord.status).toBe('');
-        });
-    });
-});

package/integrations/tests/use-cases/update-integration.test.js

@@ -1,134 +0,0 @@
-const { UpdateIntegration } = require('../../use-cases/update-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('UpdateIntegration Use-Case', () => {
-    let integrationRepository;
-    let moduleFactory;
-    let useCase;
-
-    beforeEach(() => {
-        integrationRepository = new TestIntegrationRepository();
-        moduleFactory = new TestModuleFactory();
-        useCase = new UpdateIntegration({
-            integrationRepository,
-            integrationClasses: [DummyIntegration],
-            moduleFactory,
-        });
-    });
-
-    describe('happy path', () => {
-        it('calls on update and returns dto', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy', foo: 'bar' });
-
-            const newConfig = { type: 'dummy', foo: 'baz' };
-            const dto = await useCase.execute(record.id, 'user-1', newConfig);
-
-            expect(dto.config.foo).toBe('baz');
-            expect(dto.id).toBe(record.id);
-            expect(dto.userId).toBe('user-1');
-        });
-
-        it('triggers ON_UPDATE event with correct payload', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy', foo: 'bar' });
-            integrationRepository.clearHistory();
-
-            const newConfig = { type: 'dummy', foo: 'updated' };
-            await useCase.execute(record.id, 'user-1', newConfig);
-
-            const history = integrationRepository.getOperationHistory();
-            const findOperation = history.find(op => op.operation === 'findById');
-            expect(findOperation).toEqual({
-                operation: 'findById',
-                id: record.id,
-                found: true
-            });
-        });
-
-        it('updates integration with multiple entities', async () => {
-            const record = await integrationRepository.createIntegration(['e1', 'e2'], 'user-1', { type: 'dummy' });
-
-            const newConfig = { type: 'dummy', updated: true };
-            const dto = await useCase.execute(record.id, 'user-1', newConfig);
-
-            expect(dto.entities).toEqual(['e1', 'e2']);
-            expect(dto.config.updated).toBe(true);
-        });
-    });
-
-    describe('error cases', () => {
-        it('throws error when integration not found', async () => {
-            const nonExistentId = 'non-existent-id';
-            const newConfig = { type: 'dummy', foo: 'baz' };
-
-            await expect(useCase.execute(nonExistentId, 'user-1', newConfig))
-                .rejects
-                .toThrow(`No integration found by the ID of ${nonExistentId}`);
-        });
-
-        it('throws error when integration class not found', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'unknown-type' });
-
-            const newConfig = { type: 'unknown-type', foo: 'baz' };
-
-            await expect(useCase.execute(record.id, 'user-1', newConfig))
-                .rejects
-                .toThrow('No integration class found for type: unknown-type');
-        });
-
-        it('throws error when user does not own integration', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            const newConfig = { type: 'dummy', foo: 'baz' };
-
-            await expect(useCase.execute(record.id, 'different-user', newConfig))
-                .rejects
-                .toThrow(`Integration ${record.id} does not belong to User different-user`);
-        });
-
-        it('throws error when no integration classes provided', async () => {
-            const useCaseWithoutClasses = new UpdateIntegration({
-                integrationRepository,
-                integrationClasses: [],
-                moduleFactory,
-            });
-
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-            const newConfig = { type: 'dummy', foo: 'baz' };
-
-            await expect(useCaseWithoutClasses.execute(record.id, 'user-1', newConfig))
-                .rejects
-                .toThrow('No integration class found for type: dummy');
-        });
-    });
-
-    describe('edge cases', () => {
-        it('handles config with null values', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy', foo: 'bar' });
-
-            const newConfig = { type: 'dummy', foo: null, bar: undefined };
-            const dto = await useCase.execute(record.id, 'user-1', newConfig);
-
-            expect(dto.config.foo).toBeNull();
-            expect(dto.config.bar).toBeUndefined();
-        });
-
-        it('handles deeply nested config updates', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy', nested: { old: 'value' } });
-
-            const newConfig = {
-                type: 'dummy',
-                nested: {
-                    new: 'value',
-                    deep: { level: 'test' }
-                }
-            };
-            const dto = await useCase.execute(record.id, 'user-1', newConfig);
-
-            expect(dto.config.nested.new).toBe('value');
-            expect(dto.config.nested.deep.level).toBe('test');
-            expect(dto.config.nested.old).toBeUndefined();
-        });
-    });
-}); 

package/integrations/use-cases/create-integration.js

@@ -1,71 +0,0 @@
-// Removed Integration wrapper - using IntegrationBase directly
-const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
-
-/**
- * Use case for creating a new integration instance.
- * @class CreateIntegration
- */
-class CreateIntegration {
-    /**
-     * Creates a new CreateIntegration instance.
-     * @param {Object} params - Configuration parameters.
-     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data operations.
-     * @param {import('../integration-classes').IntegrationClasses} params.integrationClasses - Array of available integration classes.
-     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management.
-     */
-    constructor({ integrationRepository, integrationClasses, moduleFactory }) {
-        this.integrationRepository = integrationRepository;
-        this.integrationClasses = integrationClasses;
-        this.moduleFactory = moduleFactory;
-    }
-
-    /**
-     * Executes the integration creation process.
-     * @async
-     * @param {string[]} entities - Array of entity IDs to associate with the integration.
-     * @param {string} userId - ID of the user creating the integration.
-     * @param {Object} config - Configuration object for the integration.
-     * @param {string} config.type - Type of integration to create.
-     * @returns {Promise<Object>} The created integration DTO.
-     * @throws {Error} When integration class is not found for the specified type.
-     */
-    async execute(entities, userId, config) {
-        const integrationRecord = await this.integrationRepository.createIntegration(entities, userId, config);
-
-
-        const integrationClass = this.integrationClasses.find(
-            (integrationClass) => integrationClass.Definition.name === integrationRecord.config.type
-        );
-
-        if (!integrationClass) {
-            throw new Error(`No integration class found for type: ${integrationRecord.config.type}`);
-        }
-
-        const modules = [];
-        for (const entityId of integrationRecord.entitiesIds) {
-            const moduleInstance = await this.moduleFactory.getModuleInstance(
-                entityId,
-                integrationRecord.userId
-            );
-            modules.push(moduleInstance);
-        }
-
-        const integrationInstance = new integrationClass({
-            id: integrationRecord.id,
-            userId: integrationRecord.userId,
-            entities: integrationRecord.entitiesIds,
-            config: integrationRecord.config,
-            status: integrationRecord.status,
-            version: integrationRecord.version,
-            messages: integrationRecord.messages,
-            modules
-        });
-
-        await integrationInstance.initialize();
-        await integrationInstance.send('ON_CREATE', { integrationId: integrationRecord.id });
-
-        return mapIntegrationClassToIntegrationDTO(integrationInstance);
-    }
-}
-
-module.exports = { CreateIntegration };