kuzzle 2.19.2 → 2.19.3

package/lib/core/plugin/pluginsManager.js

@@ -19,39 +19,42 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const assert = require('assert');
-const path = require('path');
-const fs = require('fs');
+const assert = require("assert");
+const path = require("path");
+const fs = require("fs");
 
-const Bluebird = require('bluebird');
-const _ = require('lodash');
+const Bluebird = require("bluebird");
+const _ = require("lodash");
 
-const kerror = require('../../kerror');
-const didYouMean = require('../../util/didYouMean');
-const { Inflector } = require('../../util/inflector');
-const debug = require('../../util/debug')('kuzzle:plugins');
-const { KuzzleError } = require('../../kerror/errors');
-const { has, get, isPlainObject } = require('../../util/safeObject');
-const { BaseController } = require('../../api/controllers/baseController');
-const Plugin = require('./plugin');
+const kerror = require("../../kerror");
+const didYouMean = require("../../util/didYouMean");
+const { Inflector } = require("../../util/inflector");
+const debug = require("../../util/debug")("kuzzle:plugins");
+const { KuzzleError } = require("../../kerror/errors");
+const { has, get, isPlainObject } = require("../../util/safeObject");
+const { BaseController } = require("../../api/controllers/baseController");
+const Plugin = require("./plugin");
 
-const assertionError = kerror.wrap('plugin', 'assert');
-const runtimeError = kerror.wrap('plugin', 'runtime');
-const strategyError = kerror.wrap('plugin', 'strategy');
-const controllerError = kerror.wrap('plugin', 'controller');
+const assertionError = kerror.wrap("plugin", "assert");
+const runtimeError = kerror.wrap("plugin", "runtime");
+const strategyError = kerror.wrap("plugin", "strategy");
+const controllerError = kerror.wrap("plugin", "controller");
 
 // Without those plugins, Kuzzle won't start at all.
