Do not allow for middleware to be inserted twice + made it easier to setup a bearer token and apply it in a header

Author: Kevin Coenegrachts

.gitignore

@@ -2,4 +2,5 @@
 /node_modules
 coverage
 .idea
-lib/
+lib/
+.vscode

README.md

@@ -91,6 +91,8 @@ Devour takes an object as the initializer. The following options are available:
 
 **auth**: An object with username and password, used to pass in HTTP Basic Authentication Headers, `new JsonApi({apiUrl: 'http://your-api-here.com', auth: {username: 'secret', password: 'cheesecake'})`
 
+**bearer**: A string containing the bearer token, used to add a HTTP Authorization Header `new JsonApi({apiUrl: 'http://your-api-here.com', bearer: 'your-token-here'})
+
 **trailingSlash**: An optional object to use trailing slashes on resource and/or collection urls (defaults to false), `new JsonApi({apiUrl: 'http://your-api-here.com', trailingSlash: {resource: false, collection: true})`
 
 ### Relationships
@@ -155,6 +157,7 @@ let errorMiddleware = {
 jsonApi.insertMiddlewareBefore('axios-request', requestMiddleware)
 jsonApi.insertMiddlewareAfter('response', responseMiddleware)
 jsonApi.replaceMiddleware('errors', errorMiddleware)
+jsonApi.removeMiddleware('response')
 ```
 
 #### The payload object

package.json

@@ -5,11 +5,13 @@
   "main": "lib/",
   "scripts": {
     "prepublish": "npm run compile",
+    "prepublish-windows": "npm run compile:windows",
     "publish": "git push origin && git push origin --tags",
     "release:patch": "npm version patch && npm publish",
     "release:minor": "npm version minor && npm publish",
     "release:major": "npm version major && npm publish",
     "compile": "rm -rf lib/ && babel -d lib/ src/",
+    "compile:windows": "rd /s /q \"lib/\" && babel -d lib/ src/",
     "watch": "babel --watch -d lib/ src/",
     "autofix": "standard --fix",
     "test": "standard && mocha"

src/index.js

@@ -36,6 +36,7 @@ const jsonApiDeleteMiddleware = require('./middleware/json-api/req-delete')
 const jsonApiGetMiddleware = require('./middleware/json-api/req-get')
 const jsonApiHeadersMiddleware = require('./middleware/json-api/req-headers')
 const railsParamsSerializer = require('./middleware/json-api/rails-params-serializer')
+const bearerTokenMiddleware = require('./middleware/json-api/req-bearer')
 const sendRequestMiddleware = require('./middleware/request')
 const deserializeResponseMiddleware = require('./middleware/json-api/res-deserialize')
 const errorsMiddleware = require('./middleware/json-api/res-errors')
@@ -56,6 +57,7 @@ class JsonApi {
       jsonApiDeleteMiddleware,
       jsonApiGetMiddleware,
       jsonApiHeadersMiddleware,
+      bearerTokenMiddleware,
       railsParamsSerializer,
       sendRequestMiddleware,
       processErrors,
@@ -66,6 +68,7 @@ class JsonApi {
       logger: true,
       resetBuilderOnCall: true,
       auth: {},
+      bearer: null,
       trailingSlash: {collection: false, resource: false}
     }
 
@@ -89,6 +92,7 @@ class JsonApi {
     this.axios = axios
     this.auth = options.auth
     this.apiUrl = options.apiUrl
+    this.bearer = options.bearer
     this.models = {}
     this.deserialize = deserialize
     this.serialize = serialize
@@ -259,6 +263,11 @@ class JsonApi {
   }
 
   insertMiddleware (middlewareName, direction, newMiddleware) {
+    if (this.middlewareExists(newMiddleware.name)) {
+      Logger.error('The middleware ' + newMiddleware.name + ' already exists')
+      return
+    }
+
     let middleware = this.middleware.filter(middleware => (middleware.name === middlewareName))
     if (middleware.length > 0) {
       let index = this.middleware.indexOf(middleware[0])
@@ -270,10 +279,29 @@ class JsonApi {
   }
 
   replaceMiddleware (middlewareName, newMiddleware) {
+    if (!this.middlewareExists(newMiddleware.name)) {
+      Logger.error('The middleware ' + newMiddleware.name + ' does not exists')
+      return
+    }
+
     let index = _findIndex(this.middleware, ['name', middlewareName])
     this.middleware[index] = newMiddleware
   }
 
+  removeMiddleware (middlewareName) {
+    if (!this.middlewareExists(middlewareName)) {
+      Logger.error('The middleware ' + middlewareName + ' does not exists')
+      return
+    }
+
+    let index = _findIndex(this.middleware, ['name', middlewareName])
+    this.middleware.splice(index, 1)
+  }
+
+  middlewareExists (middlewareName) {
+    return this.middleware.some(middleware => (middleware.name === middlewareName))
+  }
+
   define (modelName, attributes, options = {}) {
     this.models[modelName] = {
       attributes: attributes,

src/middleware/json-api/req-bearer.js

@@ -0,0 +1,12 @@
+const _isNil = require('lodash/isNil')
+const _assign = require('lodash/assign')
+
+module.exports = {
+  name: 'add-bearer-token',
+  req: payload => {
+    if (!_isNil(payload.jsonApi.bearer)) {
+      payload.req.headers = _assign({}, payload.req.headers, {'Authorization': 'Bearer ' + payload.jsonApi.bearer})
+    }
+    return payload
+  }
+}

test/api/api-test.js

@@ -102,6 +102,42 @@ describe('JsonApi', () => {
       jsonApi.one('foo', 1).get().then(() => done())
     })
 
+    it('should allow users to add Authorization header (bearer token)', (done) => {
+      jsonApi = new JsonApi({apiUrl: 'http://myapi.com', bearer: 'abc'})
+      jsonApi.define('foo', {title: ''})
+
+      let inspectorMiddleware = {
+        name: 'inspector-middleware',
+        req: (payload) => {
+          expect(payload.req.headers.Authorization).to.be.eql('Bearer abc')
+          return {}
+        }
+      }
+      const bearerTokenMiddleware = require('./../../src/middleware/json-api/req-bearer')
+
+      jsonApi.middleware = [bearerTokenMiddleware, inspectorMiddleware]
+
+      jsonApi.one('foo', 1).get().then(() => done())
+    })
+
+    it('should not add HTPP Authorization header if not set', (done) => {
+      jsonApi = new JsonApi({apiUrl: 'http://myapi.com'})
+      jsonApi.define('foo', {title: ''})
+
+      let inspectorMiddleware = {
+        name: 'inspector-middleware',
+        req: (payload) => {
+          expect(payload.req.headers).to.be.eql(undefined)
+          return {}
+        }
+      }
+      const bearerTokenMiddleware = require('./../../src/middleware/json-api/req-bearer')
+
+      jsonApi.middleware = [bearerTokenMiddleware, inspectorMiddleware]
+
+      jsonApi.one('foo', 1).get().then(() => done())
+    })
+
     describe('Pluralize options', () => {
       context('no options passed -- default behavior', () => {
         it('should use the pluralize package', () => {
@@ -382,6 +418,42 @@ describe('JsonApi', () => {
       expect(jsonApi.middleware.indexOf(beforeMiddleware)).to.eql(index)
       expect(jsonApi.middleware.indexOf(afterMiddleware)).to.eql(index + 2)
     })
+
+    it('should not allow users to register the same middleware twice', () => {
+      let responseMiddleware = jsonApi.middleware.filter(middleware => middleware.name === 'response')[0]
+      let catMiddleWare = {
+        name: 'cat-middleware',
+        req: function (req) {
+          return req
+        },
+        res: function (res) {
+          return res
+        }
+      }
+      let index = jsonApi.middleware.indexOf(responseMiddleware)
+      jsonApi.insertMiddlewareBefore('response', catMiddleWare)
+      expect(jsonApi.middleware.indexOf(catMiddleWare)).to.eql(index)
+      jsonApi.insertMiddlewareAfter('response', catMiddleWare)
+      expect(jsonApi.middleware.indexOf(catMiddleWare)).to.not.eql(index + 2)
+      expect(jsonApi.middleware.indexOf(catMiddleWare)).to.eql(index)
+    })
+
+    it('should allow users to remove existing middleware', () => {
+      let catMiddleWare = {
+        name: 'cat-middleware',
+        req: function (req) {
+          return req
+        },
+        res: function (res) {
+          return res
+        }
+      }
+      jsonApi.insertMiddlewareBefore('response', catMiddleWare)
+      const middlewareLength = jsonApi.middleware.length
+      jsonApi.removeMiddleware('cat-middleware')
+      expect(jsonApi.middleware.length).to.eql(middlewareLength - 1)
+      expect(jsonApi.middleware.findIndex(middleware => middleware.name === 'cat-middleware')).to.eql(-1)
+    })
   })
 
   describe('Models and serializers', () => {