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

package/integrations/integration-router.js

@@ -2,144 +2,23 @@ const express = require('express');
 const { get } = require('../assertions');
 const Boom = require('@hapi/boom');
 const catchAsyncError = require('express-async-handler');
-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 { 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');
-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 moduleFactory = new ModuleFactory({
-        moduleRepository,
-        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
-    });
-    const deleteIntegrationForUser = new DeleteIntegrationForUser({
-        integrationRepository,
-        integrationClasses,
-    });
-
-    const getIntegrationsForUser = new GetIntegrationsForUser({
-        integrationRepository,
-        integrationClasses,
-        moduleFactory,
-        moduleRepository,
-    });
-
-    const getCredentialForUser = new GetCredentialForUser({
-        credentialRepository,
-    });
-
-    const createIntegration = new CreateIntegration({
-        integrationRepository,
-        integrationClasses,
-        moduleFactory,
-    });
-
-    const getEntitiesForUser = new GetEntitiesForUser({
-        moduleRepository,
-        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
-    });
-
-    const getIntegrationInstance = new GetIntegrationInstance({
-        integrationRepository,
-        integrationClasses,
-        moduleFactory,
-    });
-
-    const updateIntegration = new UpdateIntegration({
-        integrationRepository,
-        integrationClasses,
-        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 getPossibleIntegrations = new GetPossibleIntegrations({
-        integrationClasses,
-    });
-
-    const processAuthorizationCallback = new ProcessAuthorizationCallback({
-        moduleRepository,
-        credentialRepository,
-        moduleDefinitions: getModulesDefinitionFromIntegrationClasses(integrationClasses),
-    });
-
-    const router = express();
-
-    setIntegrationRoutes(router, getUserFromBearerToken, {
-        createIntegration,
-        deleteIntegrationForUser,
-        getIntegrationsForUser,
-        getEntitiesForUser,
-        getIntegrationInstance,
-        updateIntegration,
-        getPossibleIntegrations,
-    });
-    setEntityRoutes(router, getUserFromBearerToken, {
-        getCredentialForUser,
-        getModuleInstanceFromType,
-        getEntityOptionsByType,
-        testModuleAuth,
-        getModule,
-        getEntityOptionsById,
-        refreshEntityOptions,
-        processAuthorizationCallback,
-    });
+const { debug } = require('../logs');
+function createIntegrationRouter(params) {
+    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);
     return router;
 }
 
@@ -157,103 +36,121 @@ 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;
 }
 
-/**
- * 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,
-        getPossibleIntegrations,
-    } = useCases;
+function setIntegrationRoutes(router, factory, getUserId) {
+    const { moduleFactory, integrationFactory, IntegrationHelper } = factory;
     router.route('/api/integrations').get(
         catchAsyncError(async (req, res) => {
-            const user = await getUserFromBearerToken.execute(
-                req.headers.authorization
-            );
-            const userId = user.getId();
-            const integrations = await getIntegrationsForUser.execute(userId);
-            const results = {
-                entities: {
-                    options: await getPossibleIntegrations.execute(),
-                    authorized: await getEntitiesForUser.execute(userId),
-                },
-                integrations: integrations,
-            }
+            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;
+            }
             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');
 
-            const integration = await createIntegration.execute(
+            // create integration
+            const integration = await integrationFactory.createIntegration(
                 params.entities,
-                userId,
+                getUserId(req),
                 params.config
             );
 
-            res.status(201).json(integration);
+            // 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
+                )
+            );
         })
     );
 
     router.route('/api/integrations/:integrationId').patch(
         catchAsyncError(async (req, res) => {
-            const user = await getUserFromBearerToken.execute(
-                req.headers.authorization
-            );
-            const userId = user.getId();
             const params = checkRequiredParams(req.body, ['config']);
 
-            const integration = await updateIntegration.execute(req.params.integrationId, userId, params.config);
-            res.json(integration);
+            const integration =
+                await integrationFactory.getInstanceFromIntegrationId({
+                    integrationId: req.params.integrationId,
+                    userId: getUserId(req),
+                });
+
+            debug(
+                `Calling onUpdate on the ${integration?.constructor?.Config?.name} Integration arguments: `,
+                params
+            );
+            await integration.send('ON_UPDATE', params);
+
+            res.json(
+                await IntegrationHelper.getFormattedIntegration(
+                    integration.record
+                )
+            );
         })
     );
 
     router.route('/api/integrations/:integrationId').delete(
         catchAsyncError(async (req, res) => {
-            const user = await getUserFromBearerToken.execute(
-                req.headers.authorization
-            );
             const params = checkRequiredParams(req.params, ['integrationId']);
-            await deleteIntegrationForUser.execute(params.integrationId, user.getId());
-            res.status(204).json({});
+            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
+            );
+
+            res.status(201).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 getIntegrationInstance.execute(params.integrationId, user.getId());
+            const integration =
+                await integrationFactory.getInstanceFromIntegrationId(params);
             res.json(await integration.send('GET_CONFIG_OPTIONS'));
         })
     );
@@ -262,13 +159,13 @@ function setIntegrationRoutes(router, getUserFromBearerToken, useCases) {
         .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 getIntegrationInstance.execute(params.integrationId, user.getId());
+                const integration =
+                    await integrationFactory.getInstanceFromIntegrationId(
+                        params
+                    );
 
                 res.json(
                     await integration.send('REFRESH_CONFIG_OPTIONS', req.body)
@@ -277,11 +174,9 @@ function setIntegrationRoutes(router, getUserFromBearerToken, useCases) {
         );
     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 getIntegrationInstance.execute(params.integrationId, user.getId());
+            const integration =
+                await integrationFactory.getInstanceFromIntegrationId(params);
             res.json(await integration.send('GET_USER_ACTIONS', req.body));
         })
     );
@@ -290,14 +185,14 @@ function setIntegrationRoutes(router, getUserFromBearerToken, useCases) {
         .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 getIntegrationInstance.execute(params.integrationId, user.getId());
+                const integration =
+                    await integrationFactory.getInstanceFromIntegrationId(
+                        params
+                    );
 
                 res.json(
                     await integration.send('GET_USER_ACTION_OPTIONS', {
@@ -314,14 +209,14 @@ function setIntegrationRoutes(router, getUserFromBearerToken, useCases) {
         )
         .post(
             catchAsyncError(async (req, res) => {
-                const user = await getUserFromBearerToken.execute(
-                    req.headers.authorization
-                );
                 const params = checkRequiredParams(req.params, [
                     'integrationId',
                     'actionId',
                 ]);
-                const integration = await getIntegrationInstance.execute(params.integrationId, user.getId());
+                const integration =
+                    await integrationFactory.getInstanceFromIntegrationId(
+                        params
+                    );
 
                 res.json(
                     await integration.send('REFRESH_USER_ACTION_OPTIONS', {
@@ -334,31 +229,23 @@ function setIntegrationRoutes(router, getUserFromBearerToken, useCases) {
 
     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 getIntegrationInstance.execute(params.integrationId, user.getId());
+            const integration =
+                await integrationFactory.getInstanceFromIntegrationId(params);
+
             res.json(await integration.send(params.actionId, req.body));
         })
     );
 
     router.route('/api/integrations/:integrationId').get(
         catchAsyncError(async (req, res) => {
-            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 getIntegrationInstance.execute(params.integrationId, user.getId());
-
+            const integration = await IntegrationHelper.getIntegrationById(
+                params.integrationId
+            );
             // We could perhaps augment router with dynamic options? Haven't decided yet, but here may be the place
 
             res.json({
@@ -372,11 +259,12 @@ function setIntegrationRoutes(router, getUserFromBearerToken, useCases) {
 
     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 getIntegrationInstance.execute(params.integrationId, user.getId());
+            const instance =
+                await integrationFactory.getInstanceFromIntegrationId({
+                    userId: getUserId(req),
+                    integrationId: params.integrationId,
+                });
 
             if (!instance) {
                 throw Boom.notFound();
@@ -398,37 +286,31 @@ function setIntegrationRoutes(router, getUserFromBearerToken, useCases) {
     );
 }
 
-
-/**
- * Sets up entity-related routes for the integration router
- * @param {Object} router - Express router instance
- * @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, getUserFromBearerToken, useCases) {
-    const {
-        getCredentialForUser,
-        getModuleInstanceFromType,
-        getEntityOptionsByType,
-        testModuleAuth,
-        getModule,
-        getEntityOptionsById,
-        refreshEntityOptions,
-        processAuthorizationCallback,
-    } = useCases;
+function setEntityRoutes(router, factory, getUserId) {
+    const { moduleFactory, IntegrationHelper } = factory;
+    const getModuleInstance = async (req, entityType) => {
+        if (!moduleFactory.checkIsValidType(entityType)) {
+            throw Boom.badRequest(
+                `Error: Invalid entity type of ${entityType}, options are ${moduleFactory.moduleTypes.join(
+                    ', '
+                )}`
+            );
+        }
+        return await moduleFactory.getInstanceFromTypeName(
+            entityType,
+            getUserId(req)
+        );
+    };
 
     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 getModuleInstanceFromType.execute(userId, params.entityType);
+            const module = await getModuleInstance(req, params.entityType);
             const areRequirementsValid =
                 module.validateAuthorizationRequirements();
             if (!areRequirementsValid) {
                 throw new Error(
-                    `Error: Entity of type ${params.entityType} requires a valid url`
+                    `Error: EntityManager of type ${params.entityType} requires a valid url`
                 );
             }
 
@@ -438,27 +320,23 @@ function setEntityRoutes(router, getUserFromBearerToken, useCases) {
 
     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 entityDetails = await processAuthorizationCallback.execute(userId, params.entityType, params.data);
-
-            res.json(entityDetails);
+            res.json(
+                await module.processAuthorizationCallback({
+                    userId: getUserId(req),
+                    data: params.data,
+                })
+            );
         })
     );
 
     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',
@@ -466,21 +344,20 @@ function setEntityRoutes(router, getUserFromBearerToken, useCases) {
             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 getCredentialForUser.execute(
-                params.data.credential_id,
-                userId
+            const credential = await IntegrationHelper.getCredentialById(
+                params.data.credential_id
             );
 
             if (!credential) {
                 throw Boom.badRequest('Invalid credential ID');
             }
 
-            const module = await getModuleInstanceFromType.execute(userId, params.entityType);
+            const module = await getModuleInstance(req, params.entityType);
             const entityDetails = await module.getEntityDetails(
                 module.api,
                 null,
                 null,
-                userId
+                getUserId(req)
             );
 
             res.json(await module.findOrCreateEntity(entityDetails));
@@ -489,39 +366,36 @@ function setEntityRoutes(router, getUserFromBearerToken, useCases) {
 
     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 getCredentialForUser.execute(
-                req.params.credentialId,
-                userId
+            const credential = await IntegrationHelper.getCredentialById(
+                req.params.credentialId
             );
-            if (credential.user._id.toString() !== userId) {
+            if (credential.user._id.toString() !== getUserId(req)) {
                 throw Boom.forbidden('Credential does not belong to user');
             }
 
             const params = checkRequiredParams(req.query, ['entityType']);
-            const entityOptions = await getEntityOptionsByType.execute(userId, params.entityType);
+            const module = await getModuleInstance(req, params.entityType);
 
-            res.json(entityOptions);
+            res.json(await module.getEntityOptions());
         })
     );
 
     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 testAuthResponse = await testModuleAuth.execute(
+            const module = await moduleFactory.getModuleInstanceFromEntityId(
                 params.entityId,
-                userId
+                getUserId(req)
             );
 
+            if (!module) {
+                throw Boom.notFound();
+            }
+
+            const testAuthResponse = await module.testAuth();
+
             if (!testAuthResponse) {
                 res.status(400);
                 res.json({
@@ -541,52 +415,55 @@ function setEntityRoutes(router, getUserFromBearerToken, useCases) {
 
     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 getModule.execute(
+            const module = await moduleFactory.getModuleInstanceFromEntityId(
                 params.entityId,
-                userId
+                getUserId(req)
             );
 
-            res.json(module);
+            if (!module) {
+                throw Boom.notFound();
+            }
+
+            res.json(module.entity);
         })
     );
 
     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)
+            );
 
-            const entityOptions = await getEntityOptionsById.execute(params.entityId, userId);
+            if (!module) {
+                throw Boom.notFound();
+            }
 
-            res.json(entityOptions);
+            res.json(await module.getEntityOptions());
         })
     );
 
     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 updatedOptions = await refreshEntityOptions.execute(
+            const module = await moduleFactory.getModuleInstanceFromEntityId(
                 params.entityId,
-                userId,
-                req.body
+                getUserId(req)
             );
 
-            res.json(updatedOptions);
+            if (!module) {
+                throw Boom.notFound();
+            }
+
+            res.json(await module.refreshEntityOptions(req.body));
         })
     );
 }