@friggframework/core 2.0.0--canary.396.6862738.0 → 2.0.0--canary.397.c07f148.0

package/integrations/integration-router.js

@@ -8,28 +8,37 @@ const { GetIntegrationsForUser } = require('./use-cases/get-integrations-for-use
 const { CredentialRepository } = require('../credential/credential-repository');
 const { GetCredentialForUser } = require('../credential/use-cases/get-credential-for-user');
 const { CreateIntegration } = require('./use-cases/create-integration');
-const { ModuleService } = require('../module-plugin/module-service');
-const { ModuleRepository } = require('../module-plugin/module-repository');
-const { GetEntitiesForUser } = require('../module-plugin/use-cases/get-entities-for-user');
+const { ModuleFactory } = require('../modules/module-factory');
+const { ModuleRepository } = require('../modules/module-repository');
+const { GetEntitiesForUser } = require('../modules/use-cases/get-entities-for-user');
 const { loadAppDefinition } = require('../handlers/app-definition-loader');
 const { GetIntegrationInstance } = require('./use-cases/get-integration-instance');
 const { UpdateIntegration } = require('./use-cases/update-integration');
 const { getModulesDefinitionFromIntegrationClasses } = require('./utils/map-integration-dto');
-
-/**
- * Creates an Express router with integration and entity routes configured
- * @param {Object} params - Configuration parameters for the router
- * @param {express.Router} [params.router] - Optional Express router instance, creates new one if not provided
- * @param {import('../user/use-cases/get-user-from-bearer-token').GetUserFromBearerToken} params.getUserFromBearerToken - Use case for retrieving a user from a bearer token
- * @returns {express.Router} Configured Express router with integration and entity routes
- */
-function createIntegrationRouter(params) {
-    const { integrations: integrationClasses } = loadAppDefinition();
+const { GetModuleInstanceFromType } = require('../modules/use-cases/get-module-instance-from-type');
+const { GetEntityOptionsByType } = require('../modules/use-cases/get-entity-options-by-type');
+const { TestModuleAuth } = require('../modules/use-cases/test-module-auth');
+const { GetModule } = require('../modules/use-cases/get-module');
+const { GetEntityOptionsById } = require('../modules/use-cases/get-entity-options-by-id');
+const { RefreshEntityOptions } = require('../modules/use-cases/refresh-entity-options');
+const { GetPossibleIntegrations } = require('./use-cases/get-possible-integrations');
+const { UserRepository } = require('../user/user-repository');
+const { GetUserFromBearerToken } = require('../user/use-cases/get-user-from-bearer-token');
+const { ProcessAuthorizationCallback } = require('../modules/use-cases/process-authorization-callback');
+
+function createIntegrationRouter() {
+    const { integrations: integrationClasses, userConfig } = loadAppDefinition();
     const moduleRepository = new ModuleRepository();
     const integrationRepository = new IntegrationRepository();
     const credentialRepository = new CredentialRepository();
+    const userRepository = new UserRepository({ userConfig });
+
+    const getUserFromBearerToken = new GetUserFromBearerToken({
+        userRepository,
+        userConfig,
+    });
 
-    const moduleService = new ModuleService({
+    const moduleFactory = new ModuleFactory({
         moduleRepository,
         moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
     });
@@ -41,16 +50,18 @@ function createIntegrationRouter(params) {
     const getIntegrationsForUser = new GetIntegrationsForUser({
         integrationRepository,
         integrationClasses,
-        moduleService,
+        moduleFactory,
         moduleRepository,
     });
+
     const getCredentialForUser = new GetCredentialForUser({
         credentialRepository,
     });
+
     const createIntegration = new CreateIntegration({
         integrationRepository,
         integrationClasses,
-        moduleService,
+        moduleFactory,
     });
 
     const getEntitiesForUser = new GetEntitiesForUser({
@@ -61,18 +72,54 @@ function createIntegrationRouter(params) {
     const getIntegrationInstance = new GetIntegrationInstance({
         integrationRepository,
         integrationClasses,
-        moduleService,
+        moduleFactory,
     });
 
     const updateIntegration = new UpdateIntegration({
         integrationRepository,
         integrationClasses,
-        moduleService,
+        moduleFactory,
+    });
+
+    const getModuleInstanceFromType = new GetModuleInstanceFromType({
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+
+    const getEntityOptionsByType = new GetEntityOptionsByType({
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+
+    const testModuleAuth = new TestModuleAuth({
+        moduleRepository,
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+
+    const getModule = new GetModule({
+        moduleRepository,
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+
+    const getEntityOptionsById = new GetEntityOptionsById({
+        moduleRepository,
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+
+    const refreshEntityOptions = new RefreshEntityOptions({
+        moduleRepository,
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
     });
 
-    const router = get(params, 'router', express());
-    const factory = get(params, 'factory');
-    const getUserFromBearerToken = get(params, 'getUserFromBearerToken');
+    const getPossibleIntegrations = new GetPossibleIntegrations({
+        integrationClasses,
+    });
+
+    const processAuthorizationCallback = new ProcessAuthorizationCallback({
+        moduleRepository,
+        credentialRepository,
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+
+    const router = express();
 
     setIntegrationRoutes(router, getUserFromBearerToken, {
         createIntegration,
@@ -81,9 +128,17 @@ function createIntegrationRouter(params) {
         getEntitiesForUser,
         getIntegrationInstance,
         updateIntegration,
+        getPossibleIntegrations,
     });
-    setEntityRoutes(router, factory, getUserFromBearerToken, {
+    setEntityRoutes(router, getUserFromBearerToken, {
         getCredentialForUser,
+        getModuleInstanceFromType,
+        getEntityOptionsByType,
+        testModuleAuth,
+        getModule,
+        getEntityOptionsById,
+        refreshEntityOptions,
+        processAuthorizationCallback,
     });
     return router;
 }
@@ -124,6 +179,7 @@ function setIntegrationRoutes(router, getUserFromBearerToken, useCases) {
         getEntitiesForUser,
         getIntegrationInstance,
         updateIntegration,
+        getPossibleIntegrations,
     } = useCases;
     router.route('/api/integrations').get(
         catchAsyncError(async (req, res) => {
@@ -134,9 +190,7 @@ function setIntegrationRoutes(router, getUserFromBearerToken, useCases) {
             const integrations = await getIntegrationsForUser.execute(userId);
             const results = {
                 entities: {
-                    options: integrations.map((integration) =>
-                        integration.options
-                    ),
+                    options: await getPossibleIntegrations.execute(),
                     authorized: await getEntitiesForUser.execute(userId),
                 },
                 integrations: integrations,
@@ -303,7 +357,7 @@ function setIntegrationRoutes(router, getUserFromBearerToken, useCases) {
             }
 
             const params = checkRequiredParams(req.params, ['integrationId']);
-            const integration = await getIntegrationForUser.execute(params.integrationId, user.getId());
+            const integration = await getIntegrationInstance.execute(params.integrationId, user.getId());
 
             // We could perhaps augment router with dynamic options? Haven't decided yet, but here may be the place
 
@@ -348,25 +402,19 @@ function setIntegrationRoutes(router, getUserFromBearerToken, useCases) {
 /**
  * Sets up entity-related routes for the integration router
  * @param {Object} router - Express router instance
- * @param {Object} factory - Factory object containing moduleFactory
  * @param {import('../user/use-cases/get-user-from-bearer-token').GetUserFromBearerToken} getUserFromBearerToken - Use case for retrieving a user from a bearer token
  */
-function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
-    const { moduleFactory } = factory;
-    const { getCredentialForUser } = useCases;
-    const getModuleInstance = async (userId, entityType) => {
-        if (!moduleFactory.checkIsValidType(entityType)) {
-            throw Boom.badRequest(
-                `Error: Invalid entity type of ${entityType}, options are ${moduleFactory.moduleTypes.join(
-                    ', '
-                )}`
-            );
-        }
-        return await moduleFactory.getInstanceFromTypeName(
-            entityType,
-            userId
-        );
-    };
+function setEntityRoutes(router, getUserFromBearerToken, useCases) {
+    const {
+        getCredentialForUser,
+        getModuleInstanceFromType,
+        getEntityOptionsByType,
+        testModuleAuth,
+        getModule,
+        getEntityOptionsById,
+        refreshEntityOptions,
+        processAuthorizationCallback,
+    } = useCases;
 
     router.route('/api/authorize').get(
         catchAsyncError(async (req, res) => {
@@ -375,16 +423,15 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
             );
             const userId = user.getId();
             const params = checkRequiredParams(req.query, ['entityType']);
-            const module = await getModuleInstance(userId, params.entityType);
-            const areRequirementsValid =
-                module.validateAuthorizationRequirements();
+            const module = await getModuleInstanceFromType.execute(userId, params.entityType);
+            const areRequirementsValid = module.validateAuthorizationRequirements();
             if (!areRequirementsValid) {
                 throw new Error(
                     `Error: Entity of type ${params.entityType} requires a valid url`
                 );
             }
 
-            res.json(await module.getAuthorizationRequirements());
+            res.json(module.getAuthorizationRequirements());
         })
     );
 
@@ -398,14 +445,10 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
                 'entityType',
                 'data',
             ]);
-            const module = await getModuleInstance(userId, params.entityType);
 
-            res.json(
-                await module.processAuthorizationCallback({
-                    userId,
-                    data: params.data,
-                })
-            );
+            const entityDetails = await processAuthorizationCallback.execute(userId, params.entityType, params.data);
+
+            res.json(entityDetails);
         })
     );
 
@@ -431,7 +474,7 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
                 throw Boom.badRequest('Invalid credential ID');
             }
 
-            const module = await getModuleInstance(userId, params.entityType);
+            const module = await getModuleInstanceFromType.execute(userId, params.entityType);
             const entityDetails = await module.getEntityDetails(
                 module.api,
                 null,
@@ -460,9 +503,9 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
             }
 
             const params = checkRequiredParams(req.query, ['entityType']);
-            const module = await getModuleInstance(userId, params.entityType);
+            const entityOptions = await getEntityOptionsByType.execute(userId, params.entityType);
 
-            res.json(await module.getEntityOptions());
+            res.json(entityOptions);
         })
     );
 
@@ -473,17 +516,11 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
             );
             const userId = user.getId();
             const params = checkRequiredParams(req.params, ['entityId']);
-            const module = await moduleFactory.getModuleInstanceFromEntityId(
+            const testAuthResponse = await testModuleAuth.execute(
                 params.entityId,
                 userId
             );
 
-            if (!module) {
-                throw Boom.notFound();
-            }
-
-            const testAuthResponse = await module.testAuth();
-
             if (!testAuthResponse) {
                 res.status(400);
                 res.json({
@@ -508,16 +545,12 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
             );
             const userId = user.getId();
             const params = checkRequiredParams(req.params, ['entityId']);
-            const module = await moduleFactory.getModuleInstanceFromEntityId(
+            const module = await getModule.execute(
                 params.entityId,
                 userId
             );
 
-            if (!module) {
-                throw Boom.notFound();
-            }
-
-            res.json(module.entity);
+            res.json(module);
         })
     );
 
@@ -530,16 +563,10 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
             const params = checkRequiredParams(req.params, [
                 'entityId',
             ]);
-            const module = await moduleFactory.getModuleInstanceFromEntityId(
-                params.entityId,
-                userId
-            );
 
-            if (!module) {
-                throw Boom.notFound();
-            }
+            const entityOptions = await getEntityOptionsById.execute(params.entityId, userId);
 
-            res.json(await module.getEntityOptions());
+            res.json(entityOptions);
         })
     );
 
@@ -552,16 +579,13 @@ function setEntityRoutes(router, factory, getUserFromBearerToken, useCases) {
             const params = checkRequiredParams(req.params, [
                 'entityId',
             ]);
-            const module = await moduleFactory.getModuleInstanceFromEntityId(
+            const updatedOptions = await refreshEntityOptions.execute(
                 params.entityId,
-                userId
+                userId,
+                req.body
             );
 
-            if (!module) {
-                throw Boom.notFound();
-            }
-
-            res.json(await module.refreshEntityOptions(req.body));
+            res.json(updatedOptions);
         })
     );
 }

package/integrations/tests/doubles/dummy-integration-class.js

@@ -0,0 +1,90 @@
+const { IntegrationBase } = require('../../integration-base');
+
+class DummyModule {
+    static definition = {
+        getName: () => 'dummy'
+    };
+}
+
+class DummyIntegration extends IntegrationBase {
+    static Definition = {
+        name: 'dummy',
+        version: '1.0.0',
+        modules: {
+            dummy: DummyModule
+        },
+        display: {
+            label: 'Dummy Integration',
+            description: 'A dummy integration for testing',
+            detailsUrl: 'https://example.com',
+            icon: 'dummy-icon'
+        }
+    };
+
+    static getOptionDetails() {
+        return {
+            name: this.Definition.name,
+            version: this.Definition.version,
+            display: this.Definition.display
+        };
+    }
+
+    constructor(params) {
+        super(params);
+        this.sendSpy = jest.fn();
+        this.eventCallHistory = [];
+        this.events = {};
+
+        this.integrationRepository = {
+            updateIntegrationById: jest.fn().mockResolvedValue({}),
+            findIntegrationById: jest.fn().mockResolvedValue({}),
+        };
+
+        this.updateIntegrationStatus = {
+            execute: jest.fn().mockResolvedValue({})
+        };
+
+        this.updateIntegrationMessages = {
+            execute: jest.fn().mockResolvedValue({})
+        };
+
+        this.registerEventHandlers();
+    }
+
+    async loadDynamicUserActions() {
+        return {};
+    }
+
+    async registerEventHandlers() {
+        super.registerEventHandlers();
+        return;
+    }
+
+    async send(event, data) {
+        this.sendSpy(event, data);
+        this.eventCallHistory.push({ event, data, timestamp: Date.now() });
+        return super.send(event, data);
+    }
+
+    async initialize() {
+        return;
+    }
+
+    async onCreate({ integrationId }) {
+        return;
+    }
+
+    async onUpdate(params) {
+        return;
+    }
+
+    async onDelete(params) {
+        return;
+    }
+
+    getConfig() {
+        return this.config || {};
+    }
+}
+
+module.exports = { DummyIntegration }; 

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

@@ -0,0 +1,89 @@
+const { v4: uuid } = require('uuid');
+
+class TestIntegrationRepository {
+    constructor() {
+        this.store = new Map();
+        this.operationHistory = [];
+    }
+
+    async createIntegration(entities, userId, config) {
+        const id = uuid();
+        const record = {
+            id,
+            _id: id,
+            entitiesIds: entities,
+            userId: userId,
+            config,
+            version: '0.0.0',
+            status: 'NEW',
+            messages: {},
+        };
+        this.store.set(id, record);
+        this.operationHistory.push({ operation: 'create', id, userId, config });
+        return record;
+    }
+
+    async findIntegrationById(id) {
+        const rec = this.store.get(id);
+        this.operationHistory.push({ operation: 'findById', id, found: !!rec });
+        if (!rec) return null;
+        return rec;
+    }
+
+    async findIntegrationsByUserId(userId) {
+        const results = Array.from(this.store.values()).filter(r => r.userId === userId);
+        this.operationHistory.push({ operation: 'findByUserId', userId, count: results.length });
+        return results;
+    }
+
+    async updateIntegrationMessages(id, type, title, body, timestamp) {
+        const rec = this.store.get(id);
+        if (!rec) {
+            this.operationHistory.push({ operation: 'updateMessages', id, success: false });
+            return false;
+        }
+        if (!rec.messages[type]) rec.messages[type] = [];
+        rec.messages[type].push({ title, message: body, timestamp });
+        this.operationHistory.push({ operation: 'updateMessages', id, type, success: true });
+        return true;
+    }
+
+    async updateIntegrationConfig(id, config) {
+        const rec = this.store.get(id);
+        if (!rec) {
+            this.operationHistory.push({ operation: 'updateConfig', id, success: false });
+            return false;
+        }
+        rec.config = config;
+        this.operationHistory.push({ operation: 'updateConfig', id, success: true });
+        return true;
+    }
+
+    async deleteIntegrationById(id) {
+        const existed = this.store.has(id);
+        const result = this.store.delete(id);
+        this.operationHistory.push({ operation: 'delete', id, existed, success: result });
+        return result;
+    }
+
+    async updateIntegrationStatus(id, status) {
+        const rec = this.store.get(id);
+        if (rec) {
+            rec.status = status;
+            this.operationHistory.push({ operation: 'updateStatus', id, status, success: true });
+        } else {
+            this.operationHistory.push({ operation: 'updateStatus', id, status, success: false });
+        }
+        return !!rec;
+    }
+
+    getOperationHistory() {
+        return [...this.operationHistory];
+    }
+
+    clearHistory() {
+        this.operationHistory = [];
+    }
+}
+
+module.exports = { TestIntegrationRepository }; 

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

@@ -0,0 +1,124 @@
+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', () => {
+    let integrationRepository;
+    let moduleFactory;
+    let useCase;
+
+    beforeEach(() => {
+        integrationRepository = new TestIntegrationRepository();
+        moduleFactory = new TestModuleFactory();
+        useCase = new CreateIntegration({
+            integrationRepository,
+            integrationClasses: [DummyIntegration],
+            moduleFactory,
+        });
+    });
+
+    describe('happy path', () => {
+        it('creates an integration and returns DTO', async () => {
+            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);
+            expect(dto.entities).toEqual(entities);
+            expect(dto.status).toBe('NEW');
+        });
+
+        it('triggers ON_CREATE event with correct payload', async () => {
+            const entities = ['entity-1'];
+            const userId = 'user-1';
+            const config = { type: 'dummy', foo: 'bar' };
+
+            const dto = await useCase.execute(entities, userId, config);
+
+            const record = await integrationRepository.findIntegrationById(dto.id);
+            expect(record).toBeTruthy();
+
+            const history = integrationRepository.getOperationHistory();
+            const createOperation = history.find(op => op.operation === 'create');
+            expect(createOperation).toEqual({
+                operation: 'create',
+                id: dto.id,
+                userId,
+                config
+            });
+        });
+
+        it('loads modules for each entity', async () => {
+            const entities = ['entity-1', 'entity-2'];
+            const userId = 'user-1';
+            const config = { type: 'dummy' };
+
+            const dto = await useCase.execute(entities, userId, config);
+
+            expect(dto.entities).toEqual(entities);
+        });
+    });
+
+    describe('error cases', () => {
+        it('throws error when integration class is not found', async () => {
+            const entities = ['entity-1'];
+            const userId = 'user-1';
+            const config = { type: 'unknown-type' };
+
+            await expect(useCase.execute(entities, userId, config))
+                .rejects
+                .toThrow('No integration class found for type: unknown-type');
+        });
+
+        it('throws error when no integration classes provided', async () => {
+            const useCaseWithoutClasses = new CreateIntegration({
+                integrationRepository,
+                integrationClasses: [],
+                moduleFactory,
+            });
+
+            const entities = ['entity-1'];
+            const userId = 'user-1';
+            const config = { type: 'dummy' };
+
+            await expect(useCaseWithoutClasses.execute(entities, userId, config))
+                .rejects
+                .toThrow('No integration class found for type: dummy');
+        });
+    });
+
+    describe('edge cases', () => {
+        it('handles empty entities array', async () => {
+            const entities = [];
+            const userId = 'user-1';
+            const config = { type: 'dummy' };
+
+            const dto = await useCase.execute(entities, userId, config);
+
+            expect(dto.entities).toEqual([]);
+            expect(dto.id).toBeDefined();
+        });
+
+        it('handles complex config objects', async () => {
+            const entities = ['entity-1'];
+            const userId = 'user-1';
+            const config = {
+                type: 'dummy',
+                nested: {
+                    value: 123,
+                    array: [1, 2, 3],
+                    bool: true
+                }
+            };
+
+            const dto = await useCase.execute(entities, userId, config);
+
+            expect(dto.config).toEqual(config);
+        });
+    });
+});