@friggframework/core 2.0.0--canary.405.1f6792c.0 → 2.0.0--canary.396.6862738.0

package/integrations/integration-router.js

@@ -2,23 +2,89 @@ const express = require('express');
 const { get } = require('../assertions');
 const Boom = require('@hapi/boom');
 const catchAsyncError = require('express-async-handler');
-const { debug } = require('../logs');
+const { IntegrationRepository } = require('./integration-repository');
+const { DeleteIntegrationForUser } = require('./use-cases/delete-integration-for-user');
+const { GetIntegrationsForUser } = require('./use-cases/get-integrations-for-user');
+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 { 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 moduleRepository = new ModuleRepository();
+    const integrationRepository = new IntegrationRepository();
+    const credentialRepository = new CredentialRepository();
+
+    const moduleService = new ModuleService({
+        moduleRepository,
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+    const deleteIntegrationForUser = new DeleteIntegrationForUser({
+        integrationRepository,
+        integrationClasses,
+    });
+
+    const getIntegrationsForUser = new GetIntegrationsForUser({
+        integrationRepository,
+        integrationClasses,
+        moduleService,
+        moduleRepository,
+    });
+    const getCredentialForUser = new GetCredentialForUser({
+        credentialRepository,
+    });
+    const createIntegration = new CreateIntegration({
+        integrationRepository,
+        integrationClasses,
+        moduleService,
+    });
+
+    const getEntitiesForUser = new GetEntitiesForUser({
+        moduleRepository,
+        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+
+    const getIntegrationInstance = new GetIntegrationInstance({
+        integrationRepository,
+        integrationClasses,
+        moduleService,
+    });
+
+    const updateIntegration = new UpdateIntegration({
+        integrationRepository,
+        integrationClasses,
+        moduleService,
+    });
+
     const router = get(params, 'router', express());
     const factory = get(params, 'factory');
-    const getUserId = get(params, 'getUserId', (req) => null);
-    const requireLoggedInUser = get(
-        params,
-        'requireLoggedInUser',
-        (req, res, next) => next()
-    );
-
-    router.all('/api/entities*', requireLoggedInUser);
-    router.all('/api/authorize', requireLoggedInUser);
-    router.all('/api/integrations*', requireLoggedInUser);
-
-    setIntegrationRoutes(router, factory, getUserId);
-    setEntityRoutes(router, factory, getUserId);
+    const getUserFromBearerToken = get(params, 'getUserFromBearerToken');
+
+    setIntegrationRoutes(router, getUserFromBearerToken, {
+        createIntegration,
+        deleteIntegrationForUser,
+        getIntegrationsForUser,
+        getEntitiesForUser,
+        getIntegrationInstance,
+        updateIntegration,
+    });
+    setEntityRoutes(router, factory, getUserFromBearerToken, {
+        getCredentialForUser,
+    });
     return router;
 }
 
@@ -36,121 +102,104 @@ function checkRequiredParams(params, requiredKeys) {
 
     if (missingKeys.length > 0) {
         throw Boom.badRequest(
-            `Missing Parameter${
-                missingKeys.length === 1 ? '' : 's'
-            }: ${missingKeys.join(', ')} ${
-                missingKeys.length === 1 ? 'is' : 'are'
+            `Missing Parameter${missingKeys.length === 1 ? '' : 's'
+            }: ${missingKeys.join(', ')} ${missingKeys.length === 1 ? 'is' : 'are'
             } required.`
         );
     }
     return returnDict;
 }
 
-function setIntegrationRoutes(router, factory, getUserId) {
-    const { moduleFactory, integrationFactory, IntegrationHelper } = factory;
+/**
+ * Sets up integration-related routes on the provided Express router
+ * @param {express.Router} router - Express router instance to add routes to
+ * @param {import('../user/use-cases/get-user-from-bearer-token').GetUserFromBearerToken} getUserFromBearerToken - Use case for retrieving a user from a bearer token
+ * @param {Object} useCases - use cases for integration management
+ */
+function setIntegrationRoutes(router, getUserFromBearerToken, useCases) {
+    const {
+        createIntegration,
+        deleteIntegrationForUser,
+        getIntegrationsForUser,
+        getEntitiesForUser,
+        getIntegrationInstance,
+        updateIntegration,
+    } = useCases;
     router.route('/api/integrations').get(
         catchAsyncError(async (req, res) => {
-            const results = await integrationFactory.getIntegrationOptions();
-            results.entities.authorized =
-                await moduleFactory.getEntitiesForUser(getUserId(req));
-            results.integrations =
-                await IntegrationHelper.getIntegrationsForUserId(
-                    getUserId(req)
-                );
-
-            for (const integrationRecord of results.integrations) {
-                const integration =
-                    await integrationFactory.getInstanceFromIntegrationId({
-                        integrationId: integrationRecord.id,
-                        userId: getUserId(req),
-                    });
-                integrationRecord.userActions = integration.userActions;
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
+            );
+            const userId = user.getId();
+            const integrations = await getIntegrationsForUser.execute(userId);
+            const results = {
+                entities: {
+                    options: integrations.map((integration) =>
+                        integration.options
+                    ),
+                    authorized: await getEntitiesForUser.execute(userId),
+                },
+                integrations: integrations,
             }
+
             res.json(results);
         })
     );
 
     router.route('/api/integrations').post(
         catchAsyncError(async (req, res) => {
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
+            );
+            const userId = user.getId();
             const params = checkRequiredParams(req.body, [
                 'entities',
                 'config',
             ]);
-            // throw if not value
+
             get(params.config, 'type');
 
-            // create integration
-            const integration = await integrationFactory.createIntegration(
+            const integration = await createIntegration.execute(
                 params.entities,
-                getUserId(req),
+                userId,
                 params.config
             );
 
-            // post integration initialization
-            debug(
-                `Calling onCreate on the ${integration?.constructor?.Config?.name} Integration with no arguments`
-            );
-            await integration.send('ON_CREATE', {});
-
-            res.status(201).json(
-                await IntegrationHelper.getFormattedIntegration(
-                    integration.record
-                )
-            );
+            res.status(201).json(integration);
         })
     );
 
     router.route('/api/integrations/:integrationId').patch(
         catchAsyncError(async (req, res) => {
-            const params = checkRequiredParams(req.body, ['config']);
-
-            const integration =
-                await integrationFactory.getInstanceFromIntegrationId({
-                    integrationId: req.params.integrationId,
-                    userId: getUserId(req),
-                });
-
-            debug(
-                `Calling onUpdate on the ${integration?.constructor?.Config?.name} Integration arguments: `,
-                params
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
             );
-            await integration.send('ON_UPDATE', params);
+            const userId = user.getId();
+            const params = checkRequiredParams(req.body, ['config']);
 
-            res.json(
-                await IntegrationHelper.getFormattedIntegration(
-                    integration.record
-                )
-            );
+            const integration = await updateIntegration.execute(req.params.integrationId, userId, params.config);
+            res.json(integration);
         })
     );
 
     router.route('/api/integrations/:integrationId').delete(
         catchAsyncError(async (req, res) => {
-            const params = checkRequiredParams(req.params, ['integrationId']);
-            const integration =
-                await integrationFactory.getInstanceFromIntegrationId({
-                    userId: getUserId(req),
-                    integrationId: params.integrationId,
-                });
-
-            debug(
-                `Calling onUpdate on the ${integration?.constructor?.Definition?.name} Integration with no arguments`
-            );
-            await integration.send('ON_DELETE');
-            await IntegrationHelper.deleteIntegrationForUserById(
-                getUserId(req),
-                params.integrationId
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
             );
-
-            res.status(201).json({});
+            const params = checkRequiredParams(req.params, ['integrationId']);
+            await deleteIntegrationForUser.execute(params.integrationId, user.getId());
+            res.status(204).json({});
         })
     );
 
     router.route('/api/integrations/:integrationId/config/options').get(
         catchAsyncError(async (req, res) => {
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
+            );
             const params = checkRequiredParams(req.params, ['integrationId']);
-            const integration =
-                await integrationFactory.getInstanceFromIntegrationId(params);
+            const integration = await getIntegrationInstance.execute(params.integrationId, user.getId());
             res.json(await integration.send('GET_CONFIG_OPTIONS'));
         })
     );
@@ -159,13 +208,13 @@ function setIntegrationRoutes(router, factory, getUserId) {
         .route('/api/integrations/:integrationId/config/options/refresh')
         .post(
             catchAsyncError(async (req, res) => {
+                const user = await getUserFromBearerToken.execute(
+                    req.headers.authorization
+                );
                 const params = checkRequiredParams(req.params, [
                     'integrationId',
                 ]);
-                const integration =
-                    await integrationFactory.getInstanceFromIntegrationId(
-                        params
-                    );
+                const integration = await getIntegrationInstance.execute(params.integrationId, user.getId());
 
                 res.json(
                     await integration.send('REFRESH_CONFIG_OPTIONS', req.body)
@@ -174,9 +223,11 @@ function setIntegrationRoutes(router, factory, getUserId) {
         );
     router.route('/api/integrations/:integrationId/actions').all(
         catchAsyncError(async (req, res) => {
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
+            );
             const params = checkRequiredParams(req.params, ['integrationId']);
-            const integration =
-                await integrationFactory.getInstanceFromIntegrationId(params);
+            const integration = await getIntegrationInstance.execute(params.integrationId, user.getId());
             res.json(await integration.send('GET_USER_ACTIONS', req.body));
         })
     );
@@ -185,14 +236,14 @@ function setIntegrationRoutes(router, factory, getUserId) {
         .route('/api/integrations/:integrationId/actions/:actionId/options')
         .all(
             catchAsyncError(async (req, res) => {
+                const user = await getUserFromBearerToken.execute(
+                    req.headers.authorization
+                );
                 const params = checkRequiredParams(req.params, [
                     'integrationId',
                     'actionId',
                 ]);
-                const integration =
-                    await integrationFactory.getInstanceFromIntegrationId(
-                        params
-                    );
+                const integration = await getIntegrationInstance.execute(params.integrationId, user.getId());
 
                 res.json(
                     await integration.send('GET_USER_ACTION_OPTIONS', {
@@ -209,14 +260,14 @@ function setIntegrationRoutes(router, factory, getUserId) {
         )
         .post(
             catchAsyncError(async (req, res) => {
+                const user = await getUserFromBearerToken.execute(
+                    req.headers.authorization
+                );
                 const params = checkRequiredParams(req.params, [
                     'integrationId',
                     'actionId',
                 ]);
-                const integration =
-                    await integrationFactory.getInstanceFromIntegrationId(
-                        params
-                    );
+                const integration = await getIntegrationInstance.execute(params.integrationId, user.getId());
 
                 res.json(
                     await integration.send('REFRESH_USER_ACTION_OPTIONS', {
@@ -229,23 +280,31 @@ function setIntegrationRoutes(router, factory, getUserId) {
 
     router.route('/api/integrations/:integrationId/actions/:actionId').post(
         catchAsyncError(async (req, res) => {
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
+            );
             const params = checkRequiredParams(req.params, [
                 'integrationId',
                 'actionId',
             ]);
-            const integration =
-                await integrationFactory.getInstanceFromIntegrationId(params);
-
+            const integration = await getIntegrationInstance.execute(params.integrationId, user.getId());
             res.json(await integration.send(params.actionId, req.body));
         })
     );
 
     router.route('/api/integrations/:integrationId').get(
         catchAsyncError(async (req, res) => {
-            const params = checkRequiredParams(req.params, ['integrationId']);
-            const integration = await IntegrationHelper.getIntegrationById(
-                params.integrationId
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
             );
+
+            if (!user) {
+                throw Boom.forbidden('User not found');
+            }
+
+            const params = checkRequiredParams(req.params, ['integrationId']);
+            const integration = await getIntegrationForUser.execute(params.integrationId, user.getId());
+
             // We could perhaps augment router with dynamic options? Haven't decided yet, but here may be the place
 
             res.json({
@@ -259,12 +318,11 @@ function setIntegrationRoutes(router, factory, getUserId) {
 
     router.route('/api/integrations/:integrationId/test-auth').get(
         catchAsyncError(async (req, res) => {
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
+            );
             const params = checkRequiredParams(req.params, ['integrationId']);
-            const instance =
-                await integrationFactory.getInstanceFromIntegrationId({
-                    userId: getUserId(req),
-                    integrationId: params.integrationId,
-                });
+            const instance = await getIntegrationInstance.execute(params.integrationId, user.getId());
 
             if (!instance) {
                 throw Boom.notFound();
@@ -286,9 +344,17 @@ function setIntegrationRoutes(router, factory, getUserId) {
     );
 }
 
-function setEntityRoutes(router, factory, getUserId) {
-    const { moduleFactory, IntegrationHelper } = factory;
-    const getModuleInstance = async (req, entityType) => {
+
+/**
+ * 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(
@@ -298,19 +364,23 @@ function setEntityRoutes(router, factory, getUserId) {
         }
         return await moduleFactory.getInstanceFromTypeName(
             entityType,
-            getUserId(req)
+            userId
         );
     };
 
     router.route('/api/authorize').get(
         catchAsyncError(async (req, res) => {
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
+            );
+            const userId = user.getId();
             const params = checkRequiredParams(req.query, ['entityType']);
-            const module = await getModuleInstance(req, params.entityType);
+            const module = await getModuleInstance(userId, params.entityType);
             const areRequirementsValid =
                 module.validateAuthorizationRequirements();
             if (!areRequirementsValid) {
                 throw new Error(
-                    `Error: EntityManager of type ${params.entityType} requires a valid url`
+                    `Error: Entity of type ${params.entityType} requires a valid url`
                 );
             }
 
@@ -320,15 +390,19 @@ function setEntityRoutes(router, factory, getUserId) {
 
     router.route('/api/authorize').post(
         catchAsyncError(async (req, res) => {
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
+            );
+            const userId = user.getId();
             const params = checkRequiredParams(req.body, [
                 'entityType',
                 'data',
             ]);
-            const module = await getModuleInstance(req, params.entityType);
+            const module = await getModuleInstance(userId, params.entityType);
 
             res.json(
                 await module.processAuthorizationCallback({
-                    userId: getUserId(req),
+                    userId,
                     data: params.data,
                 })
             );
@@ -337,6 +411,10 @@ function setEntityRoutes(router, factory, getUserId) {
 
     router.route('/api/entity').post(
         catchAsyncError(async (req, res) => {
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
+            );
+            const userId = user.getId();
             const params = checkRequiredParams(req.body, [
                 'entityType',
                 'data',
@@ -344,20 +422,21 @@ function setEntityRoutes(router, factory, getUserId) {
             checkRequiredParams(req.body.data, ['credential_id']);
 
             // May want to pass along the user ID as well so credential ID's can't be fished???
-            const credential = await IntegrationHelper.getCredentialById(
-                params.data.credential_id
+            const credential = await getCredentialForUser.execute(
+                params.data.credential_id,
+                userId
             );
 
             if (!credential) {
                 throw Boom.badRequest('Invalid credential ID');
             }
 
-            const module = await getModuleInstance(req, params.entityType);
+            const module = await getModuleInstance(userId, params.entityType);
             const entityDetails = await module.getEntityDetails(
                 module.api,
                 null,
                 null,
-                getUserId(req)
+                userId
             );
 
             res.json(await module.findOrCreateEntity(entityDetails));
@@ -366,17 +445,22 @@ function setEntityRoutes(router, factory, getUserId) {
 
     router.route('/api/entity/options/:credentialId').get(
         catchAsyncError(async (req, res) => {
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
+            );
+            const userId = user.getId();
             // TODO May want to pass along the user ID as well so credential ID's can't be fished???
             // TODO **flagging this for review** -MW
-            const credential = await IntegrationHelper.getCredentialById(
-                req.params.credentialId
+            const credential = await getCredentialForUser.execute(
+                req.params.credentialId,
+                userId
             );
-            if (credential.user._id.toString() !== getUserId(req)) {
+            if (credential.user._id.toString() !== userId) {
                 throw Boom.forbidden('Credential does not belong to user');
             }
 
             const params = checkRequiredParams(req.query, ['entityType']);
-            const module = await getModuleInstance(req, params.entityType);
+            const module = await getModuleInstance(userId, params.entityType);
 
             res.json(await module.getEntityOptions());
         })
@@ -384,10 +468,14 @@ function setEntityRoutes(router, factory, getUserId) {
 
     router.route('/api/entities/:entityId/test-auth').get(
         catchAsyncError(async (req, res) => {
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
+            );
+            const userId = user.getId();
             const params = checkRequiredParams(req.params, ['entityId']);
             const module = await moduleFactory.getModuleInstanceFromEntityId(
                 params.entityId,
-                getUserId(req)
+                userId
             );
 
             if (!module) {
@@ -415,10 +503,14 @@ function setEntityRoutes(router, factory, getUserId) {
 
     router.route('/api/entities/:entityId').get(
         catchAsyncError(async (req, res) => {
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
+            );
+            const userId = user.getId();
             const params = checkRequiredParams(req.params, ['entityId']);
             const module = await moduleFactory.getModuleInstanceFromEntityId(
                 params.entityId,
-                getUserId(req)
+                userId
             );
 
             if (!module) {
@@ -431,13 +523,16 @@ function setEntityRoutes(router, factory, getUserId) {
 
     router.route('/api/entities/:entityId/options').post(
         catchAsyncError(async (req, res) => {
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
+            );
+            const userId = user.getId();
             const params = checkRequiredParams(req.params, [
                 'entityId',
-                getUserId(req),
             ]);
             const module = await moduleFactory.getModuleInstanceFromEntityId(
                 params.entityId,
-                getUserId(req)
+                userId
             );
 
             if (!module) {
@@ -450,13 +545,16 @@ function setEntityRoutes(router, factory, getUserId) {
 
     router.route('/api/entities/:entityId/options/refresh').post(
         catchAsyncError(async (req, res) => {
+            const user = await getUserFromBearerToken.execute(
+                req.headers.authorization
+            );
+            const userId = user.getId();
             const params = checkRequiredParams(req.params, [
                 'entityId',
-                getUserId(req),
             ]);
             const module = await moduleFactory.getModuleInstanceFromEntityId(
                 params.entityId,
-                getUserId(req)
+                userId
             );
 
             if (!module) {