exframe-middleware 1.1.0 → 1.3.2

package/.eslintrc.json

@@ -5,7 +5,7 @@
   },
   "extends": "airbnb-base",
   "parserOptions": {
-    "ecmaVersion": 2018
+    "ecmaVersion": 2020
   },
   "rules": {
     "comma-dangle": [2, "never"],

package/index.js

@@ -33,7 +33,8 @@ module.exports = {
   authorizeUser: {
     mq: authorizeUser,
     express: (req, res, next) => {
-      authorizeUser(req);
+      const user = req?.user || req?.context?.user;
+      authorizeUser({ user });
       next();
     }
   },

package/lib/authorizeUser.js

@@ -2,7 +2,11 @@
 
 const errors = require('exframe-errors');
 
-module.exports = context => {
-  if (!context.user)
+/**
+ * @param {Object} context
+ * @param {Object} context.user
+ */
+module.exports = ({ user }) => {
+  if (!user)
     throw new errors.Unauthorized('Could not authorize user');
 };

package/lib/handleErrors.js

@@ -3,7 +3,20 @@
 /**
  * error
  */
-module.exports = (context, error, optionalIncomingMessage) => {
+module.exports = (context, rawError, optionalIncomingMessage) => {
+  let error = rawError;
+
+  // exframe-workflow v4 creates a parent error object with an errors array that can contain multiple child errors
+  // originating from forked workflows. This check moves that errors array to the top level so that the workflow
+  // error can be processed in the same way as pre-v4 exframe-workflow errors below.
+  // NOTE: schema validation errors can also have an errors array, but in that case the objects in the array are
+  // not complete errors and represent each schema validation error from a single request. These objects will not
+  // have a "statusCode" property and is the reason for the check here to keep them out of the workflow error logic.
+  if (Array.isArray(rawError.errors) && rawError.errors.length > 0 && rawError.errors[0].statusCode !== undefined) {
+    if (rawError.errors.length > 1) error = rawError.errors;
+    else error = rawError.errors[0] || rawError;
+  }
+
   const { errorCode } = error;
   let { message } = error;
   let status;

package/package.json

@@ -1,31 +1,37 @@
 {
   "name": "exframe-middleware",
-  "version": "1.1.0",
+  "version": "1.3.2",
   "description": "",
   "main": "index.js",
+  "config": {
+    "reporter": "mocha-exzeo-reporter"
+  },
   "scripts": {
-    "test": "nyc mocha",
+    "test": "nyc mocha --reporter $npm_package_config_reporter",
     "pretest": "npm run lint",
     "dev-test": "nyc mocha",
     "lint": "eslint --ignore-pattern test* ."
   },
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@bitbucket.org/exzeo-usa/exframe-middleware.git"
+    "url": "https://bitbucket.org/exzeo-usa/exframe",
+    "directory": "packages/exframe-middleware"
   },
-  "author": "",
+  "author": "Exzeo",
   "license": "ISC",
   "homepage": "https://bitbucket.org/exzeo-usa/exframe-middleware#readme",
   "devDependencies": {
-    "chai": "^4.2.0",
-    "eslint": "^7.9.0",
-    "eslint-config-airbnb-base": "^14.2.0",
+    "chai": "*",
+    "eslint": "*",
+    "eslint-config-airbnb-base": "*",
     "eslint-plugin-import": "^2.22.0",
-    "mocha": "^8.1.3",
-    "nyc": "^15.1.0",
-    "sinon": "^9.0.3"
+    "mocha": "*",
+    "mocha-exzeo-reporter": "*",
+    "nyc": "*",
+    "sinon": "*"
   },
   "dependencies": {
     "exframe-errors": "^1.2.0"
-  }
+  },
+  "gitHead": "6c4adb8a4ad4a5a60f1b98fb94dc4a13026eb796"
 }

package/sonar-project.properties

@@ -0,0 +1,21 @@
+# The language the application is written in.
+; sonar.language=js
+sonar.language=JavaScript
+
+# Path is relative to the sonar-project.properties file. Defaults to .
+sonar.sources=.
+
+# # Encoding of the source code. Default is default system encoding
+sonar.sourceEncoding=UTF-8
+
+# # Patterns used to exclude some source files from analysis.
+sonar.exclusions=test*/**/*.js
+
+# # Patterns used to include some test files and only these ones in analysis.
+sonar.test.inclusions=test*/**/*.js
+
+# Patterns used to exclude some files from coverage report.
+sonar.coverage.exclusions=test*/**/*.js,node_modules/*,documentation/combined/lcov-report/*,junit/*
+
+# Paths (absolute or relative) to the files with LCOV data.
+sonar.javascript.lcov.reportPaths=documentation/combined/lcov.info

package/test/authorizeUser.test.js

@@ -6,26 +6,61 @@ const errors = require('exframe-errors');
 const { authorizeUser } = require('../index');
 
 context('authorizeUser', () => {
-  it('throws unauthorized error when no user', () => {
-    try { authorizeUser.mq({}); }
-    catch (e) {
-      expect(e).to.be.an.instanceOf(errors.Unauthorized);
-      return;
-    }
-
-    expect.fail('authorizeUser should have thrown an Unauthorized error');
-  });
+  describe('mq', () => {
+    it('throws unauthorized error when no user', () => {
+      try { authorizeUser.mq({}); }
+      catch (e) {
+        expect(e).to.be.an.instanceOf(errors.Unauthorized);
+        return;
+      }
+
+      expect.fail('authorizeUser should have thrown an Unauthorized error');
+    });
 
-  it('does not throw an error when there is a user', () => {
-    try { authorizeUser.mq({ user: 'something' }); }
-    catch (e) { expect.fail('authorizeUser should not have thrown an error'); }
+    it('does not throw an error when there is a user', () => {
+      try { authorizeUser.mq({ user: 'something' }); }
+      catch (e) { expect.fail('authorizeUser should not have thrown an error'); }
+    });
   });
 
-  it('works when there is a user and calls next when using express version', () => {
-    let called = 0;
-    const next = () => ++called;
-    authorizeUser.express({ user: {} }, {}, next);
+  describe('express - user exists directly on the request object', () => {
+    it('calls the next function when there is a user', () => {
+      let called = 0;
+      const next = () => ++called;
+      authorizeUser.express({ user: {} }, {}, next);
+
+      expect(called).to.equal(1);
+    });
+    it('throws unauthorized error when there is no user', () => {
+      let called = 0;
+      const next = () => ++called;
+      try { authorizeUser.express({ }, {}, next); }
+      catch (e) {
+        expect(e).to.be.an.instanceOf(errors.Unauthorized);
+        return;
+      }
+      expect.fail('authorizeUser should have thrown an Unauthorized error');
+      expect(called).to.equal(0);
+    });
+  });
 
-    expect(called).to.equal(1);
+  describe('express - user exists within the context on the request object', () => {
+    it('calls the next function when there is a user', () => {
+      let called = 0;
+      const next = () => ++called;
+      authorizeUser.express({ context: { user: {} } }, {}, next);
+      expect(called).to.equal(1);
+    });
+    it('throws unauthorized error when there is no user', () => {
+      let called = 0;
+      const next = () => ++called;
+      try { authorizeUser.express({ context: {} }, {}, next); }
+      catch (e) {
+        expect(e).to.be.an.instanceOf(errors.Unauthorized);
+        return;
+      }
+      expect.fail('authorizeUser should have thrown an Unauthorized error');
+      expect(called).to.equal(0);
+    });
   });
 });

package/test/handleErrors.test.js

@@ -1,17 +1,16 @@
 'use strict';
 
-
 const errors = require('exframe-errors');
 const { expect } = require('chai');
 const sinon = require('sinon');
 
 const { fakeLogger } = require('./support/utils');
-const handleErorrs = require('../index').handleErrors();
+const handleErrors = require('../index').handleErrors();
 
 context('handleErrors', () => {
   describe('status buckets', () => {
     it('403 beats everything else', async () => {
-      const { status, message } = await handleErorrs.mq(
+      const { status, message } = await handleErrors.mq(
         [
           new errors.Unauthorized('nah brah'),
           new errors.InvalidInput(),
@@ -26,7 +25,7 @@ context('handleErrors', () => {
     });
 
     it('then 401', async () => {
-      const { status, message } = await handleErorrs.mq(
+      const { status, message } = await handleErrors.mq(
         [
           new errors.InvalidInput(),
           new errors.ResourceNotFound(),
@@ -40,7 +39,7 @@ context('handleErrors', () => {
     });
 
     it('then 500', async () => {
-      const { status, message } = await handleErorrs.mq(
+      const { status, message } = await handleErrors.mq(
         [
           new errors.InvalidInput(),
           new errors.ExframeBase('some message')
@@ -53,7 +52,7 @@ context('handleErrors', () => {
     });
 
     it('then groups 400 type errors', async () => {
-      const { status, message } = await handleErorrs.mq(
+      const { status, message } = await handleErrors.mq(
         [
           new errors.InvalidInput(), // 400
           new errors.ResourceNotFound() // 404
@@ -66,7 +65,7 @@ context('handleErrors', () => {
     });
 
     it('but gives a specific error status when all errors are the same', async () => {
-      const { status, message, errorCode } = await handleErorrs.mq(
+      const { status, message } = await handleErrors.mq(
         [
           new errors.ResourceNotFound(),
           new errors.ResourceNotFound(),
@@ -82,25 +81,25 @@ context('handleErrors', () => {
 
   describe('single errors', () => {
     it('handles single errors', async () => {
-      const { status, message } = await handleErorrs.mq(new errors.InvalidInput('some message, ya'), { log: fakeLogger });
+      const { status, message } = await handleErrors.mq(new errors.InvalidInput('some message, ya'), { log: fakeLogger });
       expect(status).to.equal(400);
       expect(message).to.equal('some message, ya');
     });
 
     it('defaults errors to 500 errors', async () => {
-      const { status, message } = await handleErorrs.mq('not an error object', { log: fakeLogger });
+      const { status, message } = await handleErrors.mq('not an error object', { log: fakeLogger });
       expect(status).to.equal(500);
       expect(message).to.equal('Internal Server Error');
     });
 
     it('handles baseExzeoError', async () => {
-      const { status, message } = await handleErorrs.mq(new errors.ExframeBase('this is my message'), { log: fakeLogger });
+      const { status, message } = await handleErrors.mq(new errors.ExframeBase('this is my message'), { log: fakeLogger });
       expect(status).to.equal(500);
       expect(message).to.equal('this is my message');
     });
 
     it('returns errorCode when provided', async () => {
-      const { status, message, errorCode } = await handleErorrs.mq(new errors.ExframeBase('this is my message', 'ERROR_CODE'), { log: fakeLogger });
+      const { status, message, errorCode } = await handleErrors.mq(new errors.ExframeBase('this is my message', 'ERROR_CODE'), { log: fakeLogger });
       expect(status).to.equal(500);
       expect(message).to.equal('this is my message');
       expect(errorCode).to.equal('ERROR_CODE');
@@ -117,7 +116,7 @@ context('handleErrors', () => {
       const sendSpy = sinon.spy(expressResponseObject, 'send');
       const doneSpy = sinon.spy();
 
-      const response = handleErorrs.express(new errors.ResourceNotFound('Resource not found'), { log: fakeLogger }, expressResponseObject, doneSpy);
+      const response = handleErrors.express(new errors.ResourceNotFound('Resource not found'), { log: fakeLogger }, expressResponseObject, doneSpy);
 
       expect(doneSpy.callCount).to.equal(0);
       expect(statusSpy.callCount).to.equal(1);
@@ -142,7 +141,7 @@ context('handleErrors', () => {
       const sendSpy = sinon.spy(expressResponseObject, 'send');
       const doneSpy = sinon.spy();
 
-      handleErorrs.express(null, { log: fakeLogger }, expressResponseObject, doneSpy);
+      handleErrors.express(null, { log: fakeLogger }, expressResponseObject, doneSpy);
 
       expect(doneSpy.callCount).to.equal(1);
       expect(statusSpy.callCount).to.equal(0);
@@ -151,4 +150,93 @@ context('handleErrors', () => {
       sinon.reset();
     });
   });
+  describe('exframe-workflow style errors', () => {
+    it('handles multiple errors', async () => {
+      const testError = new Error('A thing happened');
+      testError.errors = [
+        new errors.InvalidInput('You messed up'),
+        new errors.ResourceNotFound('Something is not there')
+      ];
+      const { status, message } = await handleErrors.mq(testError, { log: fakeLogger });
+      expect(status).to.equal(400);
+      expect(message).to.equal('multiple errors occured: [You messed up, Something is not there]');
+    });
+    it('handles a single error', async () => {
+      const testError = new Error('A thing happened');
+      testError.errors = [
+        new errors.InvalidInput('You messed up')
+      ];
+      const { status, message } = await handleErrors.mq(testError, { log: fakeLogger });
+      expect(status).to.equal(400);
+      expect(message).to.equal('You messed up');
+    });
+    it('handles an empty errors array', async () => {
+      const testError = new Error('A thing happened');
+      testError.errors = [];
+      const { status, message } = await handleErrors.mq(testError, { log: fakeLogger });
+      expect(status).to.equal(500);
+      expect(message).to.equal('A thing happened');
+    });
+    it('handles an errors field that is not an array', async () => {
+      const testError = new Error('A thing happened');
+      testError.errors = 123;
+      const { status, message } = await handleErrors.mq(testError, { log: fakeLogger });
+      expect(status).to.equal(500);
+      expect(message).to.equal('A thing happened');
+    });
+  });
+
+  describe('schema validation errors', () => {
+    it('handles a single validation error', async () => {
+      const testError = new errors.InvalidInput('You messed up');
+      testError.errors = [
+        {
+          keyword: 'required',
+          dataPath: '',
+          schemaPath: '#/required',
+          params: {
+            missingProperty: 'banana'
+          },
+          message: 'should have required property \'banana\''
+        }
+      ];
+      const { status, message } = await handleErrors.mq(testError, { log: fakeLogger });
+      expect(status).to.equal(400);
+      expect(message).to.equal('You messed up');
+    });
+
+    it('handles multiple validation error', async () => {
+      const testError = new errors.InvalidInput('You messed up');
+      testError.errors = [
+        {
+          keyword: 'required',
+          dataPath: '',
+          schemaPath: '#/required',
+          params: {
+            missingProperty: 'banana'
+          },
+          message: 'should have required property \'banana\''
+        }, {
+          keyword: 'required',
+          dataPath: '',
+          schemaPath: '#/required',
+          params: {
+            missingProperty: 'pineapple'
+          },
+          message: 'should have required property \'pineapple\''
+        }, {
+          keyword: 'required',
+          dataPath: '',
+          schemaPath: '#/required',
+          params: {
+            missingProperty: 'kiwi'
+          },
+          message: 'should have required property \'kiwi\''
+        }
+      ];
+      const { status, message } = await handleErrors.mq(testError, { log: fakeLogger });
+      expect(status).to.equal(400);
+      expect(message).to.equal('You messed up');
+    });
+  });
 });