@friggframework/core 0.2.31-v1-alpha-package-update.0 → 1.0.1-v1-alpha-package-update.1

package/integrations/integration-factory.js

@@ -0,0 +1,166 @@
+const { ModuleFactory, Credential, Entity } = require('../module-plugin');
+const {IntegrationModel} = require("./integration-model");
+const _ = require('lodash');
+
+
+class IntegrationFactory {
+    constructor(integrationClasses = []) {
+        this.integrationClasses = integrationClasses;
+        this.moduleFactory = new ModuleFactory(...this.getModules());
+        this.integrationTypes = this.integrationClasses.map(IntegrationClass => IntegrationClass.getName());
+        this.getIntegrationConfigs = this.integrationClasses.map(IntegrationClass => IntegrationClass.Config);
+    }
+
+    async getIntegrationOptions() {
+        const options = this.integrationClasses.map(IntegrationClass => IntegrationClass.Options);
+        return {
+            entities: {
+                primary: this.getPrimaryName(),
+                options: options.map(val => val.get()),
+                authorized: [],
+            },
+            integrations: [],
+        };
+    }
+
+    getModules() {
+        return  [... new Set(this.integrationClasses.map(integration =>
+            Object.values(integration.modules)
+        ).flat())];
+    }
+
+    getPrimaryName() {
+        function findMostFrequentElement(array) {
+            const frequencyMap = _.countBy(array);
+            return _.maxBy(_.keys(frequencyMap), (element) => frequencyMap[element]);
+        }
+        const allModulesNames = _.flatten(this.integrationClasses.map(integration =>
+            Object.values(integration.modules).map(module => module.getName())
+        ));
+        return findMostFrequentElement(allModulesNames);
+    }
+
+    getIntegrationClassDefByType(type) {
+        const integrationClassIndex = this.integrationTypes.indexOf(type);
+        return this.integrationClasses[integrationClassIndex];
+    }
+
+    async getInstanceFromIntegrationId(params) {
+        const integrationRecord = await IntegrationHelper.getIntegrationById(params.integrationId);
+        let {userId} = params;
+        if (!integrationRecord) {
+            throw new Error(`No integration found by the ID of ${params.integrationId}`);
+        }
+
+        if (!userId) {
+            userId = integrationRecord.user._id.toString();
+        } else if (userId !== integrationRecord.user._id.toString()) {
+            throw new Error(`Integration ${params.integrationId} does not belong to User ${userId}, ${integrationRecord.user.id.toString()}`);
+        }
+
+        const integrationClassDef = this.getIntegrationClassDefByType(integrationRecord.config.type);
+        const instance = new integrationClassDef({
+            userId,
+            integrationId: params.integrationId,
+        });
+        instance.record = integrationRecord;
+        instance.delegateTypes.push(...integrationClassDef.Config.events);
+        instance.primary = await this.moduleFactory.getModuleInstanceFromEntityId(
+            instance.record.entities[0],
+            instance.record.user
+        );
+        instance.target = await this.moduleFactory.getModuleInstanceFromEntityId(
+            instance.record.entities[1],
+            instance.record.user
+        );
+
+        try {
+            await instance.getAndSetUserActions();
+            instance.delegateTypes.push(...Object.keys(instance.userActions));
+        } catch(e) {
+            instance.userActions = {};
+            instance.record.status = 'ERROR';
+            instance.record.messages.errors.push(e);
+            await instance.record.save();
+        }
+        return instance;
+    }
+
+    async createIntegration(entities, userId, config) {
+        // verify entity ids belong to the user
+        // for (const id of entities) {
+        //     const entity = await Entity.findById(id);
+        //     if (!entity) {
+        //         throw new Error(`Entity with ID ${id} does not exist.`);
+        //     }
+        //     if (entity.user.toString() !== userId.toString()) {
+        //         throw new Error('one or more the entities do not belong to the user');
+        //     }
+        // }
+
+        // build integration
+        const integrationRecord = await IntegrationModel.create({
+            entities: entities,
+            user: userId,
+            config,
+            version: '0.0.0',
+        });
+        return await this.getInstanceFromIntegrationId({integrationId: integrationRecord.id, userId});
+    }
+}
+
+const IntegrationHelper = {
+     getFormattedIntegration: async function(integrationRecord) {
+        const integrationObj = {
+            id: integrationRecord.id,
+            status: integrationRecord.status,
+            config: integrationRecord.config,
+            entities: [],
+            version: integrationRecord.version,
+            messages: integrationRecord.messages,
+        };
+        for (const entityId of integrationRecord.entities) {
+            // Only return non-internal fields. Leverages "select" and "options" to non-excepted fields and a pure object.
+            const entity = await Entity.findById(
+                entityId,
+                '-createdAt -updatedAt -user -credentials -credential -_id -__t -__v',
+                { lean: true }
+            );
+            integrationObj.entities.push({
+                id: entityId,
+                ...entity,
+            });
+        }
+        return integrationObj;
+    },
+
+     getIntegrationsForUserId: async function(userId) {
+        const integrationList = await IntegrationModel.find({ user: userId });
+        return await Promise.all(integrationList.map(async (integrationRecord) =>
+            await IntegrationHelper.getFormattedIntegration(integrationRecord)
+        ));
+    },
+
+     deleteIntegrationForUserById: async function(userId, integrationId) {
+        const integrationList = await IntegrationModel.find({
+            user: userId,
+            _id: integrationId,
+        });
+        if (integrationList.length !== 1) {
+            throw new Error(
+                `Integration with id of ${integrationId} does not exist for this user`
+            );
+        }
+        await IntegrationModel.deleteOne({ _id: integrationId });
+    },
+
+     getIntegrationById: async function(id) {
+        return IntegrationModel.findById(id);
+    },
+
+     listCredentials: async function(options) {
+        return Credential.find(options);
+    }
+}
+
+module.exports = { IntegrationFactory, IntegrationHelper };

package/integrations/integration-mapping.js

@@ -0,0 +1,43 @@
+const { mongoose } = require('../database/mongoose');
+const { Encrypt } = require('../encrypt');
+
+const schema = new mongoose.Schema(
+    {
+        integration: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'Integration',
+            required: true,
+        },
+        sourceId: { type: String }, // Used for lookups
+        mapping: {}
+    },
+    { timestamps: true }
+);
+
+schema.plugin(Encrypt);
+
+schema.static({
+    findBy: async function (integrationId, sourceId) {
+        const mappings = await this.find({ integration: integrationId, sourceId });
+        if (mappings.length === 0) {
+            return null;
+        } else if (mappings.length === 1) {
+            return mappings[0].mapping;
+        } else {
+            throw new Error('multiple integration mappings with same sourceId');
+        }
+    },
+    upsert: async function (integrationId, sourceId, mapping) {
+        return this.findOneAndUpdate(
+            { integration: integrationId, sourceId },
+            { mapping },
+            { new: true, upsert: true, setDefaultsOnInsert: true }
+        );
+    },
+});
+
+schema.index({ integration: 1, sourceId: 1 });
+
+const IntegrationMapping =
+    mongoose.models.IntegrationMapping || mongoose.model('IntegrationMapping', schema);
+module.exports = { IntegrationMapping };

package/integrations/integration-model.js

@@ -0,0 +1,42 @@
+const { mongoose } = require('../database/mongoose');
+
+const schema = new mongoose.Schema(
+    {
+        entities: [
+            {
+                type: mongoose.Schema.Types.ObjectId,
+                ref: 'Entity',
+                required: true,
+            },
+        ],
+        user: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'User',
+            required: false,
+        },
+        status: {
+            type: String,
+            enum: [
+                'ENABLED',
+                'NEEDS_CONFIG',
+                'PROCESSING',
+                'DISABLED',
+                'ERROR',
+            ],
+            default: 'ENABLED',
+        },
+        config: {},
+        version: { type: String },
+        messages: {
+            errors: [],
+            warnings: [],
+            info: [],
+            logs: [],
+        },
+    },
+    { timestamps: true }
+);
+
+const Integration =
+    mongoose.models.Integration || mongoose.model('Integration', schema);
+module.exports = { IntegrationModel: Integration };

package/integrations/integration-router.js

@@ -0,0 +1,367 @@
+const express = require('express');
+const { get } = require('../assertions');
+const Boom = require('@hapi/boom');
+const catchAsyncError = require('express-async-handler');
+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;
+}
+
+function checkRequiredParams(params, requiredKeys) {
+    const missingKeys = [];
+    const returnDict = {};
+    for (const key of requiredKeys) {
+        const val = get(params, key, null);
+        if (val) {
+            returnDict[key] = val;
+        } else {
+            missingKeys.push(key);
+        }
+    }
+
+    if (missingKeys.length > 0) {
+        throw Boom.badRequest(
+            `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;
+    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;
+            }
+            res.json(results);
+        })
+    );
+
+    router.route('/api/integrations').post(
+        catchAsyncError(async (req, res) => {
+            const params = checkRequiredParams(req.body, [
+                'entities',
+                'config',
+            ]);
+            // throw if not value
+            get(params.config, 'type');
+
+            // create integration
+            const integration =
+                await integrationFactory.createIntegration(
+                    params.entities,
+                    getUserId(req),
+                    params.config,
+                    moduleFactory
+                );
+
+            // post integration initialization
+            debug(
+                `Calling onCreate on the ${integration?.constructor?.Config?.name} Integration with no arguments`
+            );
+            await integration.onCreate();
+
+            // filtered set for results
+            const response = await IntegrationHelper.getFormattedIntegration(
+                integration.record
+            );
+            res.status(201);
+            res.json(response);
+        })
+    );
+
+    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
+            );
+            await integration.onUpdate(params);
+
+            const response = await IntegrationHelper.getFormattedIntegration(
+                integration.record
+            );
+
+            res.json(response);
+        })
+    );
+
+    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?.Config?.name} Integration with no arguments`
+            );
+            await integration.onDelete();
+            await IntegrationHelper.deleteIntegrationForUserById(
+                getUserId(req),
+                params.integrationId
+            );
+
+            res.status(201);
+            res.json({});
+        })
+    );
+
+    router.route('/api/integrations/:integrationId/config/options').get(
+        catchAsyncError(async (req, res) => {
+            const params = checkRequiredParams(req.params, [
+                'integrationId',
+            ]);
+            const integration =
+                await integrationFactory.getInstanceFromIntegrationId(params);
+            const results = await integration.getConfigOptions();
+            // We could perhaps augment router with dynamic options? Haven't decided yet, but here may be the place
+            res.json(results);
+        })
+    );
+
+    router.route('/api/integrations/:integrationId/actions/:actionId/options').get(
+        catchAsyncError(async (req, res) => {
+            const params = checkRequiredParams(req.params, [
+                'integrationId',
+                'actionId'
+            ]);
+            const integration =
+                await integrationFactory.getInstanceFromIntegrationId(params);
+            const results = await integration.getActionOptions(
+                params.actionId
+            );
+            // We could perhaps augment router with dynamic options? Haven't decided yet, but here may be the place
+            res.json(results);
+        })
+    );
+
+    router.route('/api/integrations/:integrationId/actions/:actionId').post(
+        catchAsyncError(async (req, res) => {
+            const params = checkRequiredParams(req.params, [
+                'integrationId',
+                'actionId'
+            ]);
+            const integration =
+                await integrationFactory.getInstanceFromIntegrationId(params);
+            const results = await integration.notify(
+                params.actionId,
+                req.body
+            );
+            // We could perhaps augment router with dynamic options? Haven't decided yet, but here may be the place
+            res.json(results);
+        })
+    )
+
+    router.route('/api/integrations/:integrationId').get(
+        catchAsyncError(async (req, res) => {
+            const params = checkRequiredParams(req.params, [
+                'integrationId',
+            ]);
+            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({
+                id: integration.id,
+                entities: integration.entities,
+                status: integration.status,
+                config: integration.config,
+            });
+        })
+    );
+
+    router.route('/api/integrations/:integrationId/test-auth').get(
+        catchAsyncError(async (req, res) => {
+            const params = checkRequiredParams(req.params, [
+                'integrationId',
+            ]);
+            const instance = await integrationFactory.getInstanceFromIntegrationId({
+                userId: getUserId(req),
+                integrationId: params.integrationId,
+            });
+
+            if (!instance) {
+                throw Boom.notFound();
+            }
+
+            const start = Date.now();
+            await instance.testAuth();
+            const errors = instance.record.messages?.errors?.filter(
+                ({ timestamp }) => timestamp >= start
+            );
+
+            if (errors?.length) {
+                res.status(400);
+                res.json({ errors });
+            } else {
+                res.json({ status: 'ok' });
+            }
+        })
+    );
+}
+
+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 params = checkRequiredParams(req.query, [
+                'entityType',
+            ]);
+            const module = await getModuleInstance(req, params.entityType);
+            const areRequirementsValid =
+                module.validateAuthorizationRequirements();
+            if (!areRequirementsValid) {
+                throw new Error(
+                    `Error: EntityManager of type ${params.entityType} requires a valid url`
+                );
+            }
+            res.json(await module.getAuthorizationRequirements());
+        })
+    );
+
+    router.route('/api/authorize').post(
+        catchAsyncError(async (req, res) => {
+            const params = checkRequiredParams(req.body, [
+                'entityType',
+                'data',
+            ]);
+            console.log('post authorize', params);
+            const module = await getModuleInstance(req, params.entityType);
+            console.log('post authorize module', module);
+            const results = await module.processAuthorizationCallback({
+                userId: getUserId(req),
+                data: params.data,
+            });
+
+            res.json(results);
+        })
+    );
+
+    router.route('/api/entity/options/:credentialId').get(
+        catchAsyncError(async (req, res) => {
+            // 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
+            );
+            if (credential.user._id.toString() !== getUserId(req)) {
+                throw Boom.forbidden('Credential does not belong to user');
+            }
+
+            const params = checkRequiredParams(req.query, [
+                'entityType',
+            ]);
+            const module = await getModuleInstance(req, params.entityType);
+
+            res.json(await module.getEntityOptions());
+        })
+    );
+
+    router.route('/api/entity').post(
+        catchAsyncError(async (req, res) => {
+            const params = checkRequiredParams(req.body, [
+                'entityType',
+                'data',
+            ]);
+            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
+            );
+
+            if (!credential) {
+                throw Boom.badRequest('Invalid credential ID');
+            }
+
+            const module = await getModuleInstance(req, params.entityType);
+            res.json(await module.findOrCreateEntity(params.data));
+        })
+    );
+
+    router.route('/api/entities/:entityId/test-auth').get(
+        catchAsyncError(async (req, res) => {
+            const params = checkRequiredParams(req.params, ['entityId']);
+            const module = await moduleFactory.getModuleInstanceFromEntityId(
+                params.entityId,
+                getUserId(req)
+            );
+
+            if (!module) {
+                throw Boom.notFound();
+            }
+
+            const testAuthResponse = await module.testAuth();
+
+            if (!testAuthResponse) {
+                res.status(400);
+                res.json({
+                    errors: [
+                        {
+                            title: 'Authentication Error',
+                            message: `There was an error with your ${module.constructor.getName()} Entity.  Please reconnect/re-authenticate, or reach out to Support for assistance.`,
+                            timestamp: Date.now(),
+                        },
+                    ],
+                });
+            } else {
+                res.json({status: 'ok'});
+            }
+        })
+    );
+}
+
+module.exports = { createIntegrationRouter, checkRequiredParams };