@friggframework/core 2.0.0-next.41 → 2.0.0-next.43

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

@@ -0,0 +1,141 @@
+jest.mock('../../../database/config', () => ({
+    DB_TYPE: 'mongodb',
+    getDatabaseType: jest.fn(() => 'mongodb'),
+    PRISMA_LOG_LEVEL: 'error,warn',
+    PRISMA_QUERY_LOGGING: false,
+}));
+
+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,83 @@
+// 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('../repositories/integration-repository-interface').IntegrationRepositoryInterface} 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 };

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

@@ -0,0 +1,73 @@
+const Boom = require('@hapi/boom');
+// Removed Integration wrapper - using IntegrationBase directly
+
+/**
+ * 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('../repositories/integration-repository-interface').IntegrationRepositoryInterface} params.integrationRepository - Repository for integration data operations.
+     * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes.
+     */
+    constructor({ integrationRepository, integrationClasses }) {
+        /**
+         * @type {import('../repositories/integration-repository-interface').IntegrationRepositoryInterface}
+         */
+        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 integrationClass({
+            id: integrationRecord.id,
+            userId: integrationRecord.userId,
+            entities: integrationRecord.entitiesIds,
+            config: integrationRecord.config,
+            status: integrationRecord.status,
+            version: integrationRecord.version,
+            messages: integrationRecord.messages,
+            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/find-integration-context-by-external-entity-id.js

@@ -0,0 +1,72 @@
+class FindIntegrationContextByExternalEntityIdUseCase {
+    constructor({
+        integrationRepository,
+        moduleRepository,
+        loadIntegrationContextUseCase,
+    } = {}) {
+        if (!integrationRepository) {
+            throw new Error('integrationRepository is required');
+        }
+        if (!moduleRepository) {
+            throw new Error('moduleRepository is required');
+        }
+        if (!loadIntegrationContextUseCase) {
+            throw new Error('loadIntegrationContextUseCase is required');
+        }
+
+        this.integrationRepository = integrationRepository;
+        this.moduleRepository = moduleRepository;
+        this.loadIntegrationContextUseCase = loadIntegrationContextUseCase;
+    }
+
+    async execute({ externalEntityId }) {
+        if (!externalEntityId) {
+            const error = new Error('externalEntityId is required');
+            error.code = 'EXTERNAL_ENTITY_ID_REQUIRED';
+            throw error;
+        }
+
+        const entity = await this.moduleRepository.findEntity({
+            externalId: externalEntityId,
+        });
+
+        if (!entity) {
+            const error = new Error(
+                `Entity not found for externalId: ${externalEntityId}`
+            );
+            error.code = 'ENTITY_NOT_FOUND';
+            throw error;
+        }
+
+        if (!entity.userId) {
+            const error = new Error('Entity does not have an associated user');
+            error.code = 'ENTITY_USER_NOT_FOUND';
+            throw error;
+        }
+
+        const integrationRecord =
+            await this.integrationRepository.findIntegrationByUserId(
+                entity.userId
+            );
+
+        if (!integrationRecord) {
+            const error = new Error(
+                `Integration not found for user: ${entity.userId}`
+            );
+            error.code = 'INTEGRATION_NOT_FOUND';
+            throw error;
+        }
+
+        const context = await this.loadIntegrationContextUseCase.execute({
+            integrationRecord,
+        });
+
+        return {
+            context,
+            entity,
+            record: integrationRecord,
+        };
+    }
+}
+
+module.exports = { FindIntegrationContextByExternalEntityIdUseCase };

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

@@ -0,0 +1,78 @@
+// Removed Integration wrapper - using IntegrationBase directly
+const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
+const Boom = require('@hapi/boom');
+
+/**
+ * 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-interface').IntegrationRepositoryInterface} 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-interface').ModuleRepositoryInterface} params.moduleRepository - Repository for module and entity data operations.
+     */
+    constructor({ integrationRepository, integrationClasses, moduleFactory, moduleRepository }) {
+
+        /**
+         * @type {import('../integration-repository-interface').IntegrationRepositoryInterface}
+         */
+        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 integrationClass({
+            id: integrationRecord._id,
+            userId: integrationRecord.userId,
+            entities: entities,
+            config: integrationRecord.config,
+            status: integrationRecord.status,
+            version: integrationRecord.version,
+            messages: integrationRecord.messages,
+            modules
+        });
+
+        return mapIntegrationClassToIntegrationDTO(integrationInstance);
+    }
+}
+
+module.exports = { GetIntegrationForUser }; 

package/integrations/use-cases/get-integration-instance-by-definition.js

@@ -0,0 +1,67 @@
+// Removed Integration wrapper - using IntegrationBase directly
+const Boom = require('@hapi/boom');
+
+/**
+ * Use case for retrieving a single integration by definition.
+ * @class GetIntegrationByDefinition
+ */
+class GetIntegrationInstanceByDefinition {
+    /**
+     * Creates a new GetIntegrationByDefinition instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../integration-repository-interface').IntegrationRepositoryInterface} params.integrationRepository - Repository for integration data operations.
+     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management.
+     * @param {import('../../modules/module-repository-interface').ModuleRepositoryInterface} params.moduleRepository - Repository for module and entity data operations.
+     */
+    constructor({ integrationRepository, moduleFactory, moduleRepository }) {
+
+        /**
+         * @type {import('../integration-repository-interface').IntegrationRepositoryInterface}
+         */
+        this.integrationRepository = integrationRepository;
+        this.moduleFactory = moduleFactory;
+        this.moduleRepository = moduleRepository;
+    }
+
+    /**
+     * Executes the retrieval of a single integration by definition.
+     * @async
+     * @returns {Promise<Object>} The integration DTO for the specified definition.
+     * @throws {Boom.notFound} When integration with the specified definition does not exist.
+     */
+    async execute(integrationClass) {
+        const integrationRecord = await this.integrationRepository.findIntegrationByName(integrationClass.Definition.name);
+
+        if (!integrationRecord) {
+            throw Boom.notFound(`Integration with name of ${integrationClass.Definition.name} does not exist`);
+        }
+
+        const entities = await this.moduleRepository.findEntitiesByIds(integrationRecord.entitiesIds);
+
+        const modules = [];
+        for (const entity of entities) {
+            const moduleInstance = await this.moduleFactory.getModuleInstance(
+                entity.id,
+                integrationRecord.userId
+            );
+            modules.push(moduleInstance);
+        }
+
+        const integrationInstance = new integrationClass({
+            id: integrationRecord.id,
+            userId: integrationRecord.userId,
+            entities: entities,
+            config: integrationRecord.config,
+            status: integrationRecord.status,
+            version: integrationRecord.version,
+            messages: integrationRecord.messages,
+            modules
+        });
+
+        await integrationInstance.initialize();
+
+        return integrationInstance
+    }
+}
+
+module.exports = { GetIntegrationInstanceByDefinition }; 

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

@@ -0,0 +1,83 @@
+// Removed Integration wrapper - using IntegrationBase directly
+
+/**
+ * Use case for retrieving a single integration instance by ID and user.
+ * @class GetIntegrationInstance
+ */
+class GetIntegrationInstance {
+    /**
+     * Creates a new GetIntegrationInstance instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../repositories/integration-repository-interface').IntegrationRepositoryInterface} params.integrationRepository - Repository for integration data access
+     * @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
+     */
+    constructor({ integrationRepository, integrationClasses, moduleFactory }) {
+        this.integrationRepository = integrationRepository;
+        this.integrationClasses = integrationClasses;
+        this.moduleFactory = moduleFactory;
+    }
+
+    /**
+     * Executes the retrieval of a single integration instance.
+     * @async
+     * @param {string} integrationId - ID of the integration to retrieve.
+     * @param {string} userId - ID of the user requesting the integration.
+     * @returns {Promise<Integration>} The fully initialized integration instance.
+     * @throws {Error} When integration is not found, doesn't belong to user, or integration class is not found.
+     */
+    async execute(integrationId, userId) {
+        const integrationRecord =
+            await this.integrationRepository.findIntegrationById(integrationId);
+
+        if (!integrationRecord) {
+            throw new Error(
+                `No integration found by the ID of ${integrationId}`
+            );
+        }
+
+        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}`
+            );
+        }
+
+        if (integrationRecord.userId !== userId) {
+            throw new Error(
+                `Integration ${integrationId} does not belong to User ${userId}`
+            );
+        }
+
+        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();
+
+        return integrationInstance;
+    }
+}
+
+module.exports = { GetIntegrationInstance };

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

@@ -0,0 +1,87 @@
+// Removed Integration wrapper - using IntegrationBase directly
+const {
+    mapIntegrationClassToIntegrationDTO,
+} = require('../utils/map-integration-dto');
+
+/**
+ * Use case for retrieving all integrations for a specific user.
+ * @class GetIntegrationsForUser
+ */
+class GetIntegrationsForUser {
+    /**
+     * Creates a new GetIntegrationsForUser instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../repositories/integration-repository-interface').IntegrationRepositoryInterface} 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/repositories/module-repository-interface').ModuleRepositoryInterface} params.moduleRepository - Repository for module and entity data operations.
+     */
+    constructor({
+        integrationRepository,
+        integrationClasses,
+        moduleFactory,
+        moduleRepository,
+    }) {
+        /**
+         * @type {import('../repositories/integration-repository-interface').IntegrationRepositoryInterface}
+         */
+        this.integrationRepository = integrationRepository;
+        this.integrationClasses = integrationClasses;
+        this.moduleFactory = moduleFactory;
+        this.moduleRepository = moduleRepository;
+    }
+
+    /**
+     * Executes the retrieval of all integrations for a user.
+     * @async
+     * @param {string} userId - ID of the user whose integrations to retrieve.
+     * @returns {Promise<Object[]>} Array of integration DTOs for the specified user.
+     */
+    async execute(userId) {
+        const integrationRecords =
+            await this.integrationRepository.findIntegrationsByUserId(userId);
+
+        const integrations = [];
+
+        for (const integrationRecord of integrationRecords) {
+            const entities = await this.moduleRepository.findEntitiesByIds(
+                integrationRecord.entitiesIds
+            );
+
+            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 integrationClass({
+                id: integrationRecord.id,
+                userId: integrationRecord.userId,
+                entities: entities,
+                config: integrationRecord.config,
+                status: integrationRecord.status,
+                version: integrationRecord.version,
+                messages: integrationRecord.messages,
+                modules,
+            });
+
+            integrations.push(
+                mapIntegrationClassToIntegrationDTO(integrationInstance)
+            );
+        }
+
+        return integrations;
+    }
+}
+
+module.exports = { GetIntegrationsForUser };