-const CORE_PLUGINS = ['kuzzle-plugin-logger', 'kuzzle-plugin-auth-passport-local'];
+const CORE_PLUGINS = [
+  "kuzzle-plugin-logger",
+  "kuzzle-plugin-auth-passport-local",
+];
 
 /**
  * @class PluginsManager
  * @param {Kuzzle} kuzzle
  */
 class PluginsManager {
-  constructor () {
-    Reflect.defineProperty(this, 'kuzzle', {
+  constructor() {
+    Reflect.defineProperty(this, "kuzzle", {
       value: global.kuzzle,
     });
 
@@ -64,9 +67,11 @@ class PluginsManager {
     this.routes = [];
 
     this.pluginsEnabledDir = path.resolve(
-      path.join(global.kuzzle.rootPath, 'plugins', 'enabled'));
+      path.join(global.kuzzle.rootPath, "plugins", "enabled")
+    );
     this.pluginsAvailableDir = path.resolve(
-      path.join(global.kuzzle.rootPath, 'plugins', 'available'));
+      path.join(global.kuzzle.rootPath, "plugins", "available")
+    );
 
     /**
      * @example
@@ -90,26 +95,37 @@ class PluginsManager {
 
     // @deprecated - Warn about the pipeTimeout configuration being obsolete
     if (this.config.common.pipeTimeout) {
-      global.kuzzle.log.warn('The configuration "plugins.common.pipeTimeout" has been deprecated and is now unused. It can be safely removed from configuration files');
+      global.kuzzle.log.warn(
+        'The configuration "plugins.common.pipeTimeout" has been deprecated and is now unused. It can be safely removed from configuration files'
+      );
     }
 
     this.loadedPlugins = [];
   }
 
-  set application (plugin) {
-    assert(this._plugins.size === 0, 'The application plugin can only be set before every other plugins are loaded');
-    assert(plugin.application, 'The application plugin must have the "application" property equals to true');
+  set application(plugin) {
+    assert(
+      this._plugins.size === 0,
+      "The application plugin can only be set before every other plugins are loaded"
+    );
+    assert(
+      plugin.application,
+      'The application plugin must have the "application" property equals to true'
+    );
 
     this._plugins.set(plugin.name, plugin);
   }
 
-  get plugins () {
-    return Array.from(this._plugins.values())
-      .filter(plugin => ! plugin.application);
+  get plugins() {
+    return Array.from(this._plugins.values()).filter(
+      (plugin) => !plugin.application
+    );
   }
 
-  get application () {
-    return Array.from(this._plugins.values()).find(plugin => plugin.application);
+  get application() {
+    return Array.from(this._plugins.values()).find(
+      (plugin) => plugin.application
+    );
   }
 
   /**
@@ -118,7 +134,7 @@ class PluginsManager {
    * @param {string} controller
    * @returns {Boolean}
    */
-  isController (controller) {
+  isController(controller) {
     return this.controllers.has(controller);
   }
 
@@ -129,7 +145,7 @@ class PluginsManager {
    * @param {string} action
    * @returns {Boolean}
    */
-  isAction (controller, action) {
+  isAction(controller, action) {
     return this.getActions(controller).includes(action);
   }
 
@@ -139,7 +155,7 @@ class PluginsManager {
    * @param {string} controller
    * @returns {Array}
    */
-  getActions (controller) {
+  getActions(controller) {
     return Array.from(this.controllers.get(controller)._actions);
   }
 
@@ -148,7 +164,7 @@ class PluginsManager {
    *
    * @returns {Array}
    */
-  getControllerNames () {
+  getControllerNames() {
     return Array.from(this.controllers.keys());
   }
 
@@ -159,7 +175,7 @@ class PluginsManager {
    * @returns {boolean}
    */
 
-  exists (pluginName) {
+  exists(pluginName) {
     return this._plugins.has(pluginName);
   }
 
@@ -168,13 +184,17 @@ class PluginsManager {
    *
    * @returns {object}
    */
-  getPluginsDescription () {
+  getPluginsDescription() {
     const pluginsDescription = {};
 
     for (const plugin of this.plugins) {
       pluginsDescription[plugin.name] = plugin.info();
 
-      debug('[%s] reading plugin configuration: %a', plugin, pluginsDescription[plugin.name]);
+      debug(
+        "[%s] reading plugin configuration: %a",
+        plugin,
+        pluginsDescription[plugin.name]
+      );
     }
 
     return pluginsDescription;
@@ -187,25 +207,32 @@ class PluginsManager {
    *
    * @throws PluginImplementationError - Throws when an error occurs when registering a plugin
    */
-  init (plugins = {}) {
-    this._plugins = new Map([
-      ...this.loadPlugins(plugins),
-      ...this._plugins]);
+  init(plugins = {}) {
+    this._plugins = new Map([...this.loadPlugins(plugins), ...this._plugins]);
 
-    global.kuzzle.on('plugin:hook:loop-error', ({ error, pluginName }) => {
-      global.kuzzle.log.error(`[${pluginName}] Infinite loop detected on event "hook:onError": ${error}`);
+    global.kuzzle.on("plugin:hook:loop-error", ({ error, pluginName }) => {
+      global.kuzzle.log.error(
+        `[${pluginName}] Infinite loop detected on event "hook:onError": ${error}`
+      );
     });
 
-    global.kuzzle.on('hook:onError', ({ error, event, pluginName }) => {
-      global.kuzzle.log.error(`[${pluginName}] Error executing hook on "${event}": ${error}${error.stack}`);
+    global.kuzzle.on("hook:onError", ({ error, event, pluginName }) => {
+      global.kuzzle.log.error(
+        `[${pluginName}] Error executing hook on "${event}": ${error}${error.stack}`
+      );
     });
 
     // register regular plugins features
     const loadPlugins = [];
 
     for (const plugin of this._plugins.values()) {
-      if (this.config.common.failsafeMode && ! CORE_PLUGINS.includes(plugin.name)) {
-        global.kuzzle.log.info(`Failsafe mode activated, skipping plugin "${plugin.name}"`);
+      if (
+        this.config.common.failsafeMode &&
+        !CORE_PLUGINS.includes(plugin.name)
+      ) {
+        global.kuzzle.log.info(
+          `Failsafe mode activated, skipping plugin "${plugin.name}"`
+        );
         continue;
       }
 
@@ -218,53 +245,59 @@ class PluginsManager {
       debug(
         '[%s] starting plugin in "%s" mode',
         plugin.name,
-        plugin.config.privileged ? 'privileged' : 'standard');
+        plugin.config.privileged ? "privileged" : "standard"
+      );
 
-      const promise = Bluebird
-        .resolve((async () => {
+      const promise = Bluebird.resolve(
+        (async () => {
           try {
             await plugin.instance.init(plugin.config, plugin.context);
+          } catch (error) {
+            throw runtimeError.get("failed_init", plugin.name, error);
           }
-          catch (error) {
-            throw runtimeError.get('failed_init', plugin.name, error);
-          }
-        })())
-        .timeout(initTimeout, `${plugin.logPrefix} Initialization timed out after ${initTimeout}ms. Try to increase the configuration "plugins.common.initTimeout".`)
+        })()
+      )
+        .timeout(
+          initTimeout,
+          `${plugin.logPrefix} Initialization timed out after ${initTimeout}ms. Try to increase the configuration "plugins.common.initTimeout".`
+        )
         .then(async () => {
           plugin.initCalled = true;
 
-          if ( ! _.isEmpty(plugin.instance.controllers)
-            && ! _.isEmpty(plugin.instance.api)) {
-            throw assertionError.get('duplicated_api_definition');
+          if (
+            !_.isEmpty(plugin.instance.controllers) &&
+            !_.isEmpty(plugin.instance.api)
+          ) {
+            throw assertionError.get("duplicated_api_definition");
           }
 
-          if (! _.isEmpty(plugin.instance.controllers)) {
+          if (!_.isEmpty(plugin.instance.controllers)) {
             this._initControllers(plugin);
           }
 
-          if (! _.isEmpty(plugin.instance.api)) {
+          if (!_.isEmpty(plugin.instance.api)) {
             await this._initApi(plugin);
           }
 
-          if (! _.isEmpty(plugin.instance.authenticators)) {
+          if (!_.isEmpty(plugin.instance.authenticators)) {
             this._initAuthenticators(plugin);
           }
 
-          if (! _.isEmpty(plugin.instance.strategies)) {
+          if (!_.isEmpty(plugin.instance.strategies)) {
             this._initStrategies(plugin);
           }
 
-          if (! _.isEmpty(plugin.instance.hooks)) {
+          if (!_.isEmpty(plugin.instance.hooks)) {
             this._initHooks(plugin);
           }
 
-          if (! _.isEmpty(plugin.instance.pipes)) {
+          if (!_.isEmpty(plugin.instance.pipes)) {
             this._initPipes(plugin);
           }
 
-          debug('[%s] plugin started', plugin.name);
+          debug("[%s] plugin started", plugin.name);
 
-          if (! plugin.application) {
+          if (!plugin.application) {
             this.loadedPlugins.push(plugin.name);
           }
 
@@ -281,7 +314,7 @@ class PluginsManager {
    * @param {string} strategyName
    * @returns {string[]}
    */
-  getStrategyFields (strategyName) {
+  getStrategyFields(strategyName) {
     return this.strategies[strategyName].strategy.config.fields || [];
   }
 
@@ -290,7 +323,7 @@ class PluginsManager {
    * @param {string} methodName
    * @returns {boolean}
    */
-  hasStrategyMethod (strategyName, methodName) {
+  hasStrategyMethod(strategyName, methodName) {
     const strategy = get(this.strategies, strategyName);
     return strategy && has(strategy.methods, methodName);
   }
@@ -300,7 +333,7 @@ class PluginsManager {
    * @param {string} methodName
    * @returns {function}
    */
-  getStrategyMethod (strategyName, methodName) {
+  getStrategyMethod(strategyName, methodName) {
     return this.strategies[strategyName].methods[methodName];
   }
 
@@ -308,7 +341,7 @@ class PluginsManager {
    * Returns the list of registered passport strategies
    * @returns {string[]}
    */
-  listStrategies () {
+  listStrategies() {
     return Object.keys(this.strategies);
   }
 
@@ -320,88 +353,108 @@ class PluginsManager {
    * @param {object} strategy
    * @throws {PluginImplementationError} If the strategy is invalid
    */
-  validateStrategy (pluginName, strategyName, strategy) {
+  validateStrategy(pluginName, strategyName, strategy) {
     const errorPrefix = `[${pluginName}] Strategy ${strategyName}:`;
 
-    if (! isPlainObject(strategy)) {
-      throw strategyError.get('invalid_description', errorPrefix, strategy);
+    if (!isPlainObject(strategy)) {
+      throw strategyError.get("invalid_description", errorPrefix, strategy);
     }
 
-    if (! isPlainObject(strategy.methods)) {
-      throw strategyError.get('invalid_methods', errorPrefix, strategy.methods);
+    if (!isPlainObject(strategy.methods)) {
+      throw strategyError.get("invalid_methods", errorPrefix, strategy.methods);
     }
 
     const plugin = this._plugins.get(pluginName.toLowerCase());
 
     // required methods check
-    ['exists', 'create', 'update', 'delete', 'validate', 'verify'].forEach(methodName => {
-      if (! _.isString(strategy.methods[methodName])) {
-        throw strategyError.get(
-          'invalid_method_type',
-          errorPrefix,
-          methodName,
-          strategy.methods[methodName]);
-      }
+    ["exists", "create", "update", "delete", "validate", "verify"].forEach(
+      (methodName) => {
+        if (!_.isString(strategy.methods[methodName])) {
+          throw strategyError.get(
+            "invalid_method_type",
+            errorPrefix,
+            methodName,
+            strategy.methods[methodName]
+          );
+        }
 
-      if (! _.isFunction(plugin.instance[strategy.methods[methodName]])) {
-        throw strategyError.get(
-          'missing_method_function',
-          errorPrefix,
-          strategy.methods[methodName]);
+        if (!_.isFunction(plugin.instance[strategy.methods[methodName]])) {
+          throw strategyError.get(
+            "missing_method_function",
+            errorPrefix,
+            strategy.methods[methodName]
+          );
+        }
       }
-    });
+    );
 
     // optional methods check
-    ['getInfo', 'getById', 'afterRegister'].forEach(name => {
+    ["getInfo", "getById", "afterRegister"].forEach((name) => {
       const optionalMethodName = strategy.methods[name];
 
-      if (! _.isNil(optionalMethodName)) {
-        if (! _.isString(optionalMethodName)) {
+      if (!_.isNil(optionalMethodName)) {
+        if (!_.isString(optionalMethodName)) {
           throw strategyError.get(
-            'invalid_method_type',
+            "invalid_method_type",
             errorPrefix,
             name,
-            optionalMethodName);
+            optionalMethodName
+          );
         }
 
-        if (! _.isFunction(plugin.instance[optionalMethodName])) {
+        if (!_.isFunction(plugin.instance[optionalMethodName])) {
           throw strategyError.get(
-            'missing_method_function',
+            "missing_method_function",
             errorPrefix,
-            optionalMethodName);
+            optionalMethodName
+          );
         }
       }
     });
 
-    if (! isPlainObject(strategy.config)) {
-      throw strategyError.get('invalid_config', errorPrefix, strategy.config);
+    if (!isPlainObject(strategy.config)) {
+      throw strategyError.get("invalid_config", errorPrefix, strategy.config);
     }
 
-    if (typeof strategy.config.authenticator !== 'string') {
+    if (typeof strategy.config.authenticator !== "string") {
       throw strategyError.get(
-        'invalid_authenticator',
+        "invalid_authenticator",
         errorPrefix,
-        strategy.config.authenticator);
-    }
-    else if (! this.authenticators[pluginName]
-      || ! this.authenticators[pluginName][strategy.config.authenticator]
+        strategy.config.authenticator
+      );
+    } else if (
+      !this.authenticators[pluginName] ||
+      !this.authenticators[pluginName][strategy.config.authenticator]
     ) {
       throw strategyError.get(
-        'unknown_authenticator',
+        "unknown_authenticator",
         errorPrefix,
-        strategy.config.authenticator);
+        strategy.config.authenticator
+      );
     }
 
-    for (const optionName of ['strategyOptions', 'authenticateOptions']) {
+    for (const optionName of ["strategyOptions", "authenticateOptions"]) {
       const options = strategy.config[optionName];
 
-      if (! _.isNil(options) && ! isPlainObject(options)) {
-        throw strategyError.get('invalid_option', errorPrefix, optionName, options);
+      if (!_.isNil(options) && !isPlainObject(options)) {
+        throw strategyError.get(
+          "invalid_option",
+          errorPrefix,
+          optionName,
+          options
+        );
       }
     }
 
-    if (! _.isNil(strategy.config.fields) && ! Array.isArray(strategy.config.fields)) {
-      throw strategyError.get('invalid_fields', errorPrefix, strategy.config.fields);
+    if (
+      !_.isNil(strategy.config.fields) &&
+      !Array.isArray(strategy.config.fields)
+    ) {
+      throw strategyError.get(
+        "invalid_fields",
+        errorPrefix,
+        strategy.config.fields
+      );
     }
   }
 
@@ -415,12 +468,13 @@ class PluginsManager {
    *
    * @returns {string} pipeId
    */
-  registerPipe (plugin, event, handler) {
+  registerPipe(plugin, event, handler) {
     debug('[%s] registering pipe on event "%s"', plugin.name, event);
 
-    const warnDelay = plugin.config.pipeWarnTime !== undefined
-      ? plugin.config.pipeWarnTime
-      : this.config.common.pipeWarnTime;
+    const warnDelay =
+      plugin.config.pipeWarnTime !== undefined
+        ? plugin.config.pipeWarnTime
+        : this.config.common.pipeWarnTime;
 
     const wrapper = (...data) => {
       const now = warnDelay ? Date.now() : null;
@@ -431,7 +485,9 @@ class PluginsManager {
           const elapsed = Date.now() - now;
 
           if (elapsed > warnDelay) {
-            global.kuzzle.log.warn(`${plugin.logPrefix} pipe for event '${event}' is slow (${elapsed}ms)`);
+            global.kuzzle.log.warn(
+              `${plugin.logPrefix} pipe for event '${event}' is slow (${elapsed}ms)`
+            );
           }
         }
 
@@ -439,34 +495,35 @@ class PluginsManager {
       };
 
       try {
-        const pipeResponse = data.length === 0
-          ? handler(null, cb)
-          : handler(...data, cb);
-
-        if ( typeof pipeResponse === 'object'
-          && pipeResponse !== null
-          && typeof pipeResponse.then === 'function'
-          && typeof pipeResponse.catch === 'function'
+        const pipeResponse =
+          data.length === 0 ? handler(null, cb) : handler(...data, cb);
+
+        if (
+          typeof pipeResponse === "object" &&
+          pipeResponse !== null &&
+          typeof pipeResponse.then === "function" &&
+          typeof pipeResponse.catch === "function"
         ) {
           pipeResponse
-            .then(result => {
+            .then((result) => {
               cb(null, result);
               return null; // prevents a false-positive bluebird warning
             })
-            .catch(error => cb(error));
+            .catch((error) => cb(error));
         }
-      }
-      catch (error) {
-        cb(error instanceof KuzzleError
-          ? error
-          : runtimeError.getFrom(error, 'unexpected_error', error.message));
+      } catch (error) {
+        cb(
+          error instanceof KuzzleError
+            ? error
+            : runtimeError.getFrom(error, "unexpected_error", error.message)
+        );
       }
     };
 
     return global.kuzzle.registerPluginPipe(event, wrapper);
   }
 
-  unregisterPipe (pipeId) {
+  unregisterPipe(pipeId) {
     global.kuzzle.unregisterPluginPipe(pipeId);
   }
 
@@ -481,13 +538,13 @@ class PluginsManager {
    * @throws {PluginImplementationError} If the strategy is invalid or if
    *                                     registration fails
    */
-  registerStrategy (pluginName, strategyName, strategy) {
+  registerStrategy(pluginName, strategyName, strategy) {
     // prior to Kaaf, plugin names can contains upper case
     const plugin = this._plugins.get(pluginName.toLowerCase());
 
     // only add the strategy to the strategies object if the init method
     // has not been called
-    if (! plugin.initCalled) {
+    if (!plugin.initCalled) {
       plugin.instance.strategies = plugin.instance.strategies || {};
       plugin.instance.strategies[strategyName] = strategy;
 
@@ -506,56 +563,58 @@ class PluginsManager {
     // convert uncaught exception into PluginImplementationError
     // promise rejections
     for (const methodName of Object.keys(strategy.methods).filter(
-      name => name !== 'verify')
-    ) {
+      (name) => name !== "verify"
+    )) {
       methods[methodName] = async (...args) => {
         try {
-          const boundFunction = plugin.instance[strategy.methods[methodName]]
-            .bind(plugin.instance);
+          const boundFunction = plugin.instance[
+            strategy.methods[methodName]
+          ].bind(plugin.instance);
 
           return await boundFunction(...args);
-        }
-        catch (error) {
+        } catch (error) {
           if (error instanceof KuzzleError) {
             throw error;
           }
 
-          throw runtimeError.getFrom(error, 'unexpected_error', error.message);
+          throw runtimeError.getFrom(error, "unexpected_error", error.message);
         }
       };
     }
 
     const opts = {
       ...strategy.config.strategyOptions,
-      passReqToCallback: true
+      passReqToCallback: true,
     };
 
     const verifyAdapter = this.wrapStrategyVerify(
       plugin.logPrefix,
       strategyName,
-      plugin.instance[strategy.methods.verify].bind(plugin.instance));
+      plugin.instance[strategy.methods.verify].bind(plugin.instance)
+    );
 
     try {
-      const
-        Ctor = this.authenticators[plugin.name][strategy.config.authenticator],
+      const Ctor =
+          this.authenticators[plugin.name][strategy.config.authenticator],
         instance = new Ctor(opts, verifyAdapter);
 
       this.strategies[strategyName] = { methods, owner: plugin.name, strategy };
       global.kuzzle.passport.use(
         strategyName,
         instance,
-        strategy.config.authenticateOptions);
+        strategy.config.authenticateOptions
+      );
 
       if (methods.afterRegister) {
         methods.afterRegister(instance);
       }
-    }
-    catch (e) {
+    } catch (e) {
       throw strategyError.getFrom(
         e,
-        'failed_registration',
+        "failed_registration",
         strategyName,
-        e.message);
+        e.message
+      );
     }
   }
 
@@ -566,19 +625,18 @@ class PluginsManager {
    * @throws {PluginImplementationError} If not the owner of the strategy or if strategy
    *                                     does not exist
    */
-  unregisterStrategy (pluginName, strategyName) {
+  unregisterStrategy(pluginName, strategyName) {
     const strategy = this.strategies[strategyName];
 
     if (strategy) {
       if (strategy.owner !== pluginName) {
-        throw strategyError.get('unauthorized_removal', strategyName);
+        throw strategyError.get("unauthorized_removal", strategyName);
       }
 
       delete this.strategies[strategyName];
       global.kuzzle.passport.unuse(strategyName);
-    }
-    else {
-      throw strategyError.get('strategy_not_found', strategyName);
+    } else {
+      throw strategyError.get("strategy_not_found", strategyName);
     }
   }
 
@@ -586,35 +644,37 @@ class PluginsManager {
    * @param {object} plugin
    * @param {number} pipeWarnTime
    */
-  _initPipes (plugin) {
+  _initPipes(plugin) {
     const methodsList = getMethods(plugin.instance);
 
     for (const [event, fn] of Object.entries(plugin.instance.pipes)) {
       const list = Array.isArray(fn) ? fn : [fn];
 
       for (const target of list) {
-        if ( typeof target !== 'function'
-          && typeof plugin.instance[target] !== 'function'
+        if (
+          typeof target !== "function" &&
+          typeof plugin.instance[target] !== "function"
         ) {
-          const message = typeof target === 'string'
-            ? didYouMean(target, methodsList)
-            : '';
+          const message =
+            typeof target === "string" ? didYouMean(target, methodsList) : "";
 
-          throw assertionError.get('invalid_pipe', event, target, message);
+          throw assertionError.get("invalid_pipe", event, target, message);
         }
 
         let handler = target;
 
-        if (typeof target === 'string') {
+        if (typeof target === "string") {
           // @deprecated - warn about using a string representing an instance method
-          plugin.printDeprecation('Defining pipe handler using a string is deprecated. Pass a function instead.');
+          plugin.printDeprecation(
+            "Defining pipe handler using a string is deprecated. Pass a function instead."
+          );
 
           handler = plugin.instance[target].bind(plugin.instance);
         }
 
         // if the function handler is a plugin instance method,
         // bound the context to the plugin instance
-        if (target.name && typeof plugin.instance[target.name] === 'function') {
+        if (target.name && typeof plugin.instance[target.name] === "function") {
           handler = target.bind(plugin.instance);
         }
 
@@ -626,21 +686,21 @@ class PluginsManager {
   /**
    * @param {object} plugin
    */
-  _initHooks (plugin) {
+  _initHooks(plugin) {
     const methodsList = getMethods(plugin.instance);
 
     for (const [event, fn] of Object.entries(plugin.instance.hooks)) {
       const list = Array.isArray(fn) ? fn : [fn];
 
       for (const target of list) {
-        if ( typeof target !== 'function'
-          && typeof plugin.instance[target] !== 'function'
+        if (
+          typeof target !== "function" &&
+          typeof plugin.instance[target] !== "function"
         ) {
-          const message = typeof target === 'string'
-            ? didYouMean(target, methodsList)
-            : '';
+          const message =
+            typeof target === "string" ? didYouMean(target, methodsList) : "";
 
-          throw assertionError.get('invalid_hook', event, target, message);
+          throw assertionError.get("invalid_hook", event, target, message);
         }
 
         debug('[%s] register hook on event "%s"', plugin.name, event);
@@ -648,15 +708,17 @@ class PluginsManager {
         let handler = target;
 
         // @deprecated - warn about using a string representing an instance method
-        if (typeof target === 'string') {
-          plugin.printDeprecation('Defining hook handler using a string is deprecated. Pass a function instead.');
+        if (typeof target === "string") {
+          plugin.printDeprecation(
+            "Defining hook handler using a string is deprecated. Pass a function instead."
+          );
 
           handler = plugin.instance[target].bind(plugin.instance);
         }
 
         // if the function handler is a plugin instance method,
         // bound the context to the plugin instance
-        if (target.name && typeof plugin.instance[target.name] === 'function') {
+        if (target.name && typeof plugin.instance[target.name] === "function") {
           handler = target.bind(plugin.instance);
         }
 
@@ -665,26 +727,37 @@ class PluginsManager {
     }
   }
 
-  async _initApi (plugin) {
-    for (const [controller, definition] of Object.entries(plugin.instance.api)) {
+  async _initApi(plugin) {
+    for (const [controller, definition] of Object.entries(
+      plugin.instance.api
+    )) {
       debug(
-        '[%s][%s] starting api controller registration',
+        "[%s][%s] starting api controller registration",
         plugin.name,
-        controller);
-
-      if (await global.kuzzle.ask('kuzzle:api:funnel:controller:isNative', controller)) {
+        controller
+      );
+
+      if (
+        await global.kuzzle.ask(
+          "kuzzle:api:funnel:controller:isNative",
+          controller
+        )
+      ) {
         throw assertionError.get(
-          'invalid_controller_definition',
+          "invalid_controller_definition",
           controller,
-          'Native controllers cannot be overriden');
+          "Native controllers cannot be overriden"
+        );
       }
 
       Plugin.checkControllerDefinition(controller, definition);
 
-      for (const [action, actionDefinition ] of Object.entries(definition.actions)) {
+      for (const [action, actionDefinition] of Object.entries(
+        definition.actions
+      )) {
         let apiController = this.controllers.get(controller);
 
-        if (! apiController) {
+        if (!apiController) {
           apiController = new BaseController();
           this.controllers.set(controller, apiController);
         }
@@ -693,7 +766,10 @@ class PluginsManager {
 
         // if the function handler is a plugin instance method,
         // bind the context to the plugin instance
-        if (handler.name && typeof plugin.instance[handler.name] === 'function') {
+        if (
+          handler.name &&
+          typeof plugin.instance[handler.name] === "function"
+        ) {
           handler = handler.bind(plugin.instance);
         }
 
@@ -703,12 +779,12 @@ class PluginsManager {
 
         // Define default HTTP route if none have been provided
         if (httpRoutes.length === 0) {
-          httpRoutes.push(
-            {
-              path: `${Inflector.kebabCase(controller)}/${Inflector.kebabCase(action)}`,
-              verb: 'get',
-            }
-          );
+          httpRoutes.push({
+            path: `${Inflector.kebabCase(controller)}/${Inflector.kebabCase(
+              action
+            )}`,
+            verb: "get",
+          });
         }
 
         for (const httpRoute of httpRoutes) {
@@ -716,18 +792,20 @@ class PluginsManager {
             '[%s] binding HTTP route "%s" to controller "%s"',
             plugin.name,
             httpRoute.path,
-            controller);
+            controller
+          );
 
-          const routePath = httpRoute.path.charAt(0) === '/'
-            ? httpRoute.path
-            : `/_/${httpRoute.path}`;
+          const routePath =
+            httpRoute.path.charAt(0) === "/"
+              ? httpRoute.path
+              : `/_/${httpRoute.path}`;
 
           this.routes.push({
             action,
             controller,
             openapi: httpRoute.openapi,
             path: routePath,
-            verb: httpRoute.verb
+            verb: httpRoute.verb,
           });
         }
       }
@@ -740,130 +818,161 @@ class PluginsManager {
    * @param {object} plugin
    * @returns {boolean}
    */
-  _initControllers (plugin) {
+  _initControllers(plugin) {
     // @deprecated - warn about using the obsolete "controllers" object
-    if (! _.isEmpty(plugin.instance.controllers)) {
-      plugin.printDeprecation('Defining controllers using the "controllers" object is deprecated. You should use the "api" object instead.');
+    if (!_.isEmpty(plugin.instance.controllers)) {
+      plugin.printDeprecation(
+        'Defining controllers using the "controllers" object is deprecated. You should use the "api" object instead.'
+      );
     }
 
     for (const controller of Object.keys(plugin.instance.controllers)) {
       debug(
-        '[%s][%s] starting controller registration',
+        "[%s][%s] starting controller registration",
         plugin.name,
-        controller);
+        controller
+      );
 
       const methodsList = getMethods(plugin.instance);
       const controllerName = `${plugin.name}/${controller}`;
       const definition = plugin.instance.controllers[controller];
       const errorControllerPrefix = `Unable to inject controller "${controller}" from plugin "${plugin.name}":`;
 
-      if (! isPlainObject(definition)) {
+      if (!isPlainObject(definition)) {
         // @todo deprecate all those errors and use plugin.assert.invalid_controller_definition
         throw controllerError.get(
-          'invalid_description',
+          "invalid_description",
           errorControllerPrefix,
-          typeof definition);
+          typeof definition
+        );
       }
 
       for (const action of Object.keys(definition)) {
         debug(
-          '[%s][%s][%s] starting action controller registration',
+          "[%s][%s][%s] starting action controller registration",
           plugin.name,
           controller,
-          action);
+          action
+        );
 
-        if ( typeof definition[action] !== 'function'
-          && typeof plugin.instance[definition[action]] !== 'function'
+        if (
+          typeof definition[action] !== "function" &&
+          typeof plugin.instance[definition[action]] !== "function"
         ) {
-          const suggestion = typeof definition[action] === 'string'
-            ? didYouMean(definition[action], methodsList)
-            : '';
+          const suggestion =
+            typeof definition[action] === "string"
+              ? didYouMean(definition[action], methodsList)
+              : "";
 
           throw controllerError.get(
-            'invalid_action',
+            "invalid_action",
             errorControllerPrefix,
             controller,
             action,
-            suggestion);
+            suggestion
+          );
         }
 
         let apiController = this.controllers.get(controllerName);
 
-        if (! apiController) {
+        if (!apiController) {
           apiController = new BaseController();
           this.controllers.set(controllerName, apiController);
         }
 
-        if (typeof definition[action] === 'function') {
+        if (typeof definition[action] === "function") {
           apiController._addAction(action, definition[action]);
-        }
-        else {
+        } else {
           apiController._addAction(
             action,
-            plugin.instance[definition[action]].bind(plugin.instance));
+            plugin.instance[definition[action]].bind(plugin.instance)
+          );
         }
       }
     }
 
-    const httpVerbs = ['get', 'head', 'post', 'put', 'delete', 'patch', 'options'];
-    const routeProperties = ['verb', 'url', 'controller', 'action', 'path'];
+    const httpVerbs = [
+      "get",
+      "head",
+      "post",
+      "put",
+      "delete",
+      "patch",
+      "options",
+    ];
+    const routeProperties = ["verb", "url", "controller", "action", "path"];
     const controllerNames = Object.keys(plugin.instance.controllers);
 
     // @deprecated - warn about using the obsolete "routes" object
-    if (! _.isEmpty(plugin.instance.routes)) {
-      plugin.printDeprecation('Defining routes using the "routes" object is deprecated. You should use the "api" object instead.');
+    if (!_.isEmpty(plugin.instance.routes)) {
+      plugin.printDeprecation(
+        'Defining routes using the "routes" object is deprecated. You should use the "api" object instead.'
+      );
     }
 
-    for (const route of (plugin.instance.routes || [])) {
+    for (const route of plugin.instance.routes || []) {
       const controller = `${plugin.name}/${route.controller}`;
-      const errorRoutePrefix = `Unable to inject API route "${JSON.stringify(route)}" from plugin "${plugin.name}":`;
+      const errorRoutePrefix = `Unable to inject API route "${JSON.stringify(
+        route
+      )}" from plugin "${plugin.name}":`;
 
       for (const key of Object.keys(route)) {
         if (routeProperties.indexOf(key) === -1) {
           throw controllerError.get(
-            'unexpected_route_property',
+            "unexpected_route_property",
             errorRoutePrefix,
             key,
-            didYouMean(key, routeProperties));
+            didYouMean(key, routeProperties)
+          );
         }
 
-        if ( typeof route[key] !== 'string'
-          || route[key].length === 0 && key !== 'url'
+        if (
+          typeof route[key] !== "string" ||
+          (route[key].length === 0 && key !== "url")
         ) {
-          throw controllerError.get('invalid_route_property', errorRoutePrefix, key);
+          throw controllerError.get(
+            "invalid_route_property",
+            errorRoutePrefix,
+            key
+          );
         }
       }
 
       const apiController = this.controllers.get(controller);
 
-      if (! apiController) {
+      if (!apiController) {
         throw controllerError.get(
-          'undefined_controller',
+          "undefined_controller",
           errorRoutePrefix,
           route.controller,
-          didYouMean(route.controller, controllerNames));
+          didYouMean(route.controller, controllerNames)
+        );
       }
 
-      if (! apiController._isAction(route.action)) {
+      if (!apiController._isAction(route.action)) {
         const actionNames = Array.from(apiController._actions);
         throw controllerError.get(
-          'undefined_action',
+          "undefined_action",
           errorRoutePrefix,
           route.action,
-          didYouMean(route.action, actionNames));
+          didYouMean(route.action, actionNames)
+        );
       }
 
       if (httpVerbs.indexOf(route.verb.toLowerCase()) === -1) {
         throw controllerError.get(
-          'unsupported_verb',
+          "unsupported_verb",
           errorRoutePrefix,
-          httpVerbs.join(', '),
-          didYouMean(route.verb, httpVerbs));
+          httpVerbs.join(", "),
+          didYouMean(route.verb, httpVerbs)
+        );
       }
 
       // @deprecated route.url is deprecated
       if (route.url) {
-        plugin.printDeprecation('Usage of "url" property for routes is deprecated. Use "path" instead.');
+        plugin.printDeprecation(
+          'Usage of "url" property for routes is deprecated. Use "path" instead.'
+        );
       }
       route.path = route.path || route.url;
 
@@ -871,25 +980,27 @@ class PluginsManager {
         '[%s] binding HTTP route "%s" to controller "%s"',
         plugin.name,
         route.path,
-        route.controller);
+        route.controller
+      );
 
       // @deprecated "/_plugin" prefix is deprecated for plugin routes
       this.routes.push({
         action: route.action,
         controller,
         path: `/_plugin/${plugin.name}${route.path}`,
-        verb: route.verb
+        verb: route.verb,
       });
 
-      const routePath = route.path.charAt(0) === '/'
-        ? `/_${route.path}`
-        : `/_/${plugin.name}/${route.path}`;
+      const routePath =
+        route.path.charAt(0) === "/"
+          ? `/_${route.path}`
+          : `/_/${plugin.name}/${route.path}`;
 
       this.routes.push({
         action: route.action,
         controller,
         path: routePath,
-        verb: route.verb
+        verb: route.verb,
       });
     }
   }
@@ -898,18 +1009,20 @@ class PluginsManager {
    * @param {object} plugin
    * @throws {PluginImplementationError} If strategies registration fails
    */
-  _initStrategies (plugin) {
-    if ( ! isPlainObject(plugin.instance.strategies)
-      || _.isEmpty(plugin.instance.strategies)
+  _initStrategies(plugin) {
+    if (
+      !isPlainObject(plugin.instance.strategies) ||
+      _.isEmpty(plugin.instance.strategies)
     ) {
-      throw strategyError.get('invalid_definition', plugin.logPrefix);
+      throw strategyError.get("invalid_definition", plugin.logPrefix);
     }
 
     for (const name of Object.keys(plugin.instance.strategies)) {
       this.registerStrategy(
         plugin.name,
         name,
-        plugin.instance.strategies[name]);
+        plugin.instance.strategies[name]
+      );
     }
   }
 
@@ -917,25 +1030,32 @@ class PluginsManager {
    * @param {object} plugin
    * @throws {PluginImplementationError} If strategies registration fails
    */
-  _initAuthenticators (plugin) {
-    if (! isPlainObject(plugin.instance.authenticators)) {
-      throw kerror.get('plugin', 'authenticators', 'not_an_object', plugin.logPrefix);
+  _initAuthenticators(plugin) {
+    if (!isPlainObject(plugin.instance.authenticators)) {
+      throw kerror.get(
+        "plugin",
+        "authenticators",
+        "not_an_object",
+        plugin.logPrefix
+      );
     }
 
     for (const authenticator of Object.keys(plugin.instance.authenticators)) {
-      if (! isConstructor(plugin.instance.authenticators[authenticator])) {
+      if (!isConstructor(plugin.instance.authenticators[authenticator])) {
         throw kerror.get(
-          'plugin',
-          'authenticators',
-          'invalid_authenticator',
+          "plugin",
+          "authenticators",
+          "invalid_authenticator",
           plugin.logPrefix,
-          authenticator);
+          authenticator
+        );
       }
     }
 
     this.authenticators[plugin.name] = Object.assign(
       {},
-      plugin.instance.authenticators);
+      plugin.instance.authenticators
+    );
   }
 
   /**
@@ -943,11 +1063,13 @@ class PluginsManager {
    *
    * @returns {object} list of loaded plugin
    */
-  loadPlugins (plugins = {}) {
+  loadPlugins(plugins = {}) {
     const loadedPlugins = new Map();
 
     // first load plugins from Backend.plugin.use
-    for (const [name, { plugin: instance, options }] of Object.entries(plugins)) {
+    for (const [name, { plugin: instance, options }] of Object.entries(
+      plugins
+    )) {
       const plugin = new Plugin(instance, { name, ...options });
 
       // the plugin cluster can be loaded in the startup script
@@ -957,32 +1079,33 @@ class PluginsManager {
       plugin.init(name);
 
       if (loadedPlugins.has(plugin.name)) {
-        throw assertionError.get('name_already_exists', plugin.name);
+        throw assertionError.get("name_already_exists", plugin.name);
       }
 
       loadedPlugins.set(plugin.name, plugin);
     }
 
     // then try to load plugins from the filesystem
-    if (! fs.existsSync(this.pluginsEnabledDir)) {
+    if (!fs.existsSync(this.pluginsEnabledDir)) {
       return loadedPlugins;
     }
 
     let pluginsPath = [];
 
     try {
-      pluginsPath = fs.readdirSync(this.pluginsEnabledDir)
-        .map(name => path.join(this.pluginsEnabledDir, name))
-        .filter(filePath => fs.statSync(filePath).isDirectory());
-    }
-    catch (e) {
+      pluginsPath = fs
+        .readdirSync(this.pluginsEnabledDir)
+        .map((name) => path.join(this.pluginsEnabledDir, name))
+        .filter((filePath) => fs.statSync(filePath).isDirectory());
+    } catch (e) {
       throw assertionError.get(
-        'invalid_plugins_dir',
+        "invalid_plugins_dir",
         this.pluginsEnabledDir,
-        e.message);
+        e.message
+      );
     }
 
-    debug('loading plugins: %a', pluginsPath);
+    debug("loading plugins: %a", pluginsPath);
 
     for (const relativePluginPath of pluginsPath) {
       const plugin = Plugin.loadFromDirectory(relativePluginPath);
@@ -990,7 +1113,7 @@ class PluginsManager {
       plugin.init(plugin.manifest.raw.name);
 
       if (loadedPlugins.has(plugin.name)) {
-        throw assertionError.get('name_already_exists', plugin.name);
+        throw assertionError.get("name_already_exists", plugin.name);
       }
 
       loadedPlugins.set(plugin.name, plugin);
@@ -1007,7 +1130,7 @@ class PluginsManager {
    * @param {Function} verifyMethod - Strategy plugin's verify method
    * @returns {Function}
    */
-  wrapStrategyVerify (pluginName, strategyName, verifyMethod) {
+  wrapStrategyVerify(pluginName, strategyName, verifyMethod) {
     const prefix = `${pluginName} Strategy ${strategyName}:`;
 
     return async (...args) => {
@@ -1016,8 +1139,8 @@ class PluginsManager {
 
       // catching plugins returning non-thenable content
       // @todo - with async/await we might consider allowing non-promise results
-      if (! ret || ! _.isFunction(ret.then)) {
-        callback(strategyError.get('invalid_verify_return', prefix, ret));
+      if (!ret || !_.isFunction(ret.then)) {
+        callback(strategyError.get("invalid_verify_return", prefix, ret));
         return;
       }
 
@@ -1025,8 +1148,7 @@ class PluginsManager {
 
       try {
         result = await ret;
-      }
-      catch (e) {
+      } catch (e) {
         callback(e);
         return;
       }
@@ -1036,25 +1158,24 @@ class PluginsManager {
         return;
       }
 
-      if (! isPlainObject(result)) {
-        callback(strategyError.get('invalid_verify_resolve', prefix));
+      if (!isPlainObject(result)) {
+        callback(strategyError.get("invalid_verify_resolve", prefix));
         return;
       }
 
       if (result.kuid !== null && result.kuid !== undefined) {
-        if (typeof result.kuid === 'string') {
+        if (typeof result.kuid === "string") {
           try {
             const user = await global.kuzzle.ask(
-              'core:security:user:get',
-              result.kuid);
+              "core:security:user:get",
+              result.kuid
+            );
 
             callback(null, user);
-          }
-          catch (e) {
-            if (e.id === 'security.user.not_found') {
-              callback(strategyError.get('unknown_kuid', prefix));
-            }
-            else {
+          } catch (e) {
+            if (e.id === "security.user.not_found") {
+              callback(strategyError.get("unknown_kuid", prefix));
+            } else {
               callback(e);
             }
           }
@@ -1062,15 +1183,14 @@ class PluginsManager {
           return;
         }
 
-        callback(strategyError.get('invalid_kuid', prefix, typeof result.kuid));
+        callback(strategyError.get("invalid_kuid", prefix, typeof result.kuid));
         return;
       }
 
       let message;
-      if (result.message && typeof result.message === 'string') {
+      if (result.message && typeof result.message === "string") {
         message = result.message;
-      }
-      else {
+      } else {
         message = `Unable to log in using the strategy "${strategyName}"`;
       }
 
@@ -1085,25 +1205,26 @@ class PluginsManager {
  * @param  {*} arg
  * @returns {Boolean}
  */
-function isConstructor (arg) {
+function isConstructor(arg) {
   try {
     Reflect.construct(Object, [], arg);
-  }
-  catch (e) {
+  } catch (e) {
     return false;
   }
 
   return true;
 }
 
-function getMethods (object) {
+function getMethods(object) {
   const prototype = Object.getPrototypeOf(object);
 
-  const instanceMethods = Object.getOwnPropertyNames(prototype)
-    .filter(method => ['init', 'constructor'].indexOf(method) === -1);
+  const instanceMethods = Object.getOwnPropertyNames(prototype).filter(
+    (method) => ["init", "constructor"].indexOf(method) === -1
+  );
 
-  const objectMethods = Object.getOwnPropertyNames(object)
-    .filter(key => typeof object[key] === 'function');
+  const objectMethods = Object.getOwnPropertyNames(object).filter(
+    (key) => typeof object[key] === "function"
+  );
 
   return [...instanceMethods, ...objectMethods];
 }