@friggframework/core 2.0.0--canary.398.a314355.0 → 2.0.0--canary.397.4957a89.0

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

@@ -0,0 +1,142 @@
+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

@@ -0,0 +1,103 @@
+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

@@ -0,0 +1,134 @@
+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

@@ -0,0 +1,72 @@
+const { Integration } = require('../integration');
+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 Integration({
+            id: integrationRecord.id,
+            userId: integrationRecord.userId,
+            entities: integrationRecord.entitiesIds,
+            config: integrationRecord.config,
+            status: integrationRecord.status,
+            version: integrationRecord.version,
+            messages: integrationRecord.messages,
+            integrationClass: integrationClass,
+            modules
+        });
+
+        await integrationInstance.initialize();
+        await integrationInstance.send('ON_CREATE', { integrationId: integrationRecord.id });
+
+        return mapIntegrationClassToIntegrationDTO(integrationInstance);
+    }
+}
+
+module.exports = { CreateIntegration }; 

package/integrations/use-cases/delete-integration-for-user.js

@@ -0,0 +1,73 @@
+const Boom = require('@hapi/boom');
+const { Integration } = require('../integration');
+
+/**
+ * Use case for deleting an integration for a specific user.
+ * @class DeleteIntegrationForUser
+ */
+class DeleteIntegrationForUser {
+    /**
+     * Creates a new DeleteIntegrationForUser instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data operations.
+     * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes.
+     */
+    constructor({ integrationRepository, integrationClasses }) {
+
+        /**
+         * @type {import('../integration-repository').IntegrationRepository}
+         */
+        this.integrationRepository = integrationRepository;
+        this.integrationClasses = integrationClasses;
+    }
+
+    /**
+     * Executes the deletion of an integration for a user.
+     * @async
+     * @param {string} integrationId - ID of the integration to delete.
+     * @param {string} userId - ID of the user requesting the deletion.
+     * @returns {Promise<void>} Resolves when the integration is successfully deleted.
+     * @throws {Boom.notFound} When integration with the specified ID does not exist.
+     * @throws {Error} When the integration doesn't belong to the specified user.
+     */
+    async execute(integrationId, userId) {
+        const integrationRecord = await this.integrationRepository.findIntegrationById(integrationId);
+
+        if (!integrationRecord) {
+            throw Boom.notFound(
+                `Integration with id of ${integrationId} does not exist`
+            );
+        }
+
+        const integrationClass = this.integrationClasses.find(
+            (integrationClass) => integrationClass.Definition.name === integrationRecord.config.type
+        );
+
+        if (integrationRecord.userId !== userId) {
+            throw new Error(
+                `Integration ${integrationId} does not belong to User ${userId}`
+            );
+        }
+
+        const integrationInstance = new Integration({
+            id: integrationRecord.id,
+            userId: integrationRecord.userId,
+            entities: integrationRecord.entitiesIds,
+            config: integrationRecord.config,
+            status: integrationRecord.status,
+            version: integrationRecord.version,
+            messages: integrationRecord.messages,
+            integrationClass: integrationClass,
+            modules: [],
+        });
+
+        // 6. Complete async initialization (load dynamic actions, register handlers)
+        await integrationInstance.initialize();
+        await integrationInstance.send('ON_DELETE');
+
+        await this.integrationRepository.deleteIntegrationById(integrationId);
+
+    }
+}
+
+module.exports = { DeleteIntegrationForUser }; 

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

@@ -0,0 +1,79 @@
+const { Integration } = require('../integration');
+const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
+
+/**
+ * Use case for retrieving a single integration for a specific user.
+ * @class GetIntegrationForUser
+ */
+class GetIntegrationForUser {
+    /**
+     * Creates a new GetIntegrationForUser instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data operations.
+     * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes.
+     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management.
+     * @param {import('../../modules/module-repository').ModuleRepository} params.moduleRepository - Repository for module and entity data operations.
+     */
+    constructor({ integrationRepository, integrationClasses, moduleFactory, moduleRepository }) {
+
+        /**
+         * @type {import('../integration-repository').IntegrationRepository}
+         */
+        this.integrationRepository = integrationRepository;
+        this.integrationClasses = integrationClasses;
+        this.moduleFactory = moduleFactory;
+        this.moduleRepository = moduleRepository;
+    }
+
+    /**
+     * Executes the retrieval of a single integration for a user.
+     * @async
+     * @param {string} integrationId - ID of the integration to retrieve.
+     * @param {string} userId - ID of the user requesting the integration.
+     * @returns {Promise<Object>} The integration DTO for the specified user.
+     * @throws {Boom.notFound} When integration with the specified ID does not exist.
+     * @throws {Boom.forbidden} When user does not have access to the integration.
+     */
+    async execute(integrationId, userId) {
+        const integrationRecord = await this.integrationRepository.findIntegrationById(integrationId);
+        const entities = await this.moduleRepository.findEntitiesByIds(integrationRecord.entitiesIds);
+
+        if (!integrationRecord) {
+            throw Boom.notFound(`Integration with id of ${integrationId} does not exist`);
+        }
+
+        if (integrationRecord.userId.toString() !== userId.toString()) {
+            throw Boom.forbidden('User does not have access to this integration');
+        }
+
+        const integrationClass = this.integrationClasses.find(
+            (integrationClass) => integrationClass.Definition.name === integrationRecord.config.type
+        );
+
+        const modules = [];
+        for (const entity of entities) {
+            const moduleInstance = await this.moduleFactory.getModuleInstance(
+                entity._id,
+                integrationRecord.userId
+            );
+            modules.push(moduleInstance);
+        }
+
+        const integrationInstance = new Integration({
+            id: integrationRecord._id,
+            userId: integrationRecord.userId,
+            entities: entities,
+            config: integrationRecord.config,
+            status: integrationRecord.status,
+            version: integrationRecord.version,
+            messages: integrationRecord.messages,
+            entityReference: integrationRecord.entityReference,
+            integrationClass: integrationClass,
+            modules
+        });
+
+        return mapIntegrationClassToIntegrationDTO(integrationInstance);
+    }
+}
+
+module.exports = { GetIntegrationForUser };