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

package/encrypt/index.js

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

package/encrypt/jest.config.js

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

package/encrypt/test-encrypt.js

@@ -0,0 +1,107 @@
+const AWS = require('aws-sdk');
+const { mongoose } = require('../database/mongoose');
+const crypto = require('crypto');
+const { Encrypt } = require('./encrypt');
+
+const hexPattern = /^[a-f0-9]+$/i; // match hex strings of length >= 1
+
+// Test that an encrypted secret value appears to have valid values (without actually decrypting it).
+function expectValidSecret(secret) {
+    const parts = secret.split(':');
+    const keyId = Buffer.from(parts[0], 'base64').toString();
+    const iv = parts[1];
+    const encryptedText = parts[2];
+    const encryptedKey = Buffer.from(parts[3], 'base64').toString();
+
+    expect(iv).toHaveLength(32);
+    expect(iv).toMatch(hexPattern);
+    expect(encryptedText).toHaveLength(14);
+    expect(encryptedText).toMatch(hexPattern);
+
+    // Keys from AWS start with Karn and have a different format.
+    if (keyId.startsWith('arn:aws')) {
+        expect(keyId).toBe(
+            `arn:aws:kms:us-east-1:000000000000:key/${process.env.KMS_KEY_ARN}`
+        );
+        // The length here is a sanity check.  Seems they are always within this range.
+        expect(encryptedKey.length).toBeGreaterThanOrEqual(85);
+        expect(encryptedKey.length).toBeLessThanOrEqual(140);
+    } else {
+        const { AES_KEY_ID, DEPRECATED_AES_KEY_ID } = process.env;
+        expect([AES_KEY_ID, DEPRECATED_AES_KEY_ID]).toContain(keyId);
+
+        const encryptedKeyParts = encryptedKey.split(':');
+        const iv2 = encryptedKeyParts[0];
+        const encryptedKeyPart = encryptedKeyParts[1];
+
+        expect(iv2).toHaveLength(32);
+        expect(iv2).toMatch(hexPattern);
+        expect(encryptedKeyPart).toHaveLength(64);
+        expect(encryptedKeyPart).toMatch(hexPattern);
+    }
+}
+
+// Load and validate a raw test document compared to a Mongoose document object.
+async function expectValidRawDoc(Model, doc) {
+    const rawDoc = await expectValidRawDocById(Model, doc._id);
+
+    expect(rawDoc.notSecret.toString()).toBe(doc.notSecret.toString());
+    expect(rawDoc).not.toHaveProperty('secret', doc.secret);
+
+    return rawDoc;
+}
+
+// Load and validate a raw test document by ID.
+async function expectValidRawDocById(Model, _id) {
+    const rawDoc = await Model.collection.findOne({ _id });
+
+    expect(rawDoc).toHaveProperty('notSecret');
+    expect(rawDoc).toHaveProperty('secret');
+    expectValidSecret(rawDoc.secret);
+
+    return rawDoc;
+}
+
+// Create a clean test model, so that the plug-in can be reinitialized.
+function createModel() {
+    const randomHex = crypto.randomBytes(16).toString('hex');
+    const schema = new mongoose.Schema({
+        secret: { type: String, lhEncrypt: true },
+        notSecret: { type: mongoose.Schema.Types.ObjectId },
+        'deeply.nested.secret': { type: String, lhEncrypt: true },
+    });
+
+    schema.plugin(Encrypt);
+
+    const Model = mongoose.model(`EncryptTest_${randomHex}`, schema);
+    return { schema, Model };
+}
+
+// Save and validate a test doc.
+async function saveTestDocument(Model) {
+    const notSecret = new mongoose.Types.ObjectId();
+    const secret = 'abcdefg';
+    const doc = new Model({ notSecret, secret });
+
+    expect(doc).toHaveProperty('notSecret');
+    expect(doc.notSecret.toString()).toBe(notSecret.toString());
+    expect(doc).toHaveProperty('secret');
+    expect(doc.secret).toBe(secret);
+
+    await doc.save();
+
+    expect(doc).toHaveProperty('notSecret');
+    expect(doc.notSecret.toString()).toBe(notSecret.toString());
+    expect(doc).toHaveProperty('secret');
+    expect(doc.secret).toBe(secret);
+
+    return { doc, secret, notSecret };
+}
+
+module.exports = {
+    expectValidSecret,
+    expectValidRawDoc,
+    expectValidRawDocById,
+    createModel,
+    saveTestDocument,
+};

package/errors/.eslintrc.json

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

package/errors/CHANGELOG.md

@@ -0,0 +1,44 @@
+# v1.1.6 (Wed Feb 08 2023)
+
+#### 🐛 Bug Fix
+
+- URLSearchParams (used in OAuth2 base) was not printing out bodies in … [#124](https://github.com/friggframework/frigg/pull/124) ([@seanspeaks](https://github.com/seanspeaks))
+- URLSearchParams (used in OAuth2 base) was not printing out bodies in error logs. ([@seanspeaks](https://github.com/seanspeaks))
+- Bump independent versions \[skip ci\] ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 1
+
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))
+
+---
+
+# v1.1.5 (Wed Jan 18 2023)
+
+#### 🐛 Bug Fix
+
+- Ironclad and slack updates [#96](https://github.com/friggframework/frigg/pull/96) ([@seanspeaks](https://github.com/seanspeaks))
+- Fetch Error fix to also log a body if already used (and passed in) ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 1
+
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))
+
+---
+
+# v1.1.4 (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`
+
+- Refactored for more conventional naming (at least for packages) ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 1
+
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))

package/errors/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/errors/README.md

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

package/errors/base-error.js

@@ -0,0 +1,23 @@
+// See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#differentiate_between_similar_errors
+class BaseError extends Error {
+    constructor(message, options, ...moreOptions) {
+        // Pass remaining arguments (including vendor specific ones) to parent constructor
+        super(message, options, ...moreOptions);
+
+        // In the future `cause` will be handled by V8 in Node.js.  For now, add the property manually
+        // See: https://v8.dev/features/error-cause
+        if (options?.cause) {
+            this.cause = options.cause;
+        }
+
+        // Maintains proper stack trace for where our error was thrown (method only available under V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, BaseError);
+        }
+
+        // Set the error name for console output
+        this.name = this.constructor?.name;
+    }
+}
+
+module.exports = { BaseError };

package/errors/base-error.test.js

@@ -0,0 +1,32 @@
+const { BaseError } = require('./base-error');
+
+describe('BaseError', () => {
+    it('can be inherited and instantiated', () => {
+        class XyzError extends BaseError {}
+        const error = new XyzError();
+        expect(error).toHaveProperty('message', '');
+        expect(error).toHaveProperty('stack');
+        expect(error.stack).toContain('XyzError');
+        expect(error.stack).toContain('at new XyzError');
+        expect(error.stack).toContain('base-error.test.js:');
+    });
+
+    it('can set the error message', () => {
+        class TestError extends BaseError {}
+        const error = new TestError('Goblins!');
+        expect(error).toHaveProperty('message', 'Goblins!');
+    });
+
+    it('sets the error name correctly', () => {
+        class TestError extends BaseError {}
+        const error = new TestError();
+        expect(error).toHaveProperty('name', 'TestError');
+    });
+
+    it('can set the parent cause', () => {
+        class TestError extends BaseError {}
+        const rootError = new Error('Davros!');
+        const error = new TestError('Daleks!', { cause: rootError });
+        expect(error).toHaveProperty('cause', rootError);
+    });
+});

package/errors/bump.txt

@@ -0,0 +1 @@
+0

package/errors/fetch-error.js

@@ -0,0 +1,72 @@
+const { BaseError } = require('./base-error');
+const { stripIndent } = require('common-tags');
+
+// TODO hide header values
+
+// Parameters names here are based on fetch.  See:
+// https://developer.mozilla.org/en-US/docs/Web/API/fetch
+
+class FetchError extends BaseError {
+    constructor(options = {}) {
+        const { resource, init, response, responseBody } = options;
+        const method = init?.method ?? 'GET';
+        const initText = init
+            ? init.body instanceof URLSearchParams
+                ? (() => {
+                      init.body = init.body.toString();
+                      return JSON.stringify({ init }, null, 2);
+                  })()
+                : JSON.stringify({ init }, null, 2)
+            : '';
+
+        let responseBodyText = '<response body is unavailable>';
+        if (typeof responseBody === 'string') {
+            responseBodyText = responseBody;
+        } else if (responseBody) {
+            responseBodyText = JSON.stringify(responseBody, null, 2);
+        }
+
+        const responseHeaders = {};
+        if (response?.headers) {
+            for (const [key, value] of response.headers) {
+                responseHeaders[key] = value;
+            }
+        }
+
+        const responseHeaderText = response
+            ? JSON.stringify({ headers: responseHeaders }, null, 2)
+            : '';
+
+        const messageParts = [
+            stripIndent`
+                -----------------------------------------------------
+                An error ocurred while fetching an external resource.
+                -----------------------------------------------------
+                >>> Request Details >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+                ${method} ${resource}
+            `,
+            initText,
+            stripIndent`
+                <<< Response Details <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+                ${response?.status} ${response?.statusText}
+            `,
+            responseHeaderText,
+            responseBodyText,
+            stripIndent`
+                -----------------------------------------------------
+                Stack Trace:
+            `,
+        ];
+
+        super(messageParts.filter(Boolean).join('\n'));
+    }
+
+    static async create(options = {}) {
+        const { response } = options;
+        let responseBody = response?.bodyUsed ? null : await response?.text();
+        if (!responseBody && options.body) responseBody = options.body;
+        return new FetchError({ ...options, responseBody });
+    }
+}
+
+module.exports = { FetchError };

package/errors/fetch-error.test.js

@@ -0,0 +1,79 @@
+const fetch = require('node-fetch');
+const { stripIndent } = require('common-tags');
+const { FetchError } = require('./fetch-error');
+const FormData = require('form-data');
+
+describe('FetchError', () => {
+    it('can be instantiated with default arguments', () => {
+        const error = new FetchError();
+        expect(error).toHaveProperty('message');
+        expect(error).not.toHaveProperty('cause');
+    });
+
+    it('can be created asynchronously with default values', async () => {
+        const error = await FetchError.create();
+        expect(error).toHaveProperty('message');
+        expect(error).not.toHaveProperty('cause');
+    });
+
+    it('can be created asynchronously', async () => {
+        const resource = 'http://example.com';
+        const init = {};
+        const response = {
+            status: 500,
+            statusText: 'Space aliens!',
+            headers: Object.entries({ 'cache-control': '123' }), // needs to be an Iterable
+            text: async () => '<!doctype html>',
+        };
+
+        const error = await FetchError.create({
+            resource,
+            init,
+            response,
+        });
+
+        expect(error).toHaveProperty('message');
+        expect(error.message).toContain('GET http://example.com');
+        expect(error.message).toContain('500 Space aliens!');
+        expect(error.message).toContain('"cache-control": "123"');
+        expect(error.message).toContain('<!doctype html>');
+    });
+
+    it('can be passed an object for the body', async () => {
+        const error = new FetchError({ responseBody: { test: true } });
+        expect(error).toHaveProperty('message');
+        expect(error.message).toContain('"test": true');
+    });
+
+    it('ignores response body if already streamed', async () => {
+        const response = { bodyUsed: true };
+        const error = await FetchError.create({ response });
+
+        expect(error).toHaveProperty('message');
+        expect(error.message).toContain('<response body is unavailable>');
+    });
+
+    it.only('prints a formData body legibly', async () => {
+        const response = {
+            status: 500,
+            statusText: 'Space aliens!',
+            headers: Object.entries({ 'cache-control': '123' }), // needs to be an Iterable
+            text: async () => '<!doctype html>',
+        };
+
+        const params = new URLSearchParams();
+        params.append('test', 'test');
+        const init = {
+            method: 'POST',
+            credentials: 'include',
+            headers: {},
+            query: {},
+            body: params,
+            returnFullRes: false,
+        };
+        const error = await FetchError.create({ response, init });
+
+        expect(error).toHaveProperty('message');
+        expect(error.message).toContain('test=test');
+    });
+});

package/errors/halt-error.js

@@ -0,0 +1,10 @@
+const { BaseError } = require('./base-error');
+
+class HaltError extends BaseError {
+    constructor(message, ...errorOptions) {
+        super(message, ...errorOptions);
+        this.isHaltError = true;
+    }
+}
+
+module.exports = { HaltError };

package/errors/halt-error.test.js

@@ -0,0 +1,11 @@
+const { HaltError } = require('./halt-error');
+
+describe('HaltError', () => {
+    it('can be instantiated', () => {
+        const rootError = new Error('Gremlinoids!!');
+        const error = new HaltError('STOP', { cause: rootError });
+        expect(error).toHaveProperty('message', 'STOP');
+        expect(error).toHaveProperty('cause', rootError);
+        expect(error).toHaveProperty('isHaltError', true);
+    });
+});

package/errors/index.js

@@ -0,0 +1,15 @@
+const { BaseError } = require('./base-error');
+const { FetchError } = require('./fetch-error');
+const { HaltError } = require('./halt-error');
+const {
+    RequiredPropertyError,
+    ParameterTypeError,
+} = require('./validation-errors');
+
+module.exports = {
+    BaseError,
+    FetchError,
+    HaltError,
+    RequiredPropertyError,
+    ParameterTypeError,
+};

package/errors/jest.config.js

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

package/errors/validation-errors.js

@@ -0,0 +1,23 @@
+const { BaseError } = require('./base-error');
+
+class RequiredPropertyError extends BaseError {
+    constructor(options = {}, ...parentOptions) {
+        const { parent, key = '' } = options;
+        const parentText = parent ? `(${parent.name}) ` : '';
+        const message = `${parentText}Key "${key}" is a required parameter.`;
+        super(message, ...parentOptions);
+    }
+}
+
+class ParameterTypeError extends BaseError {
+    constructor(options = {}, ...parentOptions) {
+        const { parent, key = '', value = '', expectedType } = options;
+        const parentText = parent ? `(${parent.name}) ` : '';
+        const keyText = key ? `key "${key}" with ` : '';
+        const typeName = expectedType?.name ?? '';
+        const message = `${parentText}Expected ${keyText}value "${value}" to be of type "${typeName}"`;
+        super(message, ...parentOptions);
+    }
+}
+
+module.exports = { RequiredPropertyError, ParameterTypeError };

package/errors/validation-errors.test.js

@@ -0,0 +1,120 @@
+const {
+    RequiredPropertyError,
+    ParameterTypeError,
+} = require('./validation-errors');
+
+describe('RequiredPropertyError', () => {
+    it('can be instantiated with default arguments', () => {
+        const error = new RequiredPropertyError();
+        expect(error).toHaveProperty(
+            'message',
+            'Key "" is a required parameter.'
+        );
+        expect(error).not.toHaveProperty('cause');
+    });
+
+    it('allows setting the key name of the error', () => {
+        const error = new RequiredPropertyError({ key: 'abc' });
+        expect(error).toHaveProperty(
+            'message',
+            'Key "abc" is a required parameter.'
+        );
+        expect(error).not.toHaveProperty('cause');
+    });
+
+    it('allows setting the parent of the error', () => {
+        const error = new RequiredPropertyError({ parent: class Xyz {} });
+        expect(error).toHaveProperty(
+            'message',
+            '(Xyz) Key "" is a required parameter.'
+        );
+        expect(error).not.toHaveProperty('cause');
+    });
+
+    it('passes cause through to the Error parent class', () => {
+        const error = new RequiredPropertyError(
+            {
+                parent: class Qrs {},
+                key: 'def',
+            },
+            { cause: new Error('Gremlins!!') }
+        );
+        const expectedMessage = '(Qrs) Key "def" is a required parameter.';
+        expect(error).toHaveProperty('message', expectedMessage);
+        expect(error).toHaveProperty('cause');
+        expect(error.cause).toHaveProperty('message', 'Gremlins!!');
+    });
+});
+
+describe('ParameterTypeError', () => {
+    it('can be instantiated with default arguments', () => {
+        const error = new ParameterTypeError();
+        expect(error).toHaveProperty(
+            'message',
+            'Expected value "" to be of type ""'
+        );
+        expect(error).not.toHaveProperty('cause');
+    });
+
+    it('allows setting the key name of the error', () => {
+        const error = new ParameterTypeError({ key: 'abc' });
+        expect(error).toHaveProperty(
+            'message',
+            'Expected key "abc" with value "" to be of type ""'
+        );
+        expect(error).not.toHaveProperty('cause');
+    });
+
+    it('allows setting the parent of the error', () => {
+        const error = new ParameterTypeError({ parent: class Xyz {} });
+        expect(error).toHaveProperty(
+            'message',
+            '(Xyz) Expected value "" to be of type ""'
+        );
+        expect(error).not.toHaveProperty('cause');
+    });
+
+    it('allows setting the value of the error', () => {
+        const error = new ParameterTypeError({ value: 1 });
+        expect(error).toHaveProperty(
+            'message',
+            'Expected value "1" to be of type ""'
+        );
+        expect(error).not.toHaveProperty('cause');
+    });
+
+    it('allows setting the expected type of the error', () => {
+        const error = new ParameterTypeError({ expectedType: class Xyz {} });
+        expect(error).toHaveProperty(
+            'message',
+            'Expected value "" to be of type "Xyz"'
+        );
+        expect(error).not.toHaveProperty('cause');
+    });
+
+    it('allows setting the expected type of the error to Array', () => {
+        const error = new ParameterTypeError({ expectedType: Array });
+        expect(error).toHaveProperty(
+            'message',
+            'Expected value "" to be of type "Array"'
+        );
+        expect(error).not.toHaveProperty('cause');
+    });
+
+    it('passes cause through to the Error parent class', () => {
+        const rootError = new Error('Gremlins!!');
+        const error = new ParameterTypeError(
+            {
+                parent: class Parent {},
+                key: 'clé',
+                expectedType: class Expected {},
+                value: 'schmalue',
+            },
+            { cause: rootError }
+        );
+        const expectedMessage =
+            '(Parent) Expected key "clé" with value "schmalue" to be of type "Expected"';
+        expect(error).toHaveProperty('message', expectedMessage);
+        expect(error).toHaveProperty('cause', rootError);
+    });
+});

package/eslint-config/.eslintrc.json

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

package/eslint-config/CHANGELOG.md

@@ -0,0 +1,17 @@
+# 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`
+
+- Refactored for more conventional naming (at least for packages) ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 1
+
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))

package/eslint-config/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/eslint-config/README.md

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