code: function resolveMiddleware (manager, promise, name) {
    if (!manager.middleware.store.has(name)) {
      return promise
    }
  
    return promise
      .then(accumulator => {
        return middleware.resolve(manager, name, accumulator)
      })
      .then(middlewareResult => {
        if (middlewareResult.___resolve === true) {
          middlewareResult.debug(middlewareResult.uid, '- will bypass')
          // doing this until proven wrong :)
          const err = new Error('bypassing middleware')
          err.name = 'bypass'
          err.bypass = true
          err.bypassValue = middlewareResult
          throw err
        }
  
        return middlewareResult
      })
  }
docs: Resolves a middeware, this method contains a 'hack'
  which consists in using an error to bypass the
  chain of promise then that come after it.
  
  If there is a better/faster more elegant way to do this
  then pls let me know and send a PR
  
  @param {Object} manager - dataPoint instance
  @param {Promise} promise - should resolve to the current accumulator
  @param {string} name - name of middleware to execute
  @returns {Promise}