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

package/integrations/integration-user.js

@@ -0,0 +1,144 @@
+const bcrypt = require('bcryptjs');
+const crypto = require('crypto');
+const { get } = require('../assertions');
+const { Token } = require('../database/models/Token');
+const { IndividualUser } = require('../database/models/IndividualUser');
+const { OrganizationUser } = require('../database/models/OrganizationUser');
+const Boom = require('@hapi/boom');
+
+class User {
+    static IndividualUser = IndividualUser;
+    static OrganizationUser = OrganizationUser;
+    static Token = Token;
+    static usePassword = false
+    static primary = User.IndividualUser;
+    static individualUserRequired = true;
+    static organizationUserRequired = false;
+
+    constructor() {
+        this.user = null;
+        this.individualUser = null;
+        this.organizationUser = null;
+    }
+
+    getPrimaryUser() {
+        if (User.primary === User.OrganizationUser) {
+            return this.organizationUser;
+        }
+        return this.individualUser;
+    }
+
+    getUserId() {
+        return this.getPrimaryUser()?.id;
+    }
+
+    isLoggedIn() {
+        return Boolean(this.getUserId());
+    }
+
+    async createUserToken(minutes) {
+        const rawToken = crypto.randomBytes(20).toString('hex');
+        const createdToken = await User.Token.createTokenWithExpire(this.getUserId(), rawToken, 120);
+        const tokenBuf = User.Token.createBase64BufferToken(createdToken, rawToken);
+        return tokenBuf;
+    }
+
+    static async newUser(params={}) {
+        const user = new User();
+        const token = get(params, 'token', null);
+        if (token) {
+            const jsonToken = this.Token.getJSONTokenFromBase64BufferToken(token);
+            const sessionToken = await this.Token.validateAndGetTokenFromJSONToken(jsonToken);
+            if (this.primary === User.OrganizationUser) {
+                user.organizationUser = await this.OrganizationUser.findById(sessionToken.user);
+            } else {
+                user.individualUser = await this.IndividualUser.findById(sessionToken.user);
+            }
+        }
+        return user;
+    }
+
+    static async createIndividualUser(params) {
+        const user = await this.newUser(params);
+        let hashword;
+        if (this.usePassword) {
+            hashword = get(params, 'password');
+        }
+
+        const email = get(params, 'email', null);
+        const username = get(params, 'username', null);
+        if (!email && !username) {
+            throw Boom.badRequest('email or username is required');
+        }
+
+        const appUserId = get(params, 'appUserId', null);
+        const organizationUserId = get(params, 'organizationUserId', null);
+
+        user.individualUser = await this.IndividualUser.create({
+            email,
+            username,
+            hashword,
+            appUserId,
+            organizationUser: organizationUserId,
+        });
+        return user;
+    }
+
+    static async createOrganizationUser(params) {
+        const user = await this.newUser(params);
+        const name = get(params, 'name');
+        const appOrgId = get(params, 'appOrgId');
+        user.organizationUser = await this.OrganizationUser.create({
+            name,
+            appOrgId,
+        });
+        return user;
+    }
+
+    static async loginUser(params) {
+        const user = await this.newUser(params);
+
+        if (this.usePassword){
+            const username = get(params, 'username');
+            const password = get(params, 'password');
+
+            const individualUser = await this.IndividualUser.findOne({username});
+
+            if (!individualUser) {
+                throw Boom.unauthorized('incorrect username or password');
+            }
+
+            const isValid = await bcrypt.compareSync(password, individualUser.hashword);
+            if (!isValid) {
+                throw Boom.unauthorized('incorrect username or password');
+            }
+            user.individualUser = individualUser;
+        }
+        else {
+            const appUserId = get(params, 'appUserId', null);
+            user.individualUser = await this.IndividualUser.getUserByAppUserId(
+                appUserId
+            );
+        }
+
+        const appOrgId = get(params, 'appOrgId', null);
+        user.organizationUser = await this.OrganizationUser.getUserByAppOrgId(
+            appOrgId
+        );
+
+        if (this.individualUserRequired) {
+            if (!user.individualUser) {
+                throw Boom.unauthorized('user not found');
+            }
+        }
+
+        if (this.organizationUserRequired) {
+            if (!user.organizationUser) {
+                throw Boom.unauthorized(`org user ${appOrgId} not found`);
+            }
+        }
+        return user;
+    }
+}
+
+module.exports = User;

package/integrations/jest-setup.js

@@ -0,0 +1,2 @@
+const { globalSetup } = require('../test-environment');
+module.exports = globalSetup;

package/integrations/jest-teardown.js

@@ -0,0 +1,2 @@
+const { globalTeardown } = require('../test-environment');
+module.exports = globalTeardown;

package/integrations/jest.config.js

@@ -0,0 +1,12 @@
+/*
+ * For a detailed explanation regarding each configuration property, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+module.exports = {
+    // A path to a module which exports an async function that is triggered once before all test suites
+    globalSetup: './jest-setup.js',
+
+    // A path to a module which exports an async function that is triggered once after all test suites
+    globalTeardown: './jest-teardown.js',
+};

package/integrations/options.js

@@ -0,0 +1,54 @@
+const { RequiredPropertyError } = require('../errors');
+const { get, getAndVerifyType } = require('../assertions');
+const { ModuleManager } = require('../module-plugin');
+
+class Options {
+    constructor(params) {
+        this.module = get(params, 'module');
+        this.isMany = Boolean(get(params, 'isMany', false));
+        this.hasUserConfig = Boolean(get(params, 'hasUserConfig', false));
+        this.requiresNewEntity = Boolean(
+            get(params, 'requiresNewEntity', false)
+        );
+        if (!params.display) {
+            throw new RequiredPropertyError({
+                parent: this,
+                key: 'display',
+            });
+        }
+
+        this.display = {};
+        this.display.name = get(params.display, 'name');
+        this.display.description = get(params.display, 'description');
+        this.display.detailsUrl = get(params.display, 'detailsUrl');
+        this.display.icon = get(params.display, 'icon');
+    }
+
+    get() {
+        return {
+            type: this.module.getName(),
+
+            // Flag for if the User can configure any settings
+            hasUserConfig: this.hasUserConfig,
+
+            // if this integration can be used multiple times with the same integration pair. For example I want to
+            // connect two different Etsy shops to the same Freshbooks account.
+            isMany: this.isMany,
+
+            // if this is true it means we need to create a new entity for every integration pair and not use an
+            // existing one. This would be true for scenarios where the client wishes to have individual control over
+            // the integerations it has connected to its app. They would want this to let their users only delete
+            // single integrations without notifying our server.
+            requiresNewEntity: this.requiresNewEntity,
+
+            // this is information required for the display side of things on the front end
+            display: this.display,
+
+            // this is information for post-authentication config, using jsonSchema and uiSchema for display on the frontend
+            // Maybe include but probably not, I like making someone make a follow-on request
+            // configOptions: this.configOptions,
+        };
+    }
+}
+
+module.exports = { Options };

package/integrations/test/integration-base.test.js

@@ -0,0 +1,143 @@
+const _ = require('lodash');
+const { mongoose } = require('../../database/mongoose');
+const { expect } = require('chai');
+const { IntegrationBase } = require("../integration-base");
+const {Credential, Entity} = require('../../module-plugin');
+const { IntegrationMapping } = require('../integration-mapping')
+const {IntegrationModel} = require("../integration-model");
+
+describe(`Should fully test the IntegrationBase Class`, () => {
+    let integrationRecord;
+    let userId;
+    const integration = new IntegrationBase;
+
+    beforeAll(async () => {
+        await mongoose.connect(process.env.MONGO_URI);
+        userId = new mongoose.Types.ObjectId();
+        const credential = await Credential.findOneAndUpdate(
+            {
+                user: this.userId,
+            },
+            { $set: { user: this.userId } },
+            {
+                new: true,
+                upsert: true,
+                setDefaultsOnInsert: true,
+            }
+        );
+        const entity1 = await Entity.findOneAndUpdate(
+            {
+                user: this.userId,
+            },
+            {
+                $set: {
+                    credential: credential.id,
+                    user: userId,
+                },
+            },
+            {
+                new: true,
+                upsert: true,
+                setDefaultsOnInsert: true,
+            }
+        );
+        const entity2 = await Entity.findOneAndUpdate(
+            {
+                user: userId,
+            },
+            {
+                $set: {
+                    credential: credential.id,
+                    user: userId,
+                },
+            },
+            {
+                new: true,
+                upsert: true,
+                setDefaultsOnInsert: true,
+            }
+        );
+        integrationRecord = await IntegrationModel.create({
+            entities: [entity1, entity2],
+            user: userId
+        });
+        integration.record = integrationRecord;
+    });
+
+    afterAll(async () => {
+        await Entity.deleteMany();
+        await Credential.deleteMany();
+        await IntegrationMapping.deleteMany();
+        await IntegrationModel.deleteMany();
+        await mongoose.disconnect();
+    });
+
+    beforeEach(() => {
+        integration.record = integrationRecord;
+    })
+
+    describe('getIntegrationMapping()', () => {
+        it('should return null if not found', async () => {
+            const mappings = await integration.getMapping('badId');
+            expect(mappings).to.be.null;
+        });
+
+        it('should return if valid ids', async () => {
+            await integration.upsertMapping('validId', {});
+            const mapping = await integration.getMapping('validId');
+            expect(mapping).to.eql({})
+        });
+    })
+
+    describe('upsertIntegrationMapping()', () => {
+        it('should throw error if sourceId is null', async () => {
+            try {
+                await integration.upsertMapping( null, {});
+                fail('should have thrown error')
+            } catch(err) {
+                expect(err.message).to.contain('sourceId must be set');
+            }
+        });
+
+        it('should return for empty mapping', async () => {
+            const mapping = await integration.upsertMapping( 'validId2', {});
+            expect(_.pick(mapping, ['integration', 'sourceId', 'mapping'])).to.eql({
+                integration: integrationRecord._id,
+                sourceId: 'validId2',
+                mapping: {}
+            })
+        });
+
+        it('should return for filled mapping', async () => {
+            const mapping = await integration.upsertMapping('validId3', {
+                name: 'someName',
+                value: 5
+            });
+            expect(_.pick(mapping, ['integration', 'sourceId', 'mapping'])).to.eql({
+                integration: integrationRecord._id,
+                sourceId: 'validId3',
+                mapping: {
+                    name: 'someName',
+                    value: 5
+                }
+            })
+        });
+
+        it('should allow upserting to same id', async () => {
+            await integration.upsertMapping('validId4', {});
+            const mapping = await integration.upsertMapping('validId4', {
+                name: 'trustMe',
+                thisWorks: true,
+            });
+            expect(_.pick(mapping, ['integration', 'sourceId', 'mapping'])).to.eql({
+                integration: integrationRecord._id,
+                sourceId: 'validId4',
+                mapping: {
+                    name: 'trustMe',
+                    thisWorks: true,
+                }
+            })
+        });
+    })
+
+});

package/lambda/README.md

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

package/lambda/TimeoutCatcher.js

@@ -0,0 +1,43 @@
+const isPositive = (n) => Number.isFinite(n) && n > 0;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+class TimeoutCatcher {
+  constructor({ work, timeout, cleanUp = () => {}, cleanUpTime = 2_000 }) {
+    this.isFinished = false;
+    this.work = work;
+    this.cleanUp = cleanUp;
+    this.waitTime = timeout - cleanUpTime;
+
+    if (!isPositive(this.waitTime))
+      throw new Error("Wait time was not a positive number of milliseconds");
+  }
+
+  async watch() {
+    try {
+      await Promise.race([this.doWork(), this.exitBeforeTimeout()]);
+      return true;
+    } catch (error) {
+      if (error.isSentinelTimeout) return false;
+      throw error;
+    }
+  }
+
+  async doWork() {
+    await this.work();
+    this.isFinished = true;
+  }
+
+  async exitBeforeTimeout() {
+    await sleep(this.waitTime);
+
+    if (!this.isFinished) {
+      await this.cleanUp();
+
+      const error = new Error("Sentinel Timed Out");
+      error.isSentinelTimeout = true;
+      throw error;
+    }
+  }
+}
+
+module.exports = { TimeoutCatcher };

package/lambda/TimeoutCatcher.test.js

@@ -0,0 +1,68 @@
+const { TimeoutCatcher } = require("./TimeoutCatcher");
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+describe("Time Sentinel", () => {
+  it("requires a positive wait time", () => {
+    try {
+      new TimeoutCatcher({
+        timeout: 1_000,
+      });
+      throw new Error("Expected error was not thrown");
+    } catch (error) {
+      expect(error).toHaveProperty(
+        "message",
+        "Wait time was not a positive number of milliseconds"
+      );
+    }
+  });
+
+  it("exits normally if the work is completed", async () => {
+    let cleanUpCalled = false;
+    const sentinel = new TimeoutCatcher({
+      cleanUp: () => (cleanUpCalled = true),
+      timeout: 3_000,
+      work: async () => {
+        await sleep(500);
+      },
+    });
+
+    const didFinish = await sentinel.watch();
+    expect(didFinish).toEqual(true);
+    expect(cleanUpCalled).toEqual(false);
+  });
+
+  it("terminates before time out if work runs long", async () => {
+    let cleanUpCalled = false;
+    const sentinel = new TimeoutCatcher({
+      cleanUp: () => (cleanUpCalled = true),
+      timeout: 3_000,
+      work: async () => {
+        await sleep(1_500);
+      },
+    });
+
+    const didFinish = await sentinel.watch();
+    expect(didFinish).toEqual(false);
+    expect(cleanUpCalled).toEqual(true);
+  });
+
+  it("rethrows unexpected errors", async () => {
+    let cleanUpCalled = false;
+    const sentinel = new TimeoutCatcher({
+      cleanUp: () => (cleanUpCalled = true),
+      timeout: 3_000,
+      work: async () => {
+        throw new Error("Spam spam spam spam");
+      },
+    });
+
+    try {
+      await sentinel.watch();
+      throw new Error("Expected error did not occur");
+    } catch (error) {
+      expect(error).toHaveProperty("message", "Spam spam spam spam");
+      expect(cleanUpCalled).toEqual(false);
+    }
+  });
+});

package/lambda/index.js

@@ -0,0 +1,3 @@
+const { TimeoutCatcher } = require('./TimeoutCatcher');
+
+module.exports = { TimeoutCatcher }

package/lambda/jest.config.js

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

package/logs/.eslintrc.json

@@ -0,0 +1,3 @@
+{
+    "extends": "@friggframework/eslint-config"
+}

package/logs/CHANGELOG.md

@@ -0,0 +1,57 @@
+# v1.0.9 (Tue Jan 31 2023)
+
+#### 🐛 Bug Fix
+
+- Bump independent versions \[skip ci\] ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 1
+
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))
+
+---
+
+# v1.0.8 (Mon Jan 09 2023)
+
+#### 🐛 Bug Fix
+
+- Merge remote-tracking branch 'origin/main' into gitbook-updates [#48](https://github.com/friggframework/frigg/pull/48) ([@seanspeaks](https://github.com/seanspeaks))
+- Bump independent versions \[skip ci\] ([@seanspeaks](https://github.com/seanspeaks))
+- Merge remote-tracking branch 'origin/main' into simplify-mongoose-models ([@seanspeaks](https://github.com/seanspeaks))
+- Add READMEs for all packages and api-modules [#20](https://github.com/friggframework/frigg/pull/20) ([@seanspeaks](https://github.com/seanspeaks))
+- Add READMEs for all packages and api-modules ([@seanspeaks](https://github.com/seanspeaks))
+
+#### ⚠️ Pushed to `main`
+
+- Merge branch 'main' into gitbook-updates ([@seanspeaks](https://github.com/seanspeaks))
+- Refactored for more conventional naming (at least for packages) ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 1
+
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))
+
+---
+
+# v1.0.7 (Tue Dec 06 2022)
+
+#### 🐛 Bug Fix
+
+- fix modules to @friggframework [#74](https://github.com/friggframework/frigg/pull/74) ([@sheehantoufiq](https://github.com/sheehantoufiq))
+- fix modules to @friggframework ([@sheehantoufiq](https://github.com/sheehantoufiq))
+- Bump independent versions \[skip ci\] ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 2
+
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))
+- Sheehan Toufiq Khan ([@sheehantoufiq](https://github.com/sheehantoufiq))
+
+---
+
+# v1.0.6 (Mon Sep 19 2022)
+
+#### 🐛 Bug Fix
+
+- Merge remote-tracking branch 'origin/main' into gitbook-updates [#48](https://github.com/friggframework/frigg/pull/48) ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 1
+
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))

package/logs/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2022 Left Hook Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/logs/README.md

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

package/logs/index.js

@@ -0,0 +1,7 @@
+const {debug, initDebugLog, flushDebugLog} = require('./logger');
+
+module.exports = {
+    debug,
+    initDebugLog,
+    flushDebugLog
+}

package/logs/jest.config.js

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

package/logs/logger.js

@@ -0,0 +1,69 @@
+const util = require('util');
+const aws = require('aws-sdk');
+
+// Except in some outlier circumstances, for example steam or event error handlers, this should be the only place that calls `console.*`.  That way, this file can be modified to log everything properly on a variety of platforms because all the logging code is here in one place.
+/* eslint-disable no-console */
+
+const logs = [];
+let flushCalled = false;
+
+// Log AWS SDK calls
+aws.config.logger = { log: debug };
+
+function debug(...messages) {
+    if (messages.length) {
+        const date = new Date();
+        const text = util.format.apply(null, messages);
+
+        if (process.env.DEBUG_VERBOSE === '1') {
+            console.debug(date, text);
+        } else {
+            logs.push({ date, text });
+        }
+    }
+}
+
+function initDebugLog(...initMessages) {
+    flushCalled = false;
+
+    // Hacky but fast way to empty an array.
+    logs.length = 0;
+
+    // Log initial event
+    debug(...initMessages);
+}
+
+function flushDebugLog(error) {
+    if (flushCalled) {
+        console.debug(
+            'Another error was encountered while handling the same request or event!  All debug messages are included again in this output as well.'
+        );
+    }
+
+    flushCalled = true;
+
+    // Output unless in verbose mode.  In verbose mode, these will already have been output so we don't want to output the messages twice.
+    if (process.env.DEBUG_VERBOSE !== '1') {
+        if (logs?.length > 0) {
+            for (const { date, text } of logs) {
+                console.debug(date, text);
+            }
+        }
+    }
+
+    if (!error) {
+        error = new Error('flushDebugLog called with empty error');
+    }
+
+    console.error(error);
+
+    let { cause: parentError } = error;
+
+    while (parentError) {
+        console.error('(Caused By)-------------------------');
+        console.error(parentError);
+        parentError = parentError.cause;
+    }
+}
+
+module.exports = { debug, initDebugLog, flushDebugLog };