@friggframework/core 2.0.0-next.5 → 2.0.0-next.50

package/integrations/integration-user.js

@@ -1,144 +0,0 @@
-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/test/integration-base.test.js

@@ -1,144 +0,0 @@
-const _ = require('lodash');
-const { mongoose } = require('../../database/mongoose');
-const { expect } = require('chai');
-const { IntegrationBase } = require("../integration-base");
-const {Credential} = require('../../module-plugin/credential');
-const {Entity} = require('../../module-plugin/entity');
-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/TimeoutCatcher.test.js

@@ -1,68 +0,0 @@
-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/logs/logger.test.js

@@ -1,76 +0,0 @@
-const { debug, initDebugLog, flushDebugLog } = require('./logger');
-const sinon = require('sinon');
-const {
-    overrideEnvironment,
-    restoreEnvironment,
-} = require('@friggframework/test');
-
-/* eslint-disable no-console */
-
-describe('Logger', () => {
-    beforeEach(() => {
-        sinon.stub(console, 'debug');
-        sinon.stub(console, 'error');
-    });
-
-    afterEach(() => {
-        console.debug.restore();
-        console.error.restore();
-        restoreEnvironment();
-    });
-
-    it('runs', () => {
-        initDebugLog('Test Event', { test: true });
-        debug('Add a message', 'or two', { or: 3 });
-        flushDebugLog(new Error());
-
-        expect(console.debug).toHaveProperty('callCount', 2);
-        expect(console.error).toHaveProperty('callCount', 1);
-    });
-
-    it('logs immediately when environment variable set', () => {
-        overrideEnvironment({ DEBUG_VERBOSE: '1' });
-
-        debug('Add a message', 'or two', { or: 3 });
-        debug('And another');
-
-        expect(console.debug).toHaveProperty('callCount', 2);
-        expect(console.error).toHaveProperty('callCount', 0);
-    });
-
-    it('is resilient to missing parameters', () => {
-        initDebugLog();
-        debug();
-        flushDebugLog();
-
-        expect(console.debug).toHaveProperty('callCount', 0);
-        expect(console.error).toHaveProperty('callCount', 1);
-    });
-
-    it('outputs parent errors', () => {
-        initDebugLog();
-
-        const error = new Error();
-        error.cause = new Error();
-        error.cause.cause = new Error();
-        error.cause.cause.cause = new Error();
-
-        flushDebugLog(error);
-
-        expect(console.debug).toHaveProperty('callCount', 0);
-        expect(console.error).toHaveProperty('callCount', 7); // 1 + 2 for each cause
-    });
-
-    it('adds a debug message if more than 1 error encountered', () => {
-        initDebugLog();
-        flushDebugLog(new Error());
-
-        expect(console.debug).toHaveProperty('callCount', 0);
-        expect(console.error).toHaveProperty('callCount', 1);
-
-        flushDebugLog(new Error());
-
-        expect(console.debug).toHaveProperty('callCount', 1);
-        expect(console.error).toHaveProperty('callCount', 2);
-    });
-});