@friggframework/core 2.0.0--canary.397.3862908.0 → 2.0.0--canary.398.e2147f7.0

package/integrations/tests/doubles/test-integration-repository.js

@@ -1,52 +0,0 @@
-const { v4: uuid } = require('uuid');
-
-class TestIntegrationRepository {
-    constructor() {
-        this.store = new Map();
-    }
-
-    async createIntegration(entities, userId, config) {
-        const id = uuid();
-        const record = {
-            id,
-            entitiesIds: entities,
-            userId,
-            config,
-            version: '0.0.0',
-            status: 'NEW',
-            messages: {},
-        };
-        this.store.set(id, record);
-        return record;
-    }
-
-    async findIntegrationById(id) {
-        const rec = this.store.get(id);
-        if (!rec) return null;
-        return rec;
-    }
-
-    async findIntegrationsByUserId(userId) {
-        return Array.from(this.store.values()).filter(r => r.userId === userId);
-    }
-
-    async updateIntegrationMessages(id, type, title, body, timestamp) {
-        const rec = this.store.get(id);
-        if (!rec) return false;
-        if (!rec.messages[type]) rec.messages[type] = [];
-        rec.messages[type].push({ title, message: body, timestamp });
-        return true;
-    }
-
-    async deleteIntegrationById(id) {
-        return this.store.delete(id);
-    }
-
-    async updateIntegrationStatus(id, status) {
-        const rec = this.store.get(id);
-        if (rec) rec.status = status;
-        return true;
-    }
-}
-
-module.exports = { TestIntegrationRepository }; 

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

@@ -1,27 +0,0 @@
-const { CreateIntegration } = require('../../use-cases/create-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('CreateIntegration Use-Case', () => {
-    it('creates an integration and returns DTO', async () => {
-        const integrationRepository = new TestIntegrationRepository();
-        const moduleFactory = new TestModuleFactory();
-
-        const useCase = new CreateIntegration({
-            integrationRepository,
-            integrationClasses: [DummyIntegration],
-            moduleFactory,
-        });
-
-        const entities = ['entity-1'];
-        const userId = 'user-1';
-        const config = { type: 'dummy', foo: 'bar' };
-
-        const dto = await useCase.execute(entities, userId, config);
-
-        expect(dto.id).toBeDefined();
-        expect(dto.config).toEqual(config);
-        expect(dto.userId).toBe(userId);
-    });
-}); 

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

@@ -1,20 +0,0 @@
-const { DeleteIntegrationForUser } = require('../../use-cases/delete-integration-for-user');
-const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
-const { DummyIntegration } = require('../doubles/dummy-integration-class');
-
-describe('DeleteIntegrationForUser', () => {
-    it('deletes integration', async () => {
-        const repo = new TestIntegrationRepository();
-        const record = await repo.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-        const useCase = new DeleteIntegrationForUser({
-            integrationRepository: repo,
-            integrationClasses: [DummyIntegration],
-        });
-
-        await useCase.execute(record.id, 'user-1');
-
-        const found = await repo.findIntegrationById(record.id);
-        expect(found).toBeNull();
-    });
-}); 

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

@@ -1,29 +0,0 @@
-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', () => {
-    it('returns integration dto', async () => {
-        const iRepo = new TestIntegrationRepository();
-        const mRepo = new TestModuleRepository();
-        const mFactory = new TestModuleFactory();
-
-        const entity = { id: 'entity-1' };
-        mRepo.addEntity(entity);
-
-        const record = await iRepo.createIntegration([entity.id], 'user-1', { type: 'dummy' });
-
-        const useCase = new GetIntegrationForUser({
-            integrationRepository: iRepo,
-            integrationClasses: [DummyIntegration],
-            moduleFactory: mFactory,
-            moduleRepository: mRepo,
-        });
-
-        const dto = await useCase.execute(record.id, 'user-1');
-        expect(dto.id).toBe(record.id);
-    });
-}); 

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

@@ -1,26 +0,0 @@
-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', () => {
-    it('returns hydrated integration instance', async () => {
-        const integrationRepository = new TestIntegrationRepository();
-        const moduleFactory = new TestModuleFactory();
-
-        // first create record directly via repo
-        const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
-
-        const useCase = new GetIntegrationInstance({
-            integrationRepository,
-            integrationClasses: [DummyIntegration],
-            moduleFactory,
-        });
-
-        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);
-    });
-}); 

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

@@ -1,30 +0,0 @@
-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', () => {
-    it('returns integrations dto list', async () => {
-        const integrationRepo = new TestIntegrationRepository();
-        const moduleRepo = new TestModuleRepository();
-        const moduleFactory = new TestModuleFactory();
-
-        // setup entity and module repo
-        const entity = { id: 'entity-1' };
-        moduleRepo.addEntity(entity);
-
-        await integrationRepo.createIntegration([entity.id], 'user-1', { type: 'dummy' });
-
-        const useCase = new GetIntegrationsForUser({
-            integrationRepository: integrationRepo,
-            integrationClasses: [DummyIntegration],
-            moduleFactory,
-            moduleRepository: moduleRepo,
-        });
-
-        const list = await useCase.execute('user-1');
-        expect(list.length).toBe(1);
-        expect(list[0].config.type).toBe('dummy');
-    });
-}); 

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

@@ -1,12 +0,0 @@
-const { GetPossibleIntegrations } = require('../../use-cases/get-possible-integrations');
-const { DummyIntegration } = require('../doubles/dummy-integration-class');
-
-describe('GetPossibleIntegrations', () => {
-    it('returns option details array', async () => {
-        const useCase = new GetPossibleIntegrations({ integrationClasses: [DummyIntegration] });
-        const res = await useCase.execute();
-        expect(Array.isArray(res)).toBe(true);
-        expect(res.length).toBe(1);
-        expect(res[0].display).toBeDefined();
-    });
-}); 

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

@@ -1,15 +0,0 @@
-const { UpdateIntegrationMessages } = require('../../use-cases/update-integration-messages');
-const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
-
-describe('UpdateIntegrationMessages', () => {
-    it('adds message', async () => {
-        const repo = new TestIntegrationRepository();
-        const rec = await repo.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-        const useCase = new UpdateIntegrationMessages({ integrationRepository: repo });
-        await useCase.execute(rec.id, 'errors', 'title', 'body', Date.now());
-
-        const fetched = await repo.findIntegrationById(rec.id);
-        expect(fetched.messages.errors.length).toBe(1);
-    });
-}); 

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

@@ -1,24 +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', () => {
-    it('calls on update and returns dto', async () => {
-        const repo = new TestIntegrationRepository();
-        const mf = new TestModuleFactory();
-
-        const record = await repo.createIntegration(['e1'], 'user-1', { type: 'dummy', foo: 'bar' });
-
-        const useCase = new UpdateIntegration({
-            integrationRepository: repo,
-            integrationClasses: [DummyIntegration],
-            moduleFactory: mf,
-        });
-
-        const newConfig = { type: 'dummy', foo: 'baz' };
-        const dto = await useCase.execute(record.id, 'user-1', newConfig);
-
-        expect(dto.config.foo).toBe('baz');
-    });
-}); 

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

@@ -1,57 +0,0 @@
-const { Integration } = require('../integration');
-const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
-
-class CreateIntegration {
-    /**
-     * @param {Object} params
-     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository
-     * @param {import('../integration-classes').IntegrationClasses} params.integrationClasses
-     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory
-     */
-    constructor({ integrationRepository, integrationClasses, moduleFactory }) {
-        this.integrationRepository = integrationRepository;
-        this.integrationClasses = integrationClasses;
-        this.moduleFactory = moduleFactory;
-    }
-
-    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

@@ -1,54 +0,0 @@
-const Boom = require('@hapi/boom');
-const { Integration } = require('../integration');
-
-class DeleteIntegrationForUser {
-    constructor({ integrationRepository, integrationClasses }) {
-
-        /**
-         * @type {import('../integration-repository').IntegrationRepository}
-         */
-        this.integrationRepository = integrationRepository;
-        this.integrationClasses = integrationClasses;
-    }
-
-    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

@@ -1,63 +0,0 @@
-const { Integration } = require('../integration');
-const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
-
-class GetIntegrationForUser {
-    constructor({ integrationRepository, integrationClasses, moduleFactory, moduleRepository }) {
-
-        /**
-         * @type {import('../integration-repository').IntegrationRepository}
-         */
-        this.integrationRepository = integrationRepository;
-        this.integrationClasses = integrationClasses;
-        this.moduleFactory = moduleFactory;
-        this.moduleRepository = moduleRepository;
-    }
-
-    /**
-     * @param {string} integrationId
-     * @param {string} userId
-     * @returns {Promise<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.user.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.user
-            );
-            modules.push(moduleInstance);
-        }
-
-        const integrationInstance = new Integration({
-            id: integrationRecord._id,
-            userId: integrationRecord.user,
-            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 }; 

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

@@ -1,73 +0,0 @@
-const { Integration } = require('../integration');
-
-class GetIntegrationInstance {
-
-    /**
-     * @class GetIntegrationInstance
-     * @description Use case for retrieving a single integration instance by ID and user.
-     * @param {Object} params
-     * @param {import('../integration-repository').IntegrationRepository} 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;
-    }
-
-    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 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();
-
-        return integrationInstance;
-    }
-}
-
-module.exports = { GetIntegrationInstance }; 

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

@@ -1,63 +0,0 @@
-const { Integration } = require('../integration');
-const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
-
-class GetIntegrationsForUser {
-    constructor({ integrationRepository, integrationClasses, moduleFactory, moduleRepository }) {
-
-        /**
-         * @type {import('../integration-repository').IntegrationRepository}
-         */
-        this.integrationRepository = integrationRepository;
-        this.integrationClasses = integrationClasses;
-        this.moduleFactory = moduleFactory;
-        this.moduleRepository = moduleRepository;
-    }
-
-    /**
-     * @param {string} userId
-     * @returns {Promise<Integration[]>}
-     */
-    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 Integration({
-                id: integrationRecord.id,
-                userId: integrationRecord.user,
-                entities: entities,
-                config: integrationRecord.config,
-                status: integrationRecord.status,
-                version: integrationRecord.version,
-                messages: integrationRecord.messages,
-                integrationClass: integrationClass,
-                modules
-            });
-
-            integrations.push(
-                mapIntegrationClassToIntegrationDTO(integrationInstance)
-            );
-
-        }
-
-        return integrations;
-    }
-}
-
-module.exports = { GetIntegrationsForUser }; 

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

@@ -1,13 +0,0 @@
-class GetPossibleIntegrations {
-    constructor({ integrationClasses }) {
-        this.integrationClasses = integrationClasses;
-    }
-
-    async execute() {
-        return this.integrationClasses.map((integrationClass) =>
-            integrationClass.getOptionDetails()
-        );
-    }
-}
-
-module.exports = { GetPossibleIntegrations };

package/integrations/use-cases/index.js

@@ -1,11 +0,0 @@
-const { GetIntegrationsForUser } = require('./get-integrations-for-user');
-const { DeleteIntegrationForUser } = require('./delete-integration-for-user');
-const { CreateIntegration } = require('./create-integration');
-const { GetIntegration } = require('./get-integration');
-
-module.exports = {
-    GetIntegrationsForUser,
-    DeleteIntegrationForUser,
-    CreateIntegration,
-    GetIntegration,
-}; 

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

@@ -1,20 +0,0 @@
-class UpdateIntegrationMessages {
-    constructor({ integrationRepository }) {
-        this.integrationRepository = integrationRepository;
-    }
-
-    /**
-     * @param {string} integrationId
-     * @param {string} messageType - 'errors', 'warnings', 'info' or 'logs'
-     * @param {string} messageTitle,
-     * @param {string} messageBody,
-     * @param {string} messageTimestamp,
-     * @returns {Promise<Object>}
-     */
-    async execute(integrationId, messageType, messageTitle, messageBody, messageTimestamp) {
-        const integration = await this.integrationRepository.updateIntegrationMessages(integrationId, messageType, messageTitle, messageBody, messageTimestamp);
-        return integration;
-    }
-}
-
-module.exports = { UpdateIntegrationMessages };

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

@@ -1,12 +0,0 @@
-class UpdateIntegrationStatus {
-    constructor({ integrationRepository }) {
-        this.integrationRepository = integrationRepository;
-    }
-
-    async execute(integrationId, status) {
-        const integration = await this.integrationRepository.updateIntegrationStatus(integrationId, status);
-        return integration;
-    }
-}
-
-module.exports = { UpdateIntegrationStatus };