kuzzle 2.19.2 → 2.19.3

package/lib/api/funnel.js

@@ -19,14 +19,14 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const Bluebird = require('bluebird');
-const Deque = require('denque');
-const Cookie = require('cookie');
+const Bluebird = require("bluebird");
+const Deque = require("denque");
+const Cookie = require("cookie");
 
-const kuzzleStateEnum = require('../kuzzle/kuzzleStateEnum');
-const { KuzzleError } = require('../kerror/errors');
+const kuzzleStateEnum = require("../kuzzle/kuzzleStateEnum");
+const { KuzzleError } = require("../kerror/errors");
 const {
   AdminController,
   AuthController,
@@ -40,20 +40,20 @@ const {
   RealtimeController,
   SecurityController,
   ServerController,
-} = require('./controllers');
-const { documentEventAliases } = require('../config/documentEventAliases');
-const DocumentExtractor = require('./documentExtractor');
-const sdkCompatibility = require('../config/sdkCompatibility');
-const RateLimiter = require('./rateLimiter');
-const kerror = require('../kerror');
+} = require("./controllers");
+const { documentEventAliases } = require("../config/documentEventAliases");
+const DocumentExtractor = require("./documentExtractor");
+const sdkCompatibility = require("../config/sdkCompatibility");
+const RateLimiter = require("./rateLimiter");
+const kerror = require("../kerror");
 
-const debug = require('../util/debug')('kuzzle:funnel');
-const processError = kerror.wrap('api', 'process');
-const { has } = require('../util/safeObject');
+const debug = require("../util/debug")("kuzzle:funnel");
+const processError = kerror.wrap("api", "process");
+const { has } = require("../util/safeObject");
 
 // Actions of the auth controller that does not necessite to verify the token
 // when cookie auth is active
-const SKIP_TOKEN_VERIF_ACTIONS = ['login', 'checkToken', 'logout'];
+const SKIP_TOKEN_VERIF_ACTIONS = ["login", "checkToken", "logout"];
 
 /**
  * @class PendingRequest
@@ -62,7 +62,7 @@ const SKIP_TOKEN_VERIF_ACTIONS = ['login', 'checkToken', 'logout'];
  * @param {Object} context
  */
 class PendingRequest {
-  constructor (request, fn, context) {
+  constructor(request, fn, context) {
     this.request = request;
     this.fn = fn;
     this.context = context;
@@ -73,7 +73,7 @@ class PendingRequest {
  * @class Funnel
  */
 class Funnel {
-  constructor () {
+  constructor() {
     this.overloaded = false;
     this.concurrentRequests = 0;
     this.controllers = new Map();
@@ -90,7 +90,7 @@ class Funnel {
     this.sdkCompatibility = sdkCompatibility;
   }
 
-  init () {
+  init() {
     /**
      * Returns true if the controller is one of Kuzzle native's one
      *
@@ -98,48 +98,47 @@ class Funnel {
      *
      * @returns {Boolean}
      */
-    global.kuzzle.onAsk(
-      'kuzzle:api:funnel:controller:isNative',
-      name => this.isNativeController(name));
+    global.kuzzle.onAsk("kuzzle:api:funnel:controller:isNative", (name) =>
+      this.isNativeController(name)
+    );
 
     /**
      * Returns inner metrics from the Funnel
-     * @returns {Object} 
+     * @returns {Object}
      */
-    global.kuzzle.onAsk(
-      'kuzzle:api:funnel:metrics',
-      () => this.metrics());
+    global.kuzzle.onAsk("kuzzle:api:funnel:metrics", () => this.metrics());
 
     this.rateLimiter.init();
 
-    this.controllers.set('auth', new AuthController());
-    this.controllers.set('bulk', new BulkController());
-    this.controllers.set('cluster', new ClusterController());
-    this.controllers.set('collection', new CollectionController());
-    this.controllers.set('debug', new DebugController());
-    this.controllers.set('document', new DocumentController());
-    this.controllers.set('index', new IndexController());
-    this.controllers.set('realtime', new RealtimeController());
-    this.controllers.set('security', new SecurityController());
-    this.controllers.set('server', new ServerController());
-    this.controllers.set('admin', new AdminController());
+    this.controllers.set("auth", new AuthController());
+    this.controllers.set("bulk", new BulkController());
+    this.controllers.set("cluster", new ClusterController());
+    this.controllers.set("collection", new CollectionController());
+    this.controllers.set("debug", new DebugController());
+    this.controllers.set("document", new DocumentController());
+    this.controllers.set("index", new IndexController());
+    this.controllers.set("realtime", new RealtimeController());
+    this.controllers.set("security", new SecurityController());
+    this.controllers.set("server", new ServerController());
+    this.controllers.set("admin", new AdminController());
 
     const msController = new MemoryStorageController();
-    this.controllers.set('memoryStorage', msController);
-    this.controllers.set('ms', msController);
+    this.controllers.set("memoryStorage", msController);
+    this.controllers.set("ms", msController);
 
-    const initPromises = Array.from(this.controllers.keys())
-      .map(ctrl => this.controllers.get(ctrl).init());
+    const initPromises = Array.from(this.controllers.keys()).map((ctrl) =>
+      this.controllers.get(ctrl).init()
+    );
 
     return Bluebird.all(initPromises);
   }
 
-  loadDocumentEventAliases () {
+  loadDocumentEventAliases() {
     this.documentEventAliases = documentEventAliases;
     this.documentEventAliases.mirrorList = {};
 
-    Object.keys(documentEventAliases.list).forEach(alias => {
-      documentEventAliases.list[alias].forEach(aliasOf => {
+    Object.keys(documentEventAliases.list).forEach((alias) => {
+      documentEventAliases.list[alias].forEach((aliasOf) => {
         this.documentEventAliases.mirrorList[aliasOf] = alias;
       });
     });
@@ -170,35 +169,41 @@ class Funnel {
    * @returns {Boolean} - A boolean telling whether the request has been
    *                      immediately executed or not.
    */
-  throttle (fn, context, request) {
+  throttle(fn, context, request) {
     if (global.kuzzle.state === kuzzleStateEnum.SHUTTING_DOWN) {
-      throw processError.get('shutting_down');
+      throw processError.get("shutting_down");
     }
 
     if (global.kuzzle.state === kuzzleStateEnum.NOT_ENOUGH_NODES) {
-      throw processError.get('not_enough_nodes');
+      throw processError.get("not_enough_nodes");
     }
 
     if (this.overloaded) {
       const now = Date.now();
 
-      if (this.pendingRequestsQueue.length > global.kuzzle.config.limits.requestsBufferWarningThreshold
-        && (this.lastWarningTime === 0 || this.lastWarningTime < now - 500)
+      if (
+        this.pendingRequestsQueue.length >
+          global.kuzzle.config.limits.requestsBufferWarningThreshold &&
+        (this.lastWarningTime === 0 || this.lastWarningTime < now - 500)
       ) {
-        const overloadPercentage = Math.round(
-          10000 *
-            this.pendingRequestsQueue.length /
-            global.kuzzle.config.limits.requestsBufferSize) /
-            100;
-        global.kuzzle.emit('core:overload', overloadPercentage);
-        global.kuzzle.log.warn(`[!WARNING!] Kuzzle overloaded: ${overloadPercentage}%. Delaying requests...`);
+        const overloadPercentage =
+          Math.round(
+            (10000 * this.pendingRequestsQueue.length) /
+              global.kuzzle.config.limits.requestsBufferSize
+          ) / 100;
+        global.kuzzle.emit("core:overload", overloadPercentage);
+        global.kuzzle.log.warn(
+          `[!WARNING!] Kuzzle overloaded: ${overloadPercentage}%. Delaying requests...`
+        );
 
         this.overloadWarned = true;
         this.lastWarningTime = now;
       }
     }
 
-    if (this.concurrentRequests < global.kuzzle.config.limits.concurrentRequests) {
+    if (
+      this.concurrentRequests < global.kuzzle.config.limits.concurrentRequests
+    ) {
       if (this.pendingRequestsById.has(request.internalId)) {
         this.pendingRequestsById.delete(request.internalId);
       }
@@ -218,20 +223,24 @@ class Funnel {
      2- the number of cached requests is equal to the requestsBufferSize property.
      The request is then discarded and an error is returned to the sender
      */
-    if (this.pendingRequestsQueue.length >= global.kuzzle.config.limits.requestsBufferSize) {
-      const error = processError.get('overloaded');
-      global.kuzzle.emit('log:error', error);
+    if (
+      this.pendingRequestsQueue.length >=
+      global.kuzzle.config.limits.requestsBufferSize
+    ) {
+      const error = processError.get("overloaded");
+      global.kuzzle.emit("log:error", error);
       global.kuzzle.log.error(error);
       throw error;
     }
 
-    if (! this.pendingRequestsById.has(request.internalId)) {
+    if (!this.pendingRequestsById.has(request.internalId)) {
       this.pendingRequestsById.set(
         request.internalId,
-        new PendingRequest(request, fn, context));
+        new PendingRequest(request, fn, context)
+      );
       this.pendingRequestsQueue.push(request.internalId);
 
-      if (! this.overloaded) {
+      if (!this.overloaded) {
         this.overloaded = true;
 
         /*
@@ -263,129 +272,180 @@ class Funnel {
    * @param {Function} callback
    * @returns {Number} -1: request delayed, 0: request processing, 1: error
    */
-  execute (request, callback) {
-    if (! request.input.controller || ! request.input.controller.length) {
+  execute(request, callback) {
+    if (!request.input.controller || !request.input.controller.length) {
       callback(
-        kerror.get('api', 'assert', 'missing_argument', 'controller'),
-        request);
+        kerror.get("api", "assert", "missing_argument", "controller"),
+        request
+      );
       return 1;
     }
 
-    if (! request.input.action || ! request.input.action.length) {
+    if (!request.input.action || !request.input.action.length) {
       callback(
-        kerror.get('api', 'assert', 'missing_argument', 'action'),
-        request);
+        kerror.get("api", "assert", "missing_argument", "action"),
+        request
+      );
       return 1;
     }
 
     // If there is a body, retrieve the targets if any
-    const targets = request.getArray('targets', []);
+    const targets = request.getArray("targets", []);
     /**
      * Only index and collection as a pair or the targets parameter is allowed at the same time
      * otherwise we throw an error because we don't know which one to use to verify the rights
      */
-    if ( targets.length > 0
-      && (request.input.args.index
-        || request.input.args.collection)
+    if (
+      targets.length > 0 &&
+      (request.input.args.index || request.input.args.collection)
     ) {
       callback(
-        kerror.get('api', 'assert', 'mutually_exclusive', 'index, collection', 'targets'),
-        request);
+        kerror.get(
+          "api",
+          "assert",
+          "mutually_exclusive",
+          "index, collection",
+          "targets"
+        ),
+        request
+      );
       return 1;
     }
 
-    if (request.input.headers
-      && has(request.input.headers, 'origin')
-      && ! this._isOriginAuthorized(request.input.headers.origin)
+    if (
+      request.input.headers &&
+      has(request.input.headers, "origin") &&
+      !this._isOriginAuthorized(request.input.headers.origin)
     ) {
-      debug('Reject request, unauthorized origin %s', request.input.headers.origin);
+      debug(
+        "Reject request, unauthorized origin %s",
+        request.input.headers.origin
+      );
       return this._executeError(
-        kerror.get('api', 'process', 'unauthorized_origin', request.input.headers.origin),
+        kerror.get(
+          "api",
+          "process",
+          "unauthorized_origin",
+          request.input.headers.origin
+        ),
         request,
         true,
-        callback);
+        callback
+      );
     }
 
     try {
-      const executing = this.throttle(req => {
-        // if the connection is closed there is no need to execute the request
-        // => discarding it
-        if (! global.kuzzle.router.isConnectionAlive(req.context)) {
-          debug('Client connection dead: dropping request: %a', req.input);
-          callback(processError.get('connection_dropped'), req);
-          return;
-        }
-
-        debug('Starting request %s:%s [%s]: %j', req.input.controller, req.input.action, req.id, req.input);
-
-        global.kuzzle.asyncStore.run(() => {
-
-          global.kuzzle.asyncStore.set('REQUEST', req);
-          global.kuzzle.pipe('request:beforeExecution', req)
-            .then(modifiedRequest => {
+      const executing = this.throttle(
+        (req) => {
+          // if the connection is closed there is no need to execute the request
+          // => discarding it
+          if (!global.kuzzle.router.isConnectionAlive(req.context)) {
+            debug("Client connection dead: dropping request: %a", req.input);
+            callback(processError.get("connection_dropped"), req);
+            return;
+          }
 
-              let _request;
+          debug(
+            "Starting request %s:%s [%s]: %j",
+            req.input.controller,
+            req.input.action,
+            req.id,
+            req.input
+          );
 
-              return this.checkRights(modifiedRequest)
-                .then(newModifiedRequest => {
-                  _request = newModifiedRequest;
-                  return this.rateLimiter.isAllowed(_request);
-                })
-                .then(allowed => {
-                  if (! allowed) {
-                    if (request.input.controller === 'auth' && request.input.action === 'login') {
-                      throw processError.get('too_many_logins_requests');
+          global.kuzzle.asyncStore.run(() => {
+            global.kuzzle.asyncStore.set("REQUEST", req);
+            global.kuzzle
+              .pipe("request:beforeExecution", req)
+              .then((modifiedRequest) => {
+                let _request;
+
+                return this.checkRights(modifiedRequest)
+                  .then((newModifiedRequest) => {
+                    _request = newModifiedRequest;
+                    return this.rateLimiter.isAllowed(_request);
+                  })
+                  .then((allowed) => {
+                    if (!allowed) {
+                      if (
+                        request.input.controller === "auth" &&
+                        request.input.action === "login"
+                      ) {
+                        throw processError.get("too_many_logins_requests");
+                      }
+                      throw processError.get("too_many_requests");
                     }
-                    throw processError.get('too_many_requests');
-                  }
-
-                  return this.processRequest(_request);
-                })
-                .then(processResult => {
-                  debug('Request %s successfully executed. Result: %a',
-                    modifiedRequest.id,
-                    processResult);
-
-                  return global.kuzzle.pipe(
-                    'request:afterExecution',
-                    { 
-                      request: _request,
-                      result: processResult,
-                      success: true,
-                    })
-                    .then(pipeEvent => { 
-                      callback(null, pipeEvent.result);
-
-                      // disables a bluebird warning in dev. mode triggered when
-                      // a promise is created and not returned
-                      return null;
-                    });
-                }).catch(err => {
-                  debug('Error processing request %s: %a', modifiedRequest.id, err);
-                  return global.kuzzle.pipe(
-                    'request:afterExecution',
-                    {
-                      error: err,
-                      request: modifiedRequest,
-                      success: false,
-                    }).then(pipeEvent => this._executeError(pipeEvent.error, pipeEvent.request, true, callback));
-                });
-            })
-            .catch(err => {
-              debug('Error processing request %s: %a', req.id, err);
-              return global.kuzzle.pipe('request:afterExecution',
-                {
-                  error: err,
-                  request: req,
-                  success: false,
-                }).then(pipeEvent => this._executeError(pipeEvent.error, pipeEvent.request, true, callback));
-            });
-        });
-      }, this, request);
+
+                    return this.processRequest(_request);
+                  })
+                  .then((processResult) => {
+                    debug(
+                      "Request %s successfully executed. Result: %a",
+                      modifiedRequest.id,
+                      processResult
+                    );
+
+                    return global.kuzzle
+                      .pipe("request:afterExecution", {
+                        request: _request,
+                        result: processResult,
+                        success: true,
+                      })
+                      .then((pipeEvent) => {
+                        callback(null, pipeEvent.result);
+
+                        // disables a bluebird warning in dev. mode triggered when
+                        // a promise is created and not returned
+                        return null;
+                      });
+                  })
+                  .catch((err) => {
+                    debug(
+                      "Error processing request %s: %a",
+                      modifiedRequest.id,
+                      err
+                    );
+                    return global.kuzzle
+                      .pipe("request:afterExecution", {
+                        error: err,
+                        request: modifiedRequest,
+                        success: false,
+                      })
+                      .then((pipeEvent) =>
+                        this._executeError(
+                          pipeEvent.error,
+                          pipeEvent.request,
+                          true,
+                          callback
+                        )
+                      );
+                  });
+              })
+              .catch((err) => {
+                debug("Error processing request %s: %a", req.id, err);
+                return global.kuzzle
+                  .pipe("request:afterExecution", {
+                    error: err,
+                    request: req,
+                    success: false,
+                  })
+                  .then((pipeEvent) =>
+                    this._executeError(
+                      pipeEvent.error,
+                      pipeEvent.request,
+                      true,
+                      callback
+                    )
+                  );
+              });
+          });
+        },
+        this,
+        request
+      );
 
       return executing ? 0 : -1;
-    }
-    catch (error) {
+    } catch (error) {
       request.setError(error);
       callback(error, request);
       return 1;
@@ -398,14 +458,13 @@ class Funnel {
    *
    * @param {KuzzleError|*} err
    */
-  handleErrorDump (err) {
+  handleErrorDump(err) {
     const handledErrors = global.kuzzle.config.dump.handledErrors;
 
     if (global.kuzzle.config.dump.enabled && handledErrors.enabled) {
       setImmediate(() => {
-        const errorType = typeof err === 'object' && err.name ?
-          err.name :
-          typeof err;
+        const errorType =
+          typeof err === "object" && err.name ? err.name : typeof err;
 
         if (handledErrors.whitelist.indexOf(errorType) > -1) {
           const now = Date.now();
@@ -413,28 +472,32 @@ class Funnel {
           // JSON.stringify(new NativeError()) === '{}'
           // i.e. Error, SyntaxError, TypeError, ReferenceError, etc.
           global.kuzzle.log.error(
-            err instanceof Error && ! (err instanceof KuzzleError)
+            err instanceof Error && !(err instanceof KuzzleError)
               ? `${err.message}\n${err.stack}`
-              : err);
+              : err
+          );
 
-          if (! this.lastDumpedErrors[errorType]
-            || this.lastDumpedErrors[errorType] < now - handledErrors.minInterval
+          if (
+            !this.lastDumpedErrors[errorType] ||
+            this.lastDumpedErrors[errorType] < now - handledErrors.minInterval
           ) {
             // simplify error message to use it in folder dump name
             let errorMessage = err.message;
 
-            if (errorMessage.indexOf('\n') > -1) {
-              errorMessage = errorMessage.split('\n')[0];
+            if (errorMessage.indexOf("\n") > -1) {
+              errorMessage = errorMessage.split("\n")[0];
             }
 
             errorMessage = errorMessage
               .toLowerCase()
-              .replace(/[^a-zA-Z0-9-_]/g, '-')
-              .split('-')
-              .filter(value => value !== '')
-              .join('-');
-
-            global.kuzzle.dump(`handled-${errorType.toLocaleLowerCase()}-${errorMessage}`);
+              .replace(/[^a-zA-Z0-9-_]/g, "-")
+              .split("-")
+              .filter((value) => value !== "")
+              .join("-");
+
+            global.kuzzle.dump(
+              `handled-${errorType.toLocaleLowerCase()}-${errorMessage}`
+            );
           }
 
           this.lastDumpedErrors[errorType] = now;
@@ -449,15 +512,12 @@ class Funnel {
    * @param {Request} request
    * @returns {Promise<Request>}
    */
-  async checkRights (request) {
-    if ( ! global.kuzzle.config.http.cookieAuthentication
-      && request.getBoolean('cookieAuth')
+  async checkRights(request) {
+    if (
+      !global.kuzzle.config.http.cookieAuthentication &&
+      request.getBoolean("cookieAuth")
     ) {
-      throw kerror.get(
-        'security',
-        'cookie',
-        'unsupported'
-      );
+      throw kerror.get("security", "cookie", "unsupported");
     }
 
     let skipTokenVerification = false;
@@ -465,35 +525,35 @@ class Funnel {
     // When a request is made with cookieAuth set to true
     // We try to use the auth token cookie if present as auth token
     // otherwise check for auth token as input
-    if (request.input.headers && has(request.input.headers, 'cookie')) {
+    if (request.input.headers && has(request.input.headers, "cookie")) {
       let cookie;
       try {
         cookie = Cookie.parse(request.input.headers.cookie);
-      }
-      catch (error) {
-        throw kerror.get('security', 'cookie', 'invalid');
+      } catch (error) {
+        throw kerror.get("security", "cookie", "invalid");
       }
 
       // if cookie is present and not null, and a token is present we should throw because we don't know which one to use
-      if (cookie.authToken && cookie.authToken !== 'null') {
-        if (! global.kuzzle.config.http.cookieAuthentication) {
-          throw kerror.get('security', 'cookie', 'unsupported');
+      if (cookie.authToken && cookie.authToken !== "null") {
+        if (!global.kuzzle.config.http.cookieAuthentication) {
+          throw kerror.get("security", "cookie", "unsupported");
         }
 
         if (request.input.jwt) {
           throw kerror.get(
-            'security',
-            'token',
-            'verification_error',
-            'Both token and cookie are present, could not decide which one to use'
+            "security",
+            "token",
+            "verification_error",
+            "Both token and cookie are present, could not decide which one to use"
           );
         }
 
         request.input.jwt = cookie.authToken;
 
-        skipTokenVerification = request.getBoolean('cookieAuth')
-          && request.input.controller === 'auth'
-          && SKIP_TOKEN_VERIF_ACTIONS.includes(request.input.action);
+        skipTokenVerification =
+          request.getBoolean("cookieAuth") &&
+          request.input.controller === "auth" &&
+          SKIP_TOKEN_VERIF_ACTIONS.includes(request.input.action);
       }
     }
 
@@ -503,58 +563,68 @@ class Funnel {
       const token = skipTokenVerification ? null : request.input.jwt;
 
       request.context.token = await global.kuzzle.ask(
-        'core:security:token:verify',
-        token);
-    }
-    catch (error) {
-      await global.kuzzle.pipe('request:onUnauthorized', request);
+        "core:security:token:verify",
+        token
+      );
+    } catch (error) {
+      await global.kuzzle.pipe("request:onUnauthorized", request);
       throw error;
     }
 
     const userId = request.context.token.userId;
 
     request.context.user = await global.kuzzle.ask(
-      'core:security:user:get',
-      userId);
+      "core:security:user:get",
+      userId
+    );
 
     // If we have a token, link the connection with the token,
     // this way the connection can be notified when the token has expired.
-    if (global.kuzzle.config.internal.notifiableProtocols.includes(request.context.connection.protocol)) {
+    if (
+      global.kuzzle.config.internal.notifiableProtocols.includes(
+        request.context.connection.protocol
+      )
+    ) {
       global.kuzzle.tokenManager.link(
         request.context.token,
-        request.context.connection.id);
+        request.context.connection.id
+      );
     }
 
-    if (! await request.context.user.isActionAllowed(request)) {
+    if (!(await request.context.user.isActionAllowed(request))) {
       // anonymous user => 401 (Unauthorized) error
       // logged-in user with insufficient permissions => 403 (Forbidden) error
       const error = kerror.get(
-        'security',
-        'rights',
-        userId === '-1' ? 'unauthorized' : 'forbidden',
+        "security",
+        "rights",
+        userId === "-1" ? "unauthorized" : "forbidden",
         request.input.controller,
         request.input.action,
-        request.context.user._id);
+        request.context.user._id
+      );
 
       request.setError(error);
 
-      await global.kuzzle.pipe('request:onUnauthorized', request);
+      await global.kuzzle.pipe("request:onUnauthorized", request);
       throw error;
     }
 
-    if ( global.kuzzle.config.plugins.common.failsafeMode
-      && ! this._isLogin(request)
-      && ! request.context.user.profileIds.includes('admin')
+    if (
+      global.kuzzle.config.plugins.common.failsafeMode &&
+      !this._isLogin(request) &&
+      !request.context.user.profileIds.includes("admin")
     ) {
-      await global.kuzzle.pipe('request:onUnauthorized', request);
-      throw kerror.get('security', 'rights', 'failsafe_mode_admin_only');
+      await global.kuzzle.pipe("request:onUnauthorized", request);
+      throw kerror.get("security", "rights", "failsafe_mode_admin_only");
     }
 
-    return global.kuzzle.pipe('request:onAuthorized', request);
+    return global.kuzzle.pipe("request:onAuthorized", request);
   }
 
-  _isLogin (request) {
-    return request.input.controller === 'auth' && request.input.action === 'login';
+  _isLogin(request) {
+    return (
+      request.input.controller === "auth" && request.input.action === "login"
+    );
   }
 
   /**
@@ -564,7 +634,7 @@ class Funnel {
    * @param {Request} request
    * @returns {Promise}
    */
-  async processRequest (request) {
+  async processRequest(request) {
     const controller = this.getController(request);
 
     global.kuzzle.statistics.startRequest(request);
@@ -574,40 +644,42 @@ class Funnel {
 
     try {
       await this._checkSdkVersion(_request);
-      _request = await this.performDocumentAlias(_request, 'before');
+      _request = await this.performDocumentAlias(_request, "before");
       _request = await global.kuzzle.pipe(
-        this.getEventName(_request, 'before'),
-        _request);
+        this.getEventName(_request, "before"),
+        _request
+      );
 
       const responseData = await doAction(controller, _request);
 
-      _request.setResult(
-        responseData,
-        { status: _request.status === 102 ? 200 : _request.status });
+      _request.setResult(responseData, {
+        status: _request.status === 102 ? 200 : _request.status,
+      });
 
-      if (! this.isNativeController(_request.input.controller) && ! _request.response.raw) {
+      if (
+        !this.isNativeController(_request.input.controller) &&
+        !_request.response.raw
+      ) {
         // check if the plugin response can be serialized
         try {
           JSON.stringify(responseData);
-        }
-        catch (e) {
+        } catch (e) {
           _request.setResult(null);
-          throw kerror.get('plugin', 'controller', 'unserializable_response');
+          throw kerror.get("plugin", "controller", "unserializable_response");
         }
       }
 
       _request = await global.kuzzle.pipe(
-        this.getEventName(_request, 'after'),
-        _request);
+        this.getEventName(_request, "after"),
+        _request
+      );
 
-      _request = await this.performDocumentAlias(_request, 'after');
-      _request = await global.kuzzle.pipe('request:onSuccess', _request);
+      _request = await this.performDocumentAlias(_request, "after");
+      _request = await global.kuzzle.pipe("request:onSuccess", _request);
       global.kuzzle.statistics.completedRequest(_request);
-    }
-    catch (error) {
+    } catch (error) {
       return this.handleProcessRequestError(_request, _request, error);
-    }
-    finally {
+    } finally {
       this.concurrentRequests--;
     }
 
@@ -624,23 +696,29 @@ class Funnel {
    *
    * @returns {Promise<KuzzleRequest>}
    */
-  async performDocumentAlias (request, prefix) {
+  async performDocumentAlias(request, prefix) {
     const { controller, action } = request.input;
     const mustTrigger =
-      controller === 'document'
-      && this.documentEventAliases.mirrorList[action]
-      && ( prefix !== 'before'
-        || ! this.documentEventAliases.notBefore.includes(action));
+      controller === "document" &&
+      this.documentEventAliases.mirrorList[action] &&
+      (prefix !== "before" ||
+        !this.documentEventAliases.notBefore.includes(action));
 
-    if (! mustTrigger) {
+    if (!mustTrigger) {
       return request;
     }
 
     const alias = this.documentEventAliases.mirrorList[action];
-    const event = `${this.documentEventAliases.namespace}:${prefix}${capitalize(alias)}`;
+    const event = `${this.documentEventAliases.namespace}:${prefix}${capitalize(
+      alias
+    )}`;
     const extractor = new DocumentExtractor(request);
 
-    const documents = await global.kuzzle.pipe(event, extractor.extract(), request);
+    const documents = await global.kuzzle.pipe(
+      event,
+      extractor.extract(),
+      request
+    );
 
     return extractor.insert(documents);
   }
@@ -656,24 +734,24 @@ class Funnel {
    * @param {Request} request
    * @returns {Promise}
    */
-  async executePluginRequest (request) {
+  async executePluginRequest(request) {
     try {
       return await doAction(this.getController(request), request);
-    }
-    catch (e) {
+    } catch (e) {
       this.handleErrorDump(e);
       throw e;
     }
   }
 
-  async handleProcessRequestError (modifiedRequest, request, error) {
+  async handleProcessRequestError(modifiedRequest, request, error) {
     let _error = this._wrapError(request, error);
     modifiedRequest.setError(_error);
 
     try {
       const updated = await global.kuzzle.pipe(
-        this.getEventName(modifiedRequest, 'error'),
-        modifiedRequest);
+        this.getEventName(modifiedRequest, "error"),
+        modifiedRequest
+      );
 
       // If there is no pipe attached on this event, the same request is
       // passed in resolve and we should reject it
@@ -682,8 +760,7 @@ class Funnel {
       }
       // Pipe recovered from the error: returned the new result
       return updated;
-    }
-    catch (err) {
+    } catch (err) {
       _error = this._wrapError(request, err);
     }
 
@@ -692,15 +769,17 @@ class Funnel {
     global.kuzzle.statistics.failedRequest(request);
 
     try {
-      const updated = await global.kuzzle.pipe('request:onError', modifiedRequest);
+      const updated = await global.kuzzle.pipe(
+        "request:onError",
+        modifiedRequest
+      );
 
       if (updated === modifiedRequest) {
         throw modifiedRequest.error;
       }
 
       return updated;
-    }
-    catch (err) {
+    } catch (err) {
       throw this._wrapError(request, err);
     }
   }
@@ -713,10 +792,10 @@ class Funnel {
    * @param {string} prefix - event prefix
    * @returns {string} event name
    */
-  getEventName (request, prefix) {
+  getEventName(request, prefix) {
     const event =
-      request.input.controller === 'memoryStorage'
-        ? 'ms'
+      request.input.controller === "memoryStorage"
+        ? "ms"
         : request.input.controller;
 
     return `${event}:${prefix}${capitalize(request.input.action)}`;
@@ -727,7 +806,7 @@ class Funnel {
    *
    * @returns {number}
    */
-  get remainingRequests () {
+  get remainingRequests() {
     return this.concurrentRequests + this.pendingRequestsQueue.length;
   }
 
@@ -738,8 +817,11 @@ class Funnel {
    * @returns {Object} controller object
    * @throws {BadRequestError} If the asked controller or action is unknown
    */
-  getController (request) {
-    for (const controllers of [this.controllers, global.kuzzle.pluginsManager.controllers]) {
+  getController(request) {
+    for (const controllers of [
+      this.controllers,
+      global.kuzzle.pluginsManager.controllers,
+    ]) {
       const controller = controllers.get(request.input.controller);
 
       if (controller) {
@@ -747,11 +829,15 @@ class Funnel {
           return controller;
         }
 
-        throw processError.get('action_not_found', request.input.controller, request.input.action);
+        throw processError.get(
+          "action_not_found",
+          request.input.controller,
+          request.input.action
+        );
       }
     }
 
-    throw processError.get('controller_not_found', request.input.controller);
+    throw processError.get("controller_not_found", request.input.controller);
   }
 
   /**
@@ -759,7 +845,7 @@ class Funnel {
    * @param  {String}  controller
    * @returns {Boolean}
    */
-  isNativeController (controller) {
+  isNativeController(controller) {
     return this.controllers.has(controller);
   }
 
@@ -767,7 +853,7 @@ class Funnel {
    * Returns inner metrics from the Funnel
    * @returns {Object}
    */
-  metrics () {
+  metrics() {
     return {
       concurrentRequests: this.concurrentRequests,
       pendingRequests: this.pendingRequestsQueue.length,
@@ -782,25 +868,29 @@ class Funnel {
    *
    * @throws
    */
-  _checkSdkVersion (request) {
-    if (! global.kuzzle.config.server.strictSdkVersion) {
+  _checkSdkVersion(request) {
+    if (!global.kuzzle.config.server.strictSdkVersion) {
       return;
     }
 
-    const sdkVersion = request.input.volatile && request.input.volatile.sdkVersion;
+    const sdkVersion =
+      request.input.volatile && request.input.volatile.sdkVersion;
     const sdkName = request.input.volatile && request.input.volatile.sdkName;
 
     // sdkVersion property is only used by Kuzzle v1 SDKs
     if (sdkVersion) {
-      throw processError.get('incompatible_sdk_version', sdkVersion, 'Kuzzle v2');
+      throw processError.get(
+        "incompatible_sdk_version",
+        sdkVersion,
+        "Kuzzle v2"
+      );
     }
 
-    if (! sdkName || typeof sdkName !== 'string') {
+    if (!sdkName || typeof sdkName !== "string") {
       return;
     }
 
-    const
-      separatorIdx = sdkName.indexOf('@'),
+    const separatorIdx = sdkName.indexOf("@"),
       name = sdkName.substr(0, separatorIdx),
       version = sdkName.substr(separatorIdx + 1);
 
@@ -809,14 +899,16 @@ class Funnel {
     }
 
     const requirements = this.sdkCompatibility[name];
-    if (! requirements) {
+    if (!requirements) {
       return;
     }
 
-    if (! satisfiesMajor(version, requirements)) {
-      const hint = `min: ${requirements.min || 'none'}, max: ${requirements.max || 'none'}`;
+    if (!satisfiesMajor(version, requirements)) {
+      const hint = `min: ${requirements.min || "none"}, max: ${
+        requirements.max || "none"
+      }`;
 
-      throw processError.get('incompatible_sdk_version', version, hint);
+      throw processError.get("incompatible_sdk_version", version, hint);
     }
   }
 
@@ -830,14 +922,13 @@ class Funnel {
    * @returns {null}
    * @private
    */
-  _executeError (error, request, asError, callback) {
+  _executeError(error, request, asError, callback) {
     request.setError(error);
 
     if (asError) {
       callback(error, request);
       this.handleErrorDump(error);
-    }
-    else {
+    } else {
       callback(null, request);
     }
 
@@ -848,26 +939,32 @@ class Funnel {
    * Background task. Checks if there are any requests in cache, and replay them
    * if Kuzzle is not overloaded anymore,
    */
-  _playPendingRequests () {
+  _playPendingRequests() {
     // If there is room to play bufferized requests, do it now. If not, retry later
     const quantityToInject = Math.min(
       this.pendingRequestsQueue.length,
-      global.kuzzle.config.limits.concurrentRequests - this.concurrentRequests);
+      global.kuzzle.config.limits.concurrentRequests - this.concurrentRequests
+    );
 
     if (quantityToInject > 0) {
       for (let i = 0; i < quantityToInject; i++) {
-        const pendingItem =
-          this.pendingRequestsById.get(this.pendingRequestsQueue.peekFront());
+        const pendingItem = this.pendingRequestsById.get(
+          this.pendingRequestsQueue.peekFront()
+        );
 
         try {
-          if (this.throttle(pendingItem.fn, pendingItem.context, pendingItem.request)) {
+          if (
+            this.throttle(
+              pendingItem.fn,
+              pendingItem.context,
+              pendingItem.request
+            )
+          ) {
             this.pendingRequestsQueue.shift();
-          }
-          else {
+          } else {
             break;
           }
-        }
-        catch (error) {
+        } catch (error) {
           break;
         }
       }
@@ -875,17 +972,19 @@ class Funnel {
 
     if (this.pendingRequestsQueue.length > 0) {
       setTimeout(() => this._playPendingRequests(), 0);
-    }
-    else {
+    } else {
       const now = Date.now();
       // No request remaining in cache => stop the background task and return to normal behavior
       this.overloaded = false;
 
-      if ( this.overloadWarned
-        && (this.lastOverloadTime === 0 || this.lastOverloadTime < now - 500)
+      if (
+        this.overloadWarned &&
+        (this.lastOverloadTime === 0 || this.lastOverloadTime < now - 500)
       ) {
         this.overloadWarned = false;
-        global.kuzzle.log.info('End of overloaded state. Resuming normal activity.');
+        global.kuzzle.log.info(
+          "End of overloaded state. Resuming normal activity."
+        );
         this.lastOverloadTime = now;
       }
     }
@@ -897,14 +996,15 @@ class Funnel {
    * @param  {Error} error
    * @returns {KuzzleError}
    */
-  _wrapError (request, error) {
-    if (! this.isNativeController(request) && ! (error instanceof KuzzleError)) {
+  _wrapError(request, error) {
+    if (!this.isNativeController(request) && !(error instanceof KuzzleError)) {
       return kerror.getFrom(
         error,
-        'plugin',
-        'runtime',
-        'unexpected_error',
-        error.message);
+        "plugin",
+        "runtime",
+        "unexpected_error",
+        error.message
+      );
     }
 
     return error;
@@ -915,10 +1015,10 @@ class Funnel {
    * @param {string} origin
    * @returns
    */
-  _isOriginAuthorized (origin) {
+  _isOriginAuthorized(origin) {
     const httpConfig = global.kuzzle.config.http;
 
-    if (! origin) {
+    if (!origin) {
       return true;
     }
 
@@ -943,7 +1043,7 @@ class Funnel {
  * @param {string} string
  * @returns {string}
  */
-function capitalize (string) {
+function capitalize(string) {
   return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
@@ -958,16 +1058,17 @@ function capitalize (string) {
  * @param  {Request} request
  * @returns {Promise}
  */
-function doAction (controller, request) {
+function doAction(controller, request) {
   const ret = controller[request.input.action](request);
 
-  if (! ret || typeof ret.then !== 'function') {
+  if (!ret || typeof ret.then !== "function") {
     return kerror.reject(
-      'plugin',
-      'controller',
-      'invalid_action_response',
+      "plugin",
+      "controller",
+      "invalid_action_response",
       request.input.controller,
-      request.input.action);
+      request.input.action
+    );
   }
 
   return ret;
@@ -982,9 +1083,8 @@ function doAction (controller, request) {
  *
  * @returns {Boolean}
  */
-function satisfiesMajor (version, requirements) {
-  let
-    maxRequirement = true,
+function satisfiesMajor(version, requirements) {
+  let maxRequirement = true,
     minRequirement = true;
 
   if (requirements.min) {
@@ -998,5 +1098,4 @@ function satisfiesMajor (version, requirements) {
   return maxRequirement && minRequirement;
 }
 
-
 module.exports = Funnel;