exframe-middleware 1.0.1 → 1.3.0

package/README.md

@@ -40,7 +40,7 @@ errors and reports their status and message
   client.use(handleErrors().mq);
 ```
 
-happyRouteResponseBuilder
+standardRouteResponseBuilder
 ---
 
 builds the response object based on input and if single or multi response
@@ -50,6 +50,6 @@ example from in production
   subscribe(
     'startBoBTransfers',
     validateRequestRPC(schemas.startBoBTransfer),
-    (context, message) => startBoBTransfer.start(context, message).then(happyRouteResponseBuilder.singleItem)
+    (context, message) => startBoBTransfer.start(context, message).then(standardRouteResponseBuilder.singleItem)
   )
 ```

package/index.js

@@ -1,13 +1,11 @@
 'use strict';
 
-
 const handleErrors = require('./lib/handleErrors');
 const standardRouteResponseBuilder = require('./lib/standardRouteResponse');
 const buildExpressRequestContext = require('./lib/buildExpressRequestContext');
 const authorizeUser = require('./lib/authorizeUser');
 const buildCspFromHeader = require('./lib/buildCspFromHeaders');
 
-
 module.exports = {
   /**
    * @param {Object} config the configuration object

package/lib/authorizeUser.js

@@ -1,6 +1,5 @@
 'use strict';
 
-
 const errors = require('exframe-errors');
 
 module.exports = context => {

package/lib/buildExpressRequestContext.js

@@ -1,6 +1,5 @@
 'use strict';
 
-
 /**
  * @description middleware for express to build the request context, app.use(buildExpressRequestContext)
  * @param {Object} request express request

package/lib/handleErrors.js

@@ -3,7 +3,21 @@
 /**
  * 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;
 
@@ -45,5 +59,5 @@ module.exports = (context, error, optionalIncomingMessage) => {
   }
   else context.log.warn('There was an issue with the client request', { message: optionalIncomingMessage || error.message, errorDetails: error });
 
-  return { status, message };
+  return { status, message, errorCode };
 };

package/package.json

@@ -1,31 +1,37 @@
 {
   "name": "exframe-middleware",
-  "version": "1.0.1",
+  "version": "1.3.0",
   "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": "^5.15.3",
-    "eslint-config-airbnb-base": "^13.1.0",
-    "eslint-plugin-import": "^2.16.0",
-    "mocha": "^6.0.2",
-    "nyc": "^13.3.0",
-    "sinon": "^7.3.0"
+    "chai": "*",
+    "eslint": "*",
+    "eslint-config-airbnb-base": "*",
+    "eslint-plugin-import": "^2.22.0",
+    "mocha": "*",
+    "mocha-exzeo-reporter": "*",
+    "nyc": "*",
+    "sinon": "*"
   },
   "dependencies": {
-    "exframe-errors": "^1.0.0"
-  }
+    "exframe-errors": "^1.2.0"
+  },
+  "gitHead": "1959247957f1a308c44d4c5210712125ab6e5573"
 }

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/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 } = await handleErorrs.mq(
+      const { status, message } = await handleErrors.mq(
         [
           new errors.ResourceNotFound(),
           new errors.ResourceNotFound(),
@@ -82,21 +81,28 @@ 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 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');
     });
   });
 
@@ -110,16 +116,17 @@ 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);
       expect(statusSpy.args).to.deep.equal([[404]]);
       expect(sendSpy.callCount).to.equal(1);
-      expect(sendSpy.args).to.deep.equal([[{ status: 404, message: 'Resource not found' }]]);
+      expect(sendSpy.args).to.deep.equal([[{ status: 404, message: 'Resource not found', errorCode: 'NOT_FOUND' }]]);
       expect(response).to.deep.equal({
         status: 404,
-        message: 'Resource not found'
+        message: 'Resource not found',
+        errorCode: 'NOT_FOUND'
       });
 
       sinon.reset();
@@ -134,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);
@@ -143,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');
+    });
+  });
 });