@friggframework/core 0.1.2 → 0.2.0

package/managers/IntegrationManager.js

@@ -1,328 +0,0 @@
-const Delegate = require('../Delegate');
-const { Credential, Entity, Integration } = require('@friggframework/models');
-
-class IntegrationManager extends Delegate {
-    static Config = {
-        name: 'Integration Name',
-        version: '0.0.0', // Integration Version, used for migration and storage purposes, as well as display
-        supportedVersions: [], // Eventually usable for deprecation and future test version purposes
-
-        // an array of events that are process(able) by this Integration
-        events: [],
-    };
-
-    constructor(params) {
-        super(params);
-        this.integrationMO = new Integration();
-    }
-
-    static getName() {
-        return this.Config.name;
-    }
-
-    static getCurrentVersion() {
-        return this.Config.version;
-    }
-
-    async validateConfig() {
-        const configOptions = await this.getConfigOptions();
-        const currentConfig = this.integration.config;
-        let needsConfig = false;
-        for (const option of configOptions) {
-            if (option.required) {
-                // For now, just make sure the key exists. We should add more dynamic/better validation later.
-                if (
-                    !Object.prototype.hasOwnProperty.call(
-                        currentConfig,
-                        option.key
-                    )
-                ) {
-                    needsConfig = true;
-                    this.integration.messages.warnings.push({
-                        title: 'Config Validation Error',
-                        message: `Missing required field of ${option.label}`,
-                        timestamp: Date.now(),
-                    });
-                }
-            }
-        }
-        if (needsConfig) {
-            this.integration.status = 'NEEDS_CONFIG';
-            await this.integration.save();
-        }
-    }
-
-    async testAuth() {
-        let didAuthPass = true;
-
-        try {
-            await this.primaryInstance.testAuth();
-        } catch {
-            didAuthPass = false;
-            this.integration.messages.errors.push({
-                title: 'Authentication Error',
-                message: `There was an error with your ${this.primaryInstance.constructor.getName()} Entity.
-                Please reconnect/re-authenticate, or reach out to Support for assistance.`,
-                timestamp: Date.now(),
-            });
-        }
-
-        try {
-            await this.targetInstance.testAuth();
-        } catch {
-            didAuthPass = false;
-            this.integration.messages.errors.push({
-                title: 'Authentication Error',
-                message: `There was an error with your ${this.targetInstance.constructor.getName()} Entity.
-            Please reconnect/re-authenticate, or reach out to Support for assistance.`,
-                timestamp: Date.now(),
-            });
-        }
-
-        if (!didAuthPass) {
-            this.integration.status = 'ERROR';
-            this.integration.markModified('messages.error');
-            await this.integration.save();
-        }
-    }
-
-    static async getInstance(params) {
-        const instance = new this(params);
-
-        params.delegate = instance;
-        instance.delegateTypes.push(...this.Config.events);
-        return new this(params);
-    }
-
-    static getIntegrationManagerClasses(type = '') {
-        const normalizedType = type.toLowerCase();
-        const integrationManagerIndex =
-            this.integrationTypes.indexOf(normalizedType);
-        const integrationManagerClass =
-            this.integrationManagerClasses[integrationManagerIndex];
-
-        if (!integrationManagerClass) {
-            throw new Error(
-                `Could not find integration manager for type "${type}"`
-            );
-        }
-
-        return integrationManagerClass;
-    }
-
-    // Takes entities, User, and Config, and returns an Instance of the IntegrationManager
-    static async createIntegration(entities, userId, config) {
-        // verify entity ids belong to the user
-        const entityMO = new Entity();
-
-        for (const id of entities) {
-            const entity = await entityMO.get(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 integrationManagerClass = this.getIntegrationManagerClasses(
-            config.type
-        );
-        const integrationMO = new Integration();
-        const integration = await integrationMO.create({
-            entities: entities,
-            user: userId,
-            config,
-            version: integrationManagerClass.Config.version,
-        });
-
-        const instance = await integrationManagerClass.getInstance({
-            userId,
-            integrationId: integration.id,
-        });
-        instance.integration = integration;
-        instance.delegateTypes.push(...integrationManagerClass.Config.events);
-
-        // Need to get special primaryInstance because it has an extra param to pass in
-        instance.primaryInstance =
-            await this.EntityManagerClass.getEntityManagerInstanceFromEntityId(
-                instance.integration.entities[0],
-                instance.integration.user
-            );
-        // Now we can use the general ManagerGetter
-        instance.targetInstance =
-            await this.EntityManagerClass.getEntityManagerInstanceFromEntityId(
-                instance.integration.entities[1],
-                instance.integration.user
-            );
-
-        instance.delegate = instance;
-
-        return instance;
-    }
-
-    static async getFormattedIntegration(integration) {
-        const entityMO = new Entity();
-        const integrationObj = {
-            id: integration.id,
-            status: integration.status,
-            config: integration.config,
-            entities: [],
-            version: integration.version,
-            messages: integration.messages,
-        };
-        for (const entityId of integration.entities) {
-            // Only return non-internal fields. Leverages "select" and "options" to non-excepted fields and a pure object.
-            const entity = await entityMO.get(
-                entityId,
-                '-dateCreated -dateUpdated -user -credentials -credential -_id -__t -__v',
-                { lean: true }
-            );
-            integrationObj.entities.push({
-                id: entityId,
-                ...entity,
-            });
-        }
-        return integrationObj;
-    }
-
-    static async getIntegrationsForUserId(userId) {
-        const integrationMO = new Integration();
-
-        const integrationList = await integrationMO.list({ user: userId });
-
-        const entityMO = new Entity();
-
-        const responseArray = [];
-        for (const integration of integrationList) {
-            const integrationObj =
-                await IntegrationManager.getFormattedIntegration(integration);
-            responseArray.push(integrationObj);
-        }
-        return responseArray;
-    }
-
-    static async getIntegrationForUserById(userId, integrationId) {
-        const integrationMO = new Integration();
-
-        const integrationList = await integrationMO.list({
-            user: userId,
-            _id: integrationId,
-        });
-
-        return integrationList[0];
-    }
-
-    static async deleteIntegrationForUserById(userId, integrationId) {
-        const integrationMO = new Integration();
-
-        const integrationList = await integrationMO.list({
-            user: userId,
-            _id: integrationId,
-        });
-        if (integrationList.length == 1) {
-            await integrationMO.delete(integrationId);
-        } else {
-            throw new Error(
-                `Integration with id of ${integrationId} does not exist for this user`
-            );
-        }
-    }
-
-    static async getIntegrationById(id) {
-        const integrationMO = new Integration();
-        return await integrationMO.get(id);
-    }
-
-    static async getFilteredIntegrationsForUserId(userId, filter) {
-        const integrationMO = new Integration();
-
-        const integrationList = await integrationMO.list({
-            user: userId,
-            ...filter,
-        });
-
-        return integrationList;
-    }
-
-    static async getCredentialById(credential_id) {
-        const credentialMO = new Credential();
-        return credentialMO.get(credential_id);
-    }
-
-    static async listCredentials(options) {
-        const credentialMO = new Credential();
-        return credentialMO.list(options);
-    }
-
-    static async getEntityById(entity_id) {
-        const entityMO = new Entity();
-        return entityMO.get(entity_id);
-    }
-
-    static async listEntities(options) {
-        const entityMO = new Entity();
-        return entityMO.list(options);
-    }
-
-    static async getInstanceFromIntegrationId(params) {
-        const { integrationId } = params;
-        const integration = await this.getIntegrationById(integrationId);
-        const userId = integration.user;
-
-        const instance = await this.getInstance({ userId, integrationId });
-        instance.integration = integration;
-
-        instance.primaryInstance =
-            await this.EntityManagerClass.getEntityManagerInstanceFromEntityId(
-                instance.integration.entities[0],
-                instance.integration.user
-            );
-
-        instance.targetInstance =
-            await this.EntityManagerClass.getEntityManagerInstanceFromEntityId(
-                instance.integration.entities[1],
-                instance.integration.user
-            );
-
-        return instance;
-    }
-
-    // Children must implement
-    async processCreate() {
-        throw new Error(
-            'processCreate method not implemented in child Manager'
-        );
-    }
-
-    async processDelete() {
-        throw new Error(
-            'processDelete method not implemented in child Manager'
-        );
-    }
-
-    async processUpdate() {
-        throw new Error(
-            'processUpdate method not implemented in child Manager'
-        );
-    }
-
-    async getConfigOptions() {
-        throw new Error(
-            'getConfigOptions method not implemented in child Manager'
-        );
-    }
-
-    async getSampleData() {
-        throw new Error(
-            'getSampleData method not implemented in child Manager'
-        );
-    }
-}
-
-module.exports = IntegrationManager;

package/managers/Migrator.js

@@ -1,190 +0,0 @@
-const Delegate = require('../Delegate');
-const { Integration } = require('@friggframework/models');
-const { get } = require('@friggframework/assertions');
-
-class Migrator extends Delegate {
-    constructor(params) {
-        super(params);
-        this.integrationMO = new Integration();
-        this.options = [];
-    }
-
-    static getInstance() {
-        const instance = new this();
-        return instance;
-    }
-
-    static getName() {
-        return this.integrationManager.getName();
-    }
-
-    async migrate(params) {
-        try {
-            const fromVersion = get(params, 'fromVersion', null);
-            const toVersion = get(params, 'toVersion');
-
-            console.log(
-                'Migrate called. First validating whether it can be done.'
-            );
-            if (
-                !this.integrationManager.Config.supportedVersions.some(
-                    (version) => version === toVersion
-                )
-            ) {
-                return this.throwException(
-                    `Attempting to migrate to an unsupported version. Current supported versions are ${this.integrationManager.Config.supportedVersions.join(
-                        ', '
-                    )}`,
-                    'Migration Error'
-                );
-            }
-            const migrationOption = this.options
-                .map((val) => val.get())
-                .find(
-                    (option) =>
-                        option.fromVersion === fromVersion &&
-                        option.toVersion === toVersion
-                );
-            if (!migrationOption)
-                return this.throwException(
-                    `No migration option found for version ${fromVersion} to ${toVersion}`,
-                    'Migration Error'
-                );
-            // Run all general functions
-            for (const generalFunct of migrationOption.generalFunctions) {
-                console.log('Running general functions first');
-                const res = await generalFunct();
-                console.log(res);
-            }
-            // Get all integration records based on fromVersion
-            const filter = {
-                'config.type': this.integrationManager.getName(),
-            };
-            console.log(
-                `Retrieved all ${this.integrationManager.getName()} integrations`
-            );
-
-            const integrations = await this.integrationMO.list(filter);
-            const filteredIntegrations = integrations.filter((int) => {
-                const isNotToVersion = int.version !== toVersion;
-                let isFromVersion = true;
-                if (fromVersion && fromVersion !== '*') {
-                    isFromVersion = int.version === fromVersion;
-                }
-                return isNotToVersion && isFromVersion;
-            });
-            const results = {
-                integrationType: this.integrationManager.getName(),
-                totalIntegrations: integrations.length,
-                versionReport: {
-                    startVersions: {},
-                    endVersions: {},
-                },
-                statusReport: {
-                    startStatuses: {},
-                    endStatuses: {},
-                },
-                toMigrate: filteredIntegrations.length,
-                migrationResults: {
-                    success: 0,
-                    needsConfig: 0,
-                    error: 0,
-                },
-            };
-
-            for (const integration of integrations) {
-                if (results.versionReport.startVersions[integration.version]) {
-                    results.versionReport.startVersions[
-                        integration.version
-                    ] += 1;
-                } else {
-                    results.versionReport.startVersions[
-                        integration.version
-                    ] = 1;
-                }
-                if (results.statusReport.startStatuses[integration.status]) {
-                    results.statusReport.startStatuses[integration.status] += 1;
-                } else {
-                    results.statusReport.startStatuses[integration.status] = 1;
-                }
-            }
-
-            // Instantiate the integrationManager based on integration ID, run all specific functions for each integration
-            for (const integration of filteredIntegrations) {
-                let integrationManagerInstance;
-                try {
-                    integrationManagerInstance =
-                        await this.integrationManager.getInstanceFromIntegrationId(
-                            {
-                                integrationId: integration.id,
-                                userId: integration.user.id,
-                            }
-                        );
-                } catch (e) {
-                    console.log(e);
-                }
-                // Test Auth
-                if (integrationManagerInstance) {
-                    await integrationManagerInstance.testAuth();
-
-                    // Run functions
-                    if (
-                        integrationManagerInstance.integration.status !==
-                        'ERROR'
-                    ) {
-                        for (const func of migrationOption.perIntegrationFunctions) {
-                            const res = await func(integrationManagerInstance);
-                            console.log(res);
-                        }
-                    }
-
-                    // Validate Config
-                    if (
-                        integrationManagerInstance.integration.status !==
-                        'ERROR'
-                    ) {
-                        await integrationManagerInstance.validateConfig();
-                    }
-
-                    // Add to results tally
-                    const currentStatus =
-                        integrationManagerInstance.integration.status;
-                    if (currentStatus === 'ENABLED') {
-                        integrationManagerInstance.integration.version =
-                            toVersion;
-                        await integrationManagerInstance.integration.save();
-                        results.migrationResults.success += 1;
-                    }
-                    if (currentStatus === 'NEEDS_CONFIG') {
-                        integrationManagerInstance.integration.version =
-                            toVersion;
-                        await integrationManagerInstance.integration.save();
-                        results.migrationResults.needsConfig += 1;
-                    }
-                    if (currentStatus === 'ERROR')
-                        results.migrationResults.error += 1;
-                }
-            }
-
-            const freshRetrieve = await this.integrationMO.list(filter);
-            for (const int of freshRetrieve) {
-                if (results.versionReport.endVersions[int.version]) {
-                    results.versionReport.endVersions[int.version] += 1;
-                } else {
-                    results.versionReport.endVersions[int.version] = 1;
-                }
-                if (results.statusReport.endStatuses[int.status]) {
-                    results.statusReport.endStatuses[int.status] += 1;
-                } else {
-                    results.statusReport.endStatuses[int.status] = 1;
-                }
-            }
-
-            return results;
-        } catch (e) {
-            this.throwException(e.message, 'Migrate Error');
-        }
-    }
-}
-
-module.exports = Migrator;

package/managers/ModuleManager.js

@@ -1,177 +0,0 @@
-const Delegate = require('../Delegate');
-const { Credential, Entity } = require('@friggframework/models');
-const { get } = require('@friggframework/assertions');
-
-class ModuleManager extends Delegate {
-    static Entity = Entity;
-    static Credential = Credential;
-
-    constructor(params) {
-        super(params);
-        this.userId = get(params, 'userId');
-
-        this.entityMO = new this.constructor.Entity();
-        this.credentialMO = new this.constructor.Credential();
-    }
-
-    static getName() {
-        throw new Error('Module name is not defined');
-    }
-
-    static async getInstance(params) {
-        throw new Error(
-            'getInstance is not implemented. It is required for ModuleManager. '
-        );
-    }
-
-    static async getEntitiesForUserId(userId) {
-        const entityMO = new this.Entity();
-        // Only return non-internal fields. Leverages "select" and "options" to non-excepted fields and a pure object.
-        const list = await entityMO.list(
-            { user: userId },
-            '-dateCreated -dateUpdated -user -credentials -credential -__t -__v',
-            { lean: true }
-        );
-        return list.map((entity) => ({
-            id: entity._id,
-            type: this.getName(),
-            ...entity,
-        }));
-    }
-
-    async getEntityId() {
-        const list = await this.entityMO.list({ user: this.userId });
-        if (list.length > 1) {
-            throw new Error(
-                'There should not be more than one entity associated with a user for this specific class type'
-            );
-        }
-        if (list.length == 0) {
-            return null;
-        }
-        return list[0].id;
-    }
-
-    async validateAuthorizationRequirements() {
-        const requirements = await this.getAuthorizationRequirements();
-
-        if (
-            (requirements.type === 'oauth1' ||
-                requirements.type === 'oauth2') &&
-            !requirements.url
-        ) {
-            return false;
-        }
-
-        return true;
-    }
-
-    async getAuthorizationRequirements(params) {
-        // this function must return a dictionary with the following format
-        // node only url key is required. Data would be used for Base Authentication
-        // let returnData = {
-        //     url: "callback url for the data or teh redirect url for login",
-        //     type: one of the types defined in modules/Constants.js
-        //     data: ["required", "fields", "we", "may", "need"]
-        // }
-        throw new Error(
-            'Authorization requirements method getAuthorizationRequirements() is not defined in the class'
-        );
-    }
-
-    async testAuth(params) {
-        // this function must invoke a method on the API using authentication
-        // if it fails, an exception should be thrown
-        throw new Error(
-            'Authentication test method testAuth() is not defined in the class'
-        );
-    }
-
-    async processAuthorizationCallback(params) {
-        // this function takes in a dictionary of callback information along with
-        // a unique user id to associate with the entity in the form of
-        // {
-        //   userId: "some id",
-        //   data: {}
-        // }
-
-        throw new Error(
-            'Authorization requirements method processAuthorizationCallback() is not defined in the class'
-        );
-    }
-
-    //----------------------------------------------------------------------------------------------------
-    // optional
-
-    async getEntityOptions() {
-        // May not be needed if the callback already creates the entity, such as in situations
-        // like HubSpot where the account is determined in the authorization flow.
-        // This should only be used in situations such as FreshBooks where the user needs to make
-        // an account decision on the front end.
-        throw new Error(
-            'Entity requirement method getEntityOptions() is not defined in the class'
-        );
-    }
-
-    async findOrCreateEntity(params) {
-        // May not be needed if the callback already creates the entity, such as in situations
-        // like HubSpot where the account is determined in the authorization flow.
-        // This should only be used in situations such as FreshBooks where the user needs to make
-        // an account decision on the front end.
-        throw new Error(
-            'Entity requirement method findOrCreateEntity() is not defined in the class'
-        );
-    }
-
-    async getAllSyncObjects(SyncClass) {
-        // takes in a Sync class and will return all objects associated with the SyncClass in an array
-        // in the form of
-        // [
-        //      {...object1},{...object2}...
-        // ]
-
-        throw new Error(
-            'The method "getAllSyncObjects()" is not defined in the class'
-        );
-    }
-
-    async batchCreateSyncObjects(syncObjects, syncManager) {
-        // takes in an array of Sync objects that has two pieces of data that
-        // are important to the updating module:
-        // 1. obj.data -> The data mapped to the obj.keys data
-        // 2. obj.syncId -> the id of the newly created sync object in our database. You will need to update
-        //                  the sync object in the database with the your id associated with this data. You
-        //                  can do this by calling the SyncManager function updateSyncObject.
-        // [
-        //      syncObject1,syncObject2, ...
-        // ]
-
-        throw new Error(
-            'The method "batchUpdateSyncObjects()" is not defined in the class'
-        );
-    }
-
-    async batchUpdateSyncObjects(syncObjects, syncManager) {
-        // takes in an array of Sync objects that has two pieces of data that
-        // are important to the updating module:
-        // 1. obj.data -> The data mapped to the obj.keys data
-        // 2. obj.moduleObjectIds[this.constructor.getName()] -> Indexed from the point of view of the module manager
-        //                                                   it will return a json object holding all of the keys
-        //                                                   required update this datapoint. an example would be:
-        //                                                   {companyId:12, email:"test@test.com"}
-        // [
-        //      syncObject1,syncObject2, ...
-        // ]
-
-        throw new Error(
-            'The method "batchUpdateSyncObjects()" is not defined in the class'
-        );
-    }
-
-    async markCredentialsInvalid() {
-        this.credential.auth_is_valid = false;
-        return await this.credential.save();
-    }
-}
-
-module.exports = ModuleManager;