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

package/module-plugin/manager.js

@@ -0,0 +1,169 @@
+const { Delegate } = require('../core');
+const { Credential } = require('./credential');
+const { Entity } = require('./entity');
+const { get } = require('../assertions');
+
+class ModuleManager extends Delegate {
+    static Entity = Entity;
+    static Credential = Credential;
+
+    constructor(params) {
+        super(params);
+        this.userId = get(params, 'userId', null); // Making this non-required
+    }
+
+    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) {
+        // Only return non-internal fields. Leverages "select" and "options" to non-excepted fields and a pure object.
+        const list = await this.Entity.find(
+            { 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 Entity.find({ 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();
+        let valid = true;
+        if (['oauth1', 'oauth2'].includes(requirements.type) && !requirements.url) {
+            valid = false;
+        }
+        return valid;
+    }
+
+    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 };

package/module-plugin/module-factory.js

@@ -0,0 +1,60 @@
+const { Entity } = require("./entity");
+const { Auther } = require('./auther');
+
+class ModuleFactory {
+    constructor(...params) {
+        this.moduleDefinitions = params;
+        this.moduleTypes = this.moduleDefinitions.map(
+            (def) => def.moduleName
+        );
+    }
+
+    async getEntitiesForUser(userId) {
+        let results = [];
+        for (const moduleDefinition of this.moduleDefinitions) {
+            const moduleInstance = await Auther.getInstance({
+                userId,
+                definition: moduleDefinition
+            });
+            const list = await moduleInstance.getEntitiesForUserId(userId);
+            results.push(...list);
+        }
+        return results;
+    }
+
+    checkIsValidType(entityType) {
+        return this.moduleTypes.includes(entityType);
+    }
+
+    getModuleDefinitionFromTypeName(typeName) {
+        return
+    }
+
+
+    async getModuleInstanceFromEntityId(entityId, userId) {
+        const entity = await Entity.findById(entityId);
+        const moduleDefinition = this.moduleDefinitions.find(
+            (def) => entity['__t'] === Auther.getEntityModelFromDefinition(def).modelName
+        )
+        if (!moduleDefinition) {
+            throw new Error('Module definition not found for entity type: ' + entity['__t']);
+        }
+        return await Auther.getInstance({
+            userId,
+            entityId,
+            definition: moduleDefinition
+        });
+    }
+
+     async getInstanceFromTypeName(typeName, userId) {
+        const moduleDefinition =this.moduleDefinitions.find(
+            (def) => def.getName() === typeName
+        );
+         return await Auther.getInstance({
+             userId,
+             definition: moduleDefinition
+         });
+    }
+}
+
+module.exports = { ModuleFactory };

package/module-plugin/requester/api-key.js

@@ -0,0 +1,36 @@
+const { Requester } = require('./requester');
+const { ModuleConstants } = require('../ModuleConstants');
+
+
+class ApiKeyRequester extends Requester {
+
+    static requesterType = ModuleConstants.authType.apiKey;
+
+    constructor(params) {
+        super(params);
+        this.requesterType = 'apiKey';
+        this.API_KEY_NAME = 'key';
+        this.API_KEY_VALUE = null;
+    }
+
+    async addAuthHeaders(headers) {
+        if (this.API_KEY_VALUE) {
+            headers[this.API_KEY_NAME] = this.API_KEY_VALUE;
+        }
+        return headers;
+    }
+
+    isAuthenticated() {
+        return (
+            this.API_KEY_VALUE !== null &&
+            this.API_KEY_VALUE !== undefined &&
+            this.API_KEY_VALUE.trim().length() > 0
+        );
+    }
+
+    setApiKey(api_key) {
+        this.API_KEY_VALUE = api_key;
+    }
+}
+
+module.exports = { ApiKeyRequester };

package/module-plugin/requester/basic.js

@@ -0,0 +1,43 @@
+const { Requester } = require('./requester');
+const { get } = require('../../assertions');
+const { ModuleConstants } = require('../ModuleConstants');
+
+class BasicAuthRequester extends Requester {
+
+    static requesterType = ModuleConstants.authType.basic;
+
+    constructor(params) {
+        super(params);
+
+        this.username = get(params, 'username', null);
+        this.password = get(params, 'password', null);
+    }
+
+    async addAuthHeaders(headers) {
+        if (this.username && this.password) {
+            headers['Authorization'] =
+                'Basic ' +
+                Buffer.from(this.username + ':' + this.password).toString(
+                    'base64'
+                );
+        }
+        return headers;
+    }
+
+    isAuthenticated() {
+        return (
+            this.username !== null &&
+            this.username !== undefined &&
+            this.username.trim().length() > 0
+        );
+    }
+
+    setUsername(username) {
+        this.username = username;
+    }
+    setPassword(password) {
+        this.password = password;
+    }
+}
+
+module.exports = { BasicAuthRequester };

package/module-plugin/requester/oauth-2.js

@@ -0,0 +1,219 @@
+const { Requester } = require('./requester');
+const { get } = require('../../assertions');
+const { ModuleConstants } = require('../ModuleConstants');
+
+class OAuth2Requester extends Requester {
+
+    static requesterType = ModuleConstants.authType.oauth2;
+
+    constructor(params) {
+        super(params);
+        this.DLGT_TOKEN_UPDATE = 'TOKEN_UPDATE';
+        this.DLGT_TOKEN_DEAUTHORIZED = 'TOKEN_DEAUTHORIZED';
+
+        this.delegateTypes.push(this.DLGT_TOKEN_UPDATE);
+        this.delegateTypes.push(this.DLGT_TOKEN_DEAUTHORIZED);
+
+        this.grant_type = get(params, 'grant_type', 'authorization_code');
+        this.client_id = get(params, 'client_id', null);
+        this.client_secret = get(params, 'client_secret', null);
+        this.redirect_uri = get(params, 'redirect_uri', null);
+        this.scope = get(params, 'scope', null);
+        this.authorizationUri = get(params, 'authorizationUri', null);
+        this.baseURL = get(params, 'baseURL', null);
+        this.access_token = get(params, 'access_token', null);
+        this.refresh_token = get(params, 'refresh_token', null);
+        this.accessTokenExpire = get(params, 'accessTokenExpire', null);
+        this.refreshTokenExpire = get(params, 'refreshTokenExpire', null);
+        this.audience = get(params, 'audience', null);
+        this.username = get(params, 'username', null);
+        this.password = get(params, 'password', null);
+        this.state = get(params, 'state', null);
+
+        this.isRefreshable = true;
+    }
+
+    async setTokens(params) {
+        this.access_token = get(params, 'access_token');
+        this.refresh_token = get(params, 'refresh_token', null);
+        const accessExpiresIn = get(params, 'expires_in', null);
+        const refreshExpiresIn = get(
+            params,
+            'x_refresh_token_expires_in',
+            null
+        );
+
+        this.accessTokenExpire = new Date(Date.now() + accessExpiresIn * 1000);
+        this.refreshTokenExpire = new Date(Date.now() + refreshExpiresIn * 1000);
+
+        await this.notify(this.DLGT_TOKEN_UPDATE);
+    }
+
+    getAuthorizationUri() {
+        return this.authorizationUri;
+    }
+
+    getAuthorizationRequirements() {
+        return {
+            url: this.getAuthorizationUri(),
+            type: 'oauth2',
+        };
+    }
+
+    // this.client_id, this.client_secret, this.redirect_uri, and this.tokenUri
+    // will need to be defined in the child class before super(params)
+    async getTokenFromCode(code) {
+        const params = new URLSearchParams();
+        params.append('grant_type', 'authorization_code');
+        params.append('client_id', this.client_id);
+        params.append('client_secret', this.client_secret);
+        params.append('redirect_uri', this.redirect_uri);
+        params.append('scope', this.scope);
+        params.append('code', code);
+        const options = {
+            body: params,
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            url: this.tokenUri,
+        };
+        const response = await this._post(options, false);
+        await this.setTokens(response);
+        return response;
+    }
+
+    // REPLACE getTokenFromCode IN THE CHILD IF NEEDED
+    // this.client_id, this.client_secret, this.redirect_uri, and this.tokenUri
+    // will need to be defined in the child class before super(params)
+    async getTokenFromCodeBasicAuthHeader(code) {
+        const params = new URLSearchParams();
+        params.append('grant_type', 'authorization_code');
+        params.append('client_id', this.client_id);
+        params.append('redirect_uri', this.redirect_uri);
+        params.append('code', code);
+
+        const options = {
+            body: params,
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Authorization: `Basic ${Buffer.from(
+                    `${this.client_id}:${this.client_secret}`
+                ).toString('base64')}`,
+            },
+            url: this.tokenUri,
+        };
+
+        const response = await this._post(options, false);
+        await this.setTokens(response);
+        return response;
+    }
+
+    // this.client_id, this.client_secret, this.redirect_uri, and this.tokenUri
+    // will need to be defined in the child class before super(params)
+    async refreshAccessToken(refreshTokenObject) {
+        this.access_token = undefined;
+        const params = new URLSearchParams();
+        params.append('grant_type', 'refresh_token');
+        params.append('client_id', this.client_id);
+        params.append('client_secret', this.client_secret);
+        params.append('refresh_token', refreshTokenObject.refresh_token);
+        params.append('redirect_uri', this.redirect_uri);
+
+        const options = {
+            body: params,
+            url: this.tokenUri,
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+        };
+        const response = await this._post(options, false);
+        await this.setTokens(response);
+        return response;
+    }
+
+    async addAuthHeaders(headers) {
+        if (this.access_token) {
+            headers.Authorization = `Bearer ${this.access_token}`;
+        }
+
+        return headers;
+    }
+
+    isAuthenticated() {
+        return (
+            this.accessToken !== null &&
+            this.refreshToken !== null &&
+            this.accessTokenExpire &&
+            this.refreshTokenExpire
+        );
+    }
+
+    async refreshAuth() {
+        try {
+            if (this.grantType !== 'client_credentials') {
+                await this.refreshAccessToken({
+                    refresh_token: this.refresh_token,
+                });
+            } else {
+                await this.getTokenFromClientCredentials();
+            }
+        } catch {
+            await this.notify(this.DLGT_INVALID_AUTH);
+        }
+    }
+
+    async getTokenFromUsernamePassword() {
+        try {
+            const url = this.tokenUri;
+
+            const body = {
+                username: this.username,
+                password: this.password,
+                grant_type: 'password',
+            };
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+
+            const tokenRes = await this._post({
+                url,
+                body,
+                headers,
+            });
+
+            await this.setTokens(tokenRes);
+            return tokenRes;
+        } catch {
+            await this.notify(this.DLGT_INVALID_AUTH);
+        }
+    }
+
+    async getTokenFromClientCredentials() {
+        try {
+            const url = this.tokenUri;
+
+            const body = {
+                audience: this.audience,
+                client_id: this.client_id,
+                client_secret: this.client_secret,
+                grant_type: 'client_credentials',
+            };
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+
+            const tokenRes = await this._post({
+                url,
+                body,
+                headers,
+            });
+
+            await this.setTokens(tokenRes);
+            return tokenRes;
+        } catch {
+            await this.notify(this.DLGT_INVALID_AUTH);
+        }
+    }
+}
+
+module.exports = { OAuth2Requester };

package/module-plugin/requester/requester.js

@@ -0,0 +1,150 @@
+const fetch = require('node-fetch');
+const { Delegate } = require('../../core');
+const { FetchError } = require('../../errors');
+const { get } = require('../../assertions');
+
+class Requester extends Delegate {
+    constructor(params) {
+        super(params);
+        this.backOff = get(params, 'backOff', [1, 3, 10, 30, 60, 180]);
+        this.isRefreshable = false;
+        this.refreshCount = 0;
+        this.DLGT_INVALID_AUTH = 'INVALID_AUTH';
+        this.delegateTypes.push(this.DLGT_INVALID_AUTH);
+        this.agent = get(params, 'agent', null);
+
+        // Allow passing in the fetch function
+        // Instance methods can use this.fetch without differentiating
+        this.fetch = get(params, 'fetch', fetch);
+    }
+
+    parsedBody = async (resp) => {
+        const contentType = resp.headers.get('Content-Type') || '';
+
+        if (
+            contentType.match(/^application\/json/) ||
+            contentType.match(/^application\/vnd.api\+json/)
+        ) {
+            return resp.json();
+        }
+
+        return resp.text();
+    };
+
+    async _request(url, options, i = 0) {
+        let encodedUrl = encodeURI(url);
+        if (options.query) {
+            let queryBuild = '?';
+            for (const key in options.query) {
+                queryBuild += `${encodeURIComponent(key)}=${encodeURIComponent(
+                    options.query[key]
+                )}&`;
+            }
+            encodedUrl += queryBuild.slice(0, -1);
+        }
+
+        options.headers = await this.addAuthHeaders(options.headers);
+
+        if (this.agent) options.agent = this.agent;
+
+        const response = await this.fetch(encodedUrl, options);
+        const { status } = response;
+
+        // If the status is retriable and there are back off requests left, retry the request
+        if ((status === 429 || status >= 500) && i < this.backOff.length) {
+            const delay = this.backOff[i] * 1000;
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            return this._request(url, options, i + 1);
+        } else if (status === 401) {
+            if (!this.isRefreshable || this.refreshCount > 0) {
+                await this.notify(this.DLGT_INVALID_AUTH);
+            } else {
+                this.refreshCount++;
+                await this.refreshAuth();
+                return this._request(url, options, i + 1); // Retries
+            }
+        }
+
+        // If the error wasn't retried, throw.
+        if (status >= 400) {
+            throw await FetchError.create({
+                resource: encodedUrl,
+                init: options,
+                response,
+            });
+        }
+
+        return options.returnFullRes
+            ? response
+            : await this.parsedBody(response);
+    }
+
+    async _get(options) {
+        const fetchOptions = {
+            method: 'GET',
+            credentials: 'include',
+            headers: options.headers || {},
+            query: options.query || {},
+            returnFullRes: options.returnFullRes || false,
+        };
+
+        const res = await this._request(options.url, fetchOptions);
+        return res;
+    }
+
+    async _post(options, stringify = true) {
+        const fetchOptions = {
+            method: 'POST',
+            credentials: 'include',
+            headers: options.headers || {},
+            query: options.query || {},
+            body: stringify ? JSON.stringify(options.body) : options.body,
+            returnFullRes: options.returnFullRes || false,
+        };
+        const res = await this._request(options.url, fetchOptions);
+        return res;
+    }
+
+    async _patch(options, stringify = true) {
+        const fetchOptions = {
+            method: 'PATCH',
+            credentials: 'include',
+            headers: options.headers || {},
+            query: options.query || {},
+            body: stringify ? JSON.stringify(options.body) : options.body,
+            returnFullRes: options.returnFullRes || false,
+        };
+        const res = await this._request(options.url, fetchOptions);
+        return res;
+    }
+
+    async _put(options, stringify = true) {
+        const fetchOptions = {
+            method: 'PUT',
+            credentials: 'include',
+            headers: options.headers || {},
+            query: options.query || {},
+            body: stringify ? JSON.stringify(options.body) : options.body,
+            returnFullRes: options.returnFullRes || false,
+        };
+        const res = await this._request(options.url, fetchOptions);
+        return res;
+    }
+
+    async _delete(options) {
+        const fetchOptions = {
+            method: 'DELETE',
+            credentials: 'include',
+            headers: options.headers || {},
+            query: options.query || {},
+            returnFullRes: options.returnFullRes || true,
+        };
+        return this._request(options.url, fetchOptions);
+    }
+
+    async refreshAuth() {
+        throw new Error('refreshAuth not yet defined in child of Requester');
+    }
+}
+
+module.exports = { Requester };