@friggframework/core 2.0.0--canary.398.53eac55.0 → 2.0.0--canary.397.878fefa.0

package/integrations/tests/use-cases/get-integration-for-user.test.js

@@ -0,0 +1,143 @@
+const { GetIntegrationForUser } = require('../../use-cases/get-integration-for-user');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
+const { TestModuleRepository } = require('../../../modules/tests/doubles/test-module-repository');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('GetIntegrationForUser Use-Case', () => {
+    let integrationRepository;
+    let moduleRepository;
+    let moduleFactory;
+    let useCase;
+
+    beforeEach(() => {
+        integrationRepository = new TestIntegrationRepository();
+        moduleRepository = new TestModuleRepository();
+        moduleFactory = new TestModuleFactory();
+        useCase = new GetIntegrationForUser({
+            integrationRepository,
+            integrationClasses: [DummyIntegration],
+            moduleFactory,
+            moduleRepository,
+        });
+    });
+
+    describe('happy path', () => {
+        it('returns integration dto', async () => {
+            const entity = { id: 'entity-1', _id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+
+            const record = await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+            const dto = await useCase.execute(record.id, 'user-1');
+            expect(dto.id).toBe(record.id);
+            expect(dto.userId).toBe('user-1');
+            expect(dto.config.type).toBe('dummy');
+        });
+
+        it('returns integration with multiple entities', async () => {
+            const entity1 = { id: 'entity-1', _id: 'entity-1' };
+            const entity2 = { id: 'entity-2', _id: 'entity-2' };
+            moduleRepository.addEntity(entity1);
+            moduleRepository.addEntity(entity2);
+
+            const record = await integrationRepository.createIntegration([entity1.id, entity2.id], 'user-1', { type: 'dummy' });
+
+            const dto = await useCase.execute(record.id, 'user-1');
+            expect(dto.entities).toEqual([entity1, entity2]);
+        });
+
+        it('returns integration with complex config', async () => {
+            const entity = { id: 'entity-1', _id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+
+            const complexConfig = {
+                type: 'dummy',
+                settings: { api: { timeout: 5000 }, debug: true },
+                features: ['webhooks', 'sync']
+            };
+
+            const record = await integrationRepository.createIntegration([entity.id], 'user-1', complexConfig);
+
+            const dto = await useCase.execute(record.id, 'user-1');
+            expect(dto.config).toEqual(complexConfig);
+        });
+    });
+
+    describe('error cases', () => {
+        it('throws error when integration not found', async () => {
+            const nonExistentId = 'non-existent-id';
+
+            await expect(useCase.execute(nonExistentId, 'user-1'))
+                .rejects
+                .toThrow();
+        });
+
+        it('throws error when user does not own integration', async () => {
+            const entity = { id: 'entity-1', _id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+
+            const record = await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+            await expect(useCase.execute(record.id, 'different-user'))
+                .rejects
+                .toThrow();
+        });
+
+        it('throws error when integration class not found', async () => {
+            const useCaseWithoutClasses = new GetIntegrationForUser({
+                integrationRepository,
+                integrationClasses: [],
+                moduleFactory,
+                moduleRepository,
+            });
+
+            const entity = { id: 'entity-1', _id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+
+            const record = await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+            await expect(useCaseWithoutClasses.execute(record.id, 'user-1'))
+                .rejects
+                .toThrow();
+        });
+
+        it('handles missing entities gracefully', async () => {
+            const record = await integrationRepository.createIntegration(['missing-entity'], 'user-1', { type: 'dummy' });
+
+            await expect(useCase.execute(record.id, 'user-1'))
+                .rejects
+                .toThrow();
+        });
+    });
+
+    describe('edge cases', () => {
+        it('handles userId as string vs number comparison', async () => {
+            const entity = { id: 'entity-1', _id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+
+            const record = await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+            const dto1 = await useCase.execute(record.id, 'user-1');
+            const dto2 = await useCase.execute(record.id, 'user-1');
+
+            expect(dto1.userId).toBe(dto2.userId);
+        });
+
+        it('returns all integration properties', async () => {
+            const entity = { id: 'entity-1', _id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+
+            const record = await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+            record.status = 'ACTIVE';
+            record.version = '1.0.0';
+            record.messages = { info: [{ title: 'Test', message: 'Message' }] };
+
+            const dto = await useCase.execute(record.id, 'user-1');
+            expect(dto.status).toBe('ACTIVE');
+            expect(dto.version).toBe('1.0.0');
+            expect(dto.messages).toEqual({ info: [{ title: 'Test', message: 'Message' }] });
+        });
+    });
+}); 

package/integrations/tests/use-cases/get-integration-instance.test.js

@@ -0,0 +1,169 @@
+const { GetIntegrationInstance } = require('../../use-cases/get-integration-instance');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('GetIntegrationInstance Use-Case', () => {
+    let integrationRepository;
+    let moduleFactory;
+    let useCase;
+
+    beforeEach(() => {
+        integrationRepository = new TestIntegrationRepository();
+        moduleFactory = new TestModuleFactory();
+        useCase = new GetIntegrationInstance({
+            integrationRepository,
+            integrationClasses: [DummyIntegration],
+            moduleFactory,
+        });
+    });
+
+    describe('happy path', () => {
+        it('returns hydrated integration instance', async () => {
+            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
+
+            const instance = await useCase.execute(record.id, 'user-1');
+
+            expect(instance.id).toBe(record.id);
+            expect(instance.getConfig().type).toBe('dummy');
+            expect(instance.entities).toEqual(record.entitiesIds);
+            expect(instance.userId).toBe('user-1');
+        });
+
+        it('returns instance with multiple modules', async () => {
+            const record = await integrationRepository.createIntegration(['entity-1', 'entity-2'], 'user-1', { type: 'dummy' });
+
+            const instance = await useCase.execute(record.id, 'user-1');
+
+            expect(instance.entities).toEqual(['entity-1', 'entity-2']);
+            expect(Object.keys(instance.modules)).toHaveLength(1);
+            expect(instance.modules['stubModule']).toBeDefined();
+        });
+
+        it('initializes integration instance properly', async () => {
+            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
+
+            const instance = await useCase.execute(record.id, 'user-1');
+
+            expect(typeof instance.send).toBe('function');
+            expect(typeof instance.getConfig).toBe('function');
+            expect(typeof instance.initialize).toBe('function');
+        });
+
+        it('preserves all integration properties', async () => {
+            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy', custom: 'value' });
+
+            record.status = 'ACTIVE';
+            record.version = '2.0.0';
+            record.messages = { logs: [{ title: 'Test', message: 'Log entry' }] };
+
+            const instance = await useCase.execute(record.id, 'user-1');
+
+            expect(instance.status).toBe('ACTIVE');
+            expect(instance.version).toBe('2.0.0');
+            expect(instance.messages).toEqual({ logs: [{ title: 'Test', message: 'Log entry' }] });
+            expect(instance.getConfig().custom).toBe('value');
+        });
+    });
+
+    describe('error cases', () => {
+        it('throws error when integration not found', async () => {
+            const nonExistentId = 'non-existent-id';
+
+            await expect(useCase.execute(nonExistentId, 'user-1'))
+                .rejects
+                .toThrow(`No integration found by the ID of ${nonExistentId}`);
+        });
+
+        it('throws error when user does not own integration', async () => {
+            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
+
+            await expect(useCase.execute(record.id, 'different-user'))
+                .rejects
+                .toThrow(`Integration ${record.id} does not belong to User different-user`);
+        });
+
+        it('throws error when integration class not found', async () => {
+            const useCaseWithoutClasses = new GetIntegrationInstance({
+                integrationRepository,
+                integrationClasses: [],
+                moduleFactory,
+            });
+
+            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
+
+            await expect(useCaseWithoutClasses.execute(record.id, 'user-1'))
+                .rejects
+                .toThrow('No integration class found for type: dummy');
+        });
+
+        it('throws error when integration has unknown type', async () => {
+            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'unknown-type' });
+
+            await expect(useCase.execute(record.id, 'user-1'))
+                .rejects
+                .toThrow('No integration class found for type: unknown-type');
+        });
+    });
+
+    describe('edge cases', () => {
+        it('handles integration with no entities', async () => {
+            const record = await integrationRepository.createIntegration([], 'user-1', { type: 'dummy' });
+
+            const instance = await useCase.execute(record.id, 'user-1');
+
+            expect(instance.entities).toEqual([]);
+            expect(Object.keys(instance.modules)).toHaveLength(0);
+        });
+
+        it('handles integration with null config values', async () => {
+            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy', nullValue: null });
+
+            const instance = await useCase.execute(record.id, 'user-1');
+
+            expect(instance.getConfig().nullValue).toBeNull();
+        });
+
+        it('handles userId comparison edge cases', async () => {
+            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
+
+            const instance1 = await useCase.execute(record.id, 'user-1');
+            const instance2 = await useCase.execute(record.id, 'user-1');
+
+            expect(instance1.userId).toBe(instance2.userId);
+        });
+
+        it('returns fresh instance on each call', async () => {
+            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
+
+            const instance1 = await useCase.execute(record.id, 'user-1');
+            const instance2 = await useCase.execute(record.id, 'user-1');
+
+            expect(instance1).not.toBe(instance2);
+            expect(instance1.id).toBe(instance2.id);
+        });
+
+        it('handles complex nested config structures', async () => {
+            const complexConfig = {
+                type: 'dummy',
+                settings: {
+                    api: {
+                        timeout: 5000,
+                        retries: 3,
+                        endpoints: ['users', 'orders']
+                    },
+                    features: {
+                        webhooks: true,
+                        sync: { interval: 300 }
+                    }
+                }
+            };
+
+            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', complexConfig);
+
+            const instance = await useCase.execute(record.id, 'user-1');
+
+            expect(instance.getConfig()).toEqual(complexConfig);
+        });
+    });
+}); 

package/integrations/tests/use-cases/get-integrations-for-user.test.js

@@ -0,0 +1,169 @@
+const { GetIntegrationsForUser } = require('../../use-cases/get-integrations-for-user');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
+const { TestModuleRepository } = require('../../../modules/tests/doubles/test-module-repository');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('GetIntegrationsForUser Use-Case', () => {
+    let integrationRepository;
+    let moduleRepository;
+    let moduleFactory;
+    let useCase;
+
+    beforeEach(() => {
+        integrationRepository = new TestIntegrationRepository();
+        moduleRepository = new TestModuleRepository();
+        moduleFactory = new TestModuleFactory();
+        useCase = new GetIntegrationsForUser({
+            integrationRepository,
+            integrationClasses: [DummyIntegration],
+            moduleFactory,
+            moduleRepository,
+        });
+    });
+
+    describe('happy path', () => {
+        it('returns integrations dto list for single user', async () => {
+            const entity = { id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+
+            await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+            const list = await useCase.execute('user-1');
+            expect(list.length).toBe(1);
+            expect(list[0].config.type).toBe('dummy');
+            expect(list[0].userId).toBe('user-1');
+        });
+
+        it('returns multiple integrations for same user', async () => {
+            const entity1 = { id: 'entity-1' };
+            const entity2 = { id: 'entity-2' };
+            moduleRepository.addEntity(entity1);
+            moduleRepository.addEntity(entity2);
+
+            await integrationRepository.createIntegration([entity1.id], 'user-1', { type: 'dummy', name: 'first' });
+            await integrationRepository.createIntegration([entity2.id], 'user-1', { type: 'dummy', name: 'second' });
+
+            const list = await useCase.execute('user-1');
+            expect(list.length).toBe(2);
+            expect(list[0].config.name).toBe('first');
+            expect(list[1].config.name).toBe('second');
+        });
+
+        it('filters integrations by user correctly', async () => {
+            const entity1 = { id: 'entity-1' };
+            const entity2 = { id: 'entity-2' };
+            moduleRepository.addEntity(entity1);
+            moduleRepository.addEntity(entity2);
+
+            await integrationRepository.createIntegration([entity1.id], 'user-1', { type: 'dummy', owner: 'user1' });
+            await integrationRepository.createIntegration([entity2.id], 'user-2', { type: 'dummy', owner: 'user2' });
+
+            const user1List = await useCase.execute('user-1');
+            const user2List = await useCase.execute('user-2');
+
+            expect(user1List.length).toBe(1);
+            expect(user2List.length).toBe(1);
+            expect(user1List[0].config.owner).toBe('user1');
+            expect(user2List[0].config.owner).toBe('user2');
+        });
+
+        it('returns empty array when user has no integrations', async () => {
+            const entity = { id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+
+            await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+            const list = await useCase.execute('user-2');
+            expect(list).toEqual([]);
+        });
+
+        it('tracks repository operations', async () => {
+            const entity = { id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+            await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+            integrationRepository.clearHistory();
+
+            await useCase.execute('user-1');
+
+            const history = integrationRepository.getOperationHistory();
+            const findOperation = history.find(op => op.operation === 'findByUserId');
+            expect(findOperation).toEqual({
+                operation: 'findByUserId',
+                userId: 'user-1',
+                count: 1
+            });
+        });
+    });
+
+    describe('error cases', () => {
+        it('throws error when integration class not found', async () => {
+            const useCaseWithoutClasses = new GetIntegrationsForUser({
+                integrationRepository,
+                integrationClasses: [],
+                moduleFactory,
+                moduleRepository,
+            });
+
+            const entity = { id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+            await integrationRepository.createIntegration([entity.id], 'user-1', { type: 'dummy' });
+
+            await expect(useCaseWithoutClasses.execute('user-1'))
+                .rejects
+                .toThrow();
+        });
+
+        it('handles missing entities gracefully', async () => {
+            await integrationRepository.createIntegration(['missing-entity'], 'user-1', { type: 'dummy' });
+
+            await expect(useCase.execute('user-1'))
+                .rejects
+                .toThrow();
+        });
+    });
+
+    describe('edge cases', () => {
+        it('handles user with null/undefined userId', async () => {
+            const list1 = await useCase.execute(null);
+            const list2 = await useCase.execute(undefined);
+
+            expect(list1).toEqual([]);
+            expect(list2).toEqual([]);
+        });
+
+        it('handles integrations with complex configs', async () => {
+            const entity = { id: 'entity-1' };
+            moduleRepository.addEntity(entity);
+
+            const complexConfig = {
+                type: 'dummy',
+                settings: {
+                    nested: { deep: 'value' },
+                    array: [1, 2, 3],
+                    boolean: true,
+                    nullValue: null
+                }
+            };
+
+            await integrationRepository.createIntegration([entity.id], 'user-1', complexConfig);
+
+            const list = await useCase.execute('user-1');
+            expect(list[0].config).toEqual(complexConfig);
+        });
+
+        it('handles integrations with multiple entities', async () => {
+            const entity1 = { id: 'entity-1' };
+            const entity2 = { id: 'entity-2' };
+            const entity3 = { id: 'entity-3' };
+            moduleRepository.addEntity(entity1);
+            moduleRepository.addEntity(entity2);
+            moduleRepository.addEntity(entity3);
+
+            await integrationRepository.createIntegration([entity1.id, entity2.id, entity3.id], 'user-1', { type: 'dummy' });
+
+            const list = await useCase.execute('user-1');
+            expect(list[0].entities).toEqual([entity1, entity2, entity3]);
+        });
+    });
+}); 

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

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