@friggframework/core 0.2.31-v1-alpha-package-update.0 → 1.0.1-canary.278.7b20420.0

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,151 @@
+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;
+
+        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 };

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

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

@@ -0,0 +1,97 @@
+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/module-plugin/test/mock-api/api.js

@@ -0,0 +1,29 @@
+const { get } = require('../../assertions');
+const { OAuth2Requester } = require('../../module-plugin');
+
+class Api extends OAuth2Requester {
+    constructor(params) {
+        super(params);
+        this.baseUrl = 'https://api.anapi.com';
+
+        this.URLs = {
+            authorization: '/oauth/authorize',
+            access_token: '/oauth/v1/token',
+        };
+
+        this.authorizationUri = encodeURI(
+            `https://app.anapi.com/oauth/authorize?client_id=${this.client_id}&redirect_uri=${this.redirect_uri}&scope=${this.scope}&state=${this.state}`
+        );
+        this.tokenUri = 'https://api.anapi.com/oauth/v1/token';
+
+        this.access_token = get(params, 'access_token', null);
+        this.refresh_token = get(params, 'refresh_token', null);
+    }
+    getAuthUri() {
+        return this.authorizationUri;
+    }
+
+
+}
+
+module.exports = { Api };

package/module-plugin/test/mock-api/definition.js

@@ -0,0 +1,48 @@
+require('dotenv').config();
+const {Api} = require('./api');
+const {get} = require('../../assertions');
+const config = {name: 'anapi'}
+
+const Definition = {
+    API: Api,
+    getName: function() {return config.name},
+    moduleName: config.name,
+    modelName: 'AnApi',
+    requiredAuthMethods: {
+        getToken: async function(api, params){
+            const code = get(params.data, 'code');
+            return api.getTokenFromCode(code);
+        },
+        getEntityDetails: async function(api, callbackParams, tokenResponse, userId) {
+            const userDetails = await api.getUserDetails();
+            return {
+                identifiers: { externalId: userDetails.portalId, user: userId },
+                details: { name: userDetails.hub_domain },
+            }
+        },
+        apiPropertiesToPersist: {
+            credential: [
+                'access_token', 'refresh_token'
+            ],
+            entity: [],
+        },
+        getCredentialDetails: async function(api, userId) {
+            const userDetails = await api.getUserDetails();
+            return {
+                identifiers: { externalId: userDetails.portalId, user: userId },
+                details: {}
+            };
+        },
+        testAuthRequest: async function(api){
+            return api.getUserDetails()
+        },
+    },
+    env: {
+        client_id: 'test',
+        client_secret: 'test',
+        scope: 'test',
+        redirect_uri: `http://localhost:3000/redirect/anapi`,
+    }
+};
+
+module.exports = { Definition };

package/module-plugin/test/mock-api/mocks/hubspot.js

@@ -0,0 +1,43 @@
+const authorizeResponse = {
+    "base": "/redirect/hubspot",
+    "data": {
+        "code": "test-code",
+        "state": "null"
+    }
+}
+
+const tokenResponse = {
+    "token_type": "bearer",
+    "refresh_token": "test-refresh-token",
+    "access_token": "test-access-token",
+    "expires_in": 1800
+}
+
+const userDetailsResponse = {
+    "portalId": 111111111,
+    "timeZone": "US/Eastern",
+    "accountType": "DEVELOPER_TEST",
+    "currency": "USD",
+    "utcOffset": "-05:00",
+    "utcOffsetMilliseconds": -18000000,
+    "token": "test-token",
+    "user": "projectteam@lefthook.co",
+    "hub_domain": "Testing Object Things-dev-44613847.com",
+    "scopes": [
+        "content",
+        "oauth",
+        "crm.objects.contacts.read",
+        "crm.objects.contacts.write",
+        "crm.objects.companies.write",
+        "crm.objects.companies.read",
+        "crm.objects.deals.read",
+        "crm.schemas.deals.read"
+    ],
+    "hub_id": 111111111,
+    "app_id": 22222222,
+    "expires_in": 1704,
+    "user_id": 33333333,
+    "token_type": "access"
+}
+
+module.exports = { authorizeResponse, tokenResponse, userDetailsResponse }

package/package.json

@@ -1,12 +1,35 @@
 {
   "name": "@friggframework/core",
   "prettier": "@friggframework/prettier-config",
-  "version": "0.2.31-v1-alpha-package-update.0",
+  "version": "1.0.1-canary.278.7b20420.0",
+  "dependencies": {
+    "@hapi/boom": "^10.0.1",
+    "aws-sdk": "^2.1200.0",
+    "bcryptjs": "^2.4.3",
+    "common-tags": "^1.8.2",
+    "express": "^4.18.2",
+    "express-async-handler": "^1.2.0",
+    "lodash": "^4.17.21",
+    "lodash.get": "^4.4.2",
+    "mongoose": "6.11.6",
+    "node-fetch": "^2.6.7"
+  },
   "devDependencies": {
-    "@friggframework/eslint-config": "^1.0.20",
-    "eslint": "^8.22.0",
+    "@friggframework/devtools": "1.0.1-canary.278.7b20420.0",
+    "@types/lodash": "^4.14.191",
+    "@typescript-eslint/eslint-plugin": "^5.55.0",
+    "chai": "^4.3.6",
+    "eslint": "^8.36.0",
+    "eslint-config-standard-with-typescript": "^34.0.1",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-n": "^15.6.1",
+    "eslint-plugin-promise": "^6.1.1",
     "jest": "^28.1.3",
-    "prettier": "^2.7.1"
+    "jest-runner-groups": "^2.2.0",
+    "mongodb-memory-server": "^8.9.0",
+    "prettier": "^2.8.5",
+    "sinon": "^14.0.0",
+    "typescript": "^5.0.2"
   },
   "scripts": {
     "lint:fix": "prettier --write --loglevel error . && eslint . --fix",
@@ -23,13 +46,6 @@
     "url": "https://github.com/friggframework/frigg/issues"
   },
   "homepage": "https://github.com/friggframework/frigg#readme",
-  "dependencies": {
-    "@friggframework/assertions": "^1.0.21",
-    "@friggframework/errors": "^1.1.18",
-    "aws-sdk": "^2.1200.0",
-    "lodash": "^4.17.21",
-    "node-fetch": "^2.6.7"
-  },
   "description": "",
-  "gitHead": "24670c56c21bed2ce5670f83b4443c6d910dd24f"
+  "gitHead": "7b20420ab945a52ffaf7d8caaf4c45d97a10204c"
 }

package/syncs/README.md

@@ -0,0 +1,3 @@
+# syncs
+
+This package exports the `syncs` classes, models, and functions used in [Frigg](https://friggframework.org). You can find its documentation [on Frigg's website](https://docs.friggframework.org/packages/syncs).

package/syncs/jest.config.js

@@ -0,0 +1,5 @@
+module.exports = async () => {
+  return {
+    preset: "@friggframework/test-environment",
+  };
+};