@friggframework/core 2.0.0-next.12 → 2.0.0-next.120

package/module-plugin/module-factory.js

@@ -1,61 +0,0 @@
-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.toJSON()['__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

@@ -1,36 +0,0 @@
-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/oauth-2.js

@@ -1,219 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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/) ||
-            contentType.match(/^application\/hal\+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;
-
-        let response;
-        try {
-            response = await this.fetch(encodedUrl, options);
-        } catch (e) {
-            if (e.code === 'ECONNRESET' && i < this.backOff.length) {
-                const delay = this.backOff[i] * 1000;
-                await new Promise((resolve) => setTimeout(resolve, delay));
-                return this._request(url, options, i + 1);
-            }
-            throw await FetchError.create({
-                resource: encodedUrl,
-                init: options,
-                responseBody: e,
-            });
-        }
-        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 };

package/module-plugin/requester/requester.test.js

@@ -1,28 +0,0 @@
-const { Requester } = require('./requester');
-
-describe('429 and 5xx testing', () => {
-    let backOffArray = [1, 1, 1];
-    let requester = new Requester({ backOff: backOffArray });
-    let sum = backOffArray.reduce((a, b) => {
-        return a + b;
-    }, 0);
-    it.skip("should retry with 'exponential' back off due to 429", async () => {
-        let startTime = await Date.now();
-        let res = await requester._get({
-            url: 'https://70e18ff0-1967-4fb5-8f96-10477ab6bb9e.mock.pstmn.io//429',
-        });
-        let endTime = await Date.now();
-        let difference = endTime - startTime;
-        expect(difference).toBeGreaterThan(sum * 1000);
-    });
-
-    it.skip("should retry with 'exponential' back off due to 500", async () => {
-        let startTime = await Date.now();
-        let res = await requester._get({
-            url: 'https://70e18ff0-1967-4fb5-8f96-10477ab6bb9e.mock.pstmn.io//5xx',
-        });
-        let endTime = await Date.now();
-        let difference = endTime - startTime;
-        expect(difference).toBeGreaterThan(sum * 1000);
-    });
-});

package/module-plugin/test/auther.test.js

@@ -1,97 +0,0 @@
-const {Api} = require('./mock-api/api');
-const hubspotMocks = require('./mock-api/mocks/hubspot');
-
-const { Definition } = require('./mock-api/definition');
-const { Auther } = require('../auther');
-const { mongoose } = require('../../database/mongoose');
-
-
-
-const getModule = async (params) => {
-    const module = await Auther.getInstance({
-        definition: Definition,
-        userId: new mongoose.Types.ObjectId(),
-        ...params,
-    });
-    module.api.getTokenFromCode = async function(code) {
-        await this.setTokens(hubspotMocks.tokenResponse);
-        return hubspotMocks.tokenResponse;
-    }
-    module.api.getUserDetails = async function() {
-        return hubspotMocks.userDetailsResponse;
-    }
-    return module
-}
-
-
-describe('HubSpot Module Tests', () => {
-    let module, authUrl;
-    beforeAll(async () => {
-        await mongoose.connect(process.env.MONGO_URI);
-        module = await getModule();
-    });
-
-    afterAll(async () => {
-        await mongoose.disconnect();
-    });
-
-    describe('getAuthorizationRequirements() test', () => {
-        it('should return auth requirements', async () => {
-            const requirements = module.getAuthorizationRequirements();
-            expect(requirements).toBeDefined();
-            expect(requirements.type).toEqual('oauth2');
-            expect(requirements.url).toBeDefined();
-            authUrl = requirements.url;
-        });
-    });
-
-    describe('Authorization requests', () => {
-        let firstRes;
-        it('processAuthorizationCallback()', async () => {
-            const response = hubspotMocks.authorizeResponse;
-            firstRes = await module.processAuthorizationCallback({
-                data: {
-                    code: response.data.code,
-                },
-            });
-            expect(firstRes).toBeDefined();
-            expect(firstRes.entity_id).toBeDefined();
-            expect(firstRes.credential_id).toBeDefined();
-        });
-        it('retrieves existing entity on subsequent calls', async () =>{
-            const response = hubspotMocks.authorizeResponse;
-            const res = await module.processAuthorizationCallback({
-                data: {
-                    code: response.data.code,
-                },
-            });
-            expect(res).toEqual(firstRes);
-        });
-    });
-    describe('Test credential retrieval and module instantiation', () => {
-        it('retrieve by entity id', async () => {
-            const newModule = await getModule({
-                userId: module.userId,
-                entityId: module.entity.id,
-                definition: Definition,
-            });
-            expect(newModule).toBeDefined();
-            expect(newModule.entity).toBeDefined();
-            expect(newModule.credential).toBeDefined();
-            expect(await newModule.testAuth()).toBeTruthy();
-
-        });
-
-        it('retrieve by credential id', async () => {
-            const newModule = await getModule({
-                userId: module.userId,
-                credentialId: module.credential.id,
-                definition: Definition,
-            });
-            expect(newModule).toBeDefined();
-            expect(newModule.credential).toBeDefined();
-            expect(await newModule.testAuth()).toBeTruthy();
-
-        });
-    });
-});

package/syncs/model.js

@@ -1,62 +0,0 @@
-const mongoose = require("mongoose");
-
-const schema = new mongoose.Schema({
-  entities: [
-    { type: mongoose.Schema.Types.ObjectId, ref: "Entity", required: true },
-  ],
-  hash: { type: String, required: true },
-  name: { type: String, required: true },
-  dataIdentifiers: [
-    {
-      entity: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Entity",
-        required: true,
-      },
-      id: { type: Object, required: true },
-      hash: { type: String, required: true },
-    },
-  ],
-});
-
-schema.statics({
-  getSyncObject: async function (name, dataIdentifier, entity) {
-    // const syncList = await this.list({name:name,entities: {"$in": entities}, "entityIds.idHash":entityIdHash });
-    const syncList = await this.find({
-      name: name,
-      dataIdentifiers: { $elemMatch: { id: dataIdentifier, entity } },
-    });
-
-    if (syncList.length === 1) {
-      return syncList[0];
-    } else if (syncList.length === 0) {
-      return null;
-    } else {
-      throw new Error(
-        `There are multiple sync objects with the name ${name}, for entities [${syncList[0].entities}] [${syncList[1].entities}]`
-      );
-    }
-  },
-
-  addDataIdentifier: async function (id, dataIdentifier) {
-    return await this.update(
-      { _id: id },
-      {},
-      { dataIdentifiers: dataIdentifier }
-    );
-  },
-
-  getEntityObjIdForEntityIdFromObject: function (syncObj, entityId) {
-    for (let dataIdentifier of syncObj.dataIdentifiers) {
-      if (dataIdentifier.entity.toString() === entityId) {
-        return dataIdentifier.id;
-      }
-    }
-    throw new Error(
-      `Sync object does not have DataIdentifier for entityId: ${entityId}`
-    );
-  },
-});
-
-const Sync = mongoose.models.Sync || mongoose.model("Sync", schema);
-module.exports = { Sync };