kuzzle 2.19.2 → 2.19.3

package/lib/api/controllers/authController.js

@@ -19,23 +19,23 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const { IncomingMessage } = require('http');
-const Cookie = require('cookie');
+const { IncomingMessage } = require("http");
+const Cookie = require("cookie");
 
-const Bluebird = require('bluebird');
-const { isEmpty } = require('lodash');
+const Bluebird = require("bluebird");
+const { isEmpty } = require("lodash");
 
-const { KuzzleError } = require('../../kerror/errors');
-const { KuzzleRequest } = require('../request');
-const kerror = require('../../kerror');
-const { has } = require('../../util/safeObject');
-const { NativeController } = require('./baseController');
-const formatProcessing = require('../../core/auth/formatProcessing');
-const { User } = require('../../model/security/user');
-const ApiKey = require('../../model/storage/apiKey');
-const SecurityController = require('./securityController');
+const { KuzzleError } = require("../../kerror/errors");
+const { KuzzleRequest } = require("../request");
+const kerror = require("../../kerror");
+const { has } = require("../../util/safeObject");
+const { NativeController } = require("./baseController");
+const formatProcessing = require("../../core/auth/formatProcessing");
+const { User } = require("../../model/security/user");
+const ApiKey = require("../../model/storage/apiKey");
+const SecurityController = require("./securityController");
 
 /**
  * @class AuthController
@@ -45,26 +45,26 @@ class AuthController extends NativeController {
    * @param {Kuzzle} kuzzle
    * @constructor
    */
-  constructor () {
+  constructor() {
     super([
-      'checkRights',
-      'checkToken',
-      'createApiKey',
-      'createMyCredentials',
-      'credentialsExist',
-      'deleteApiKey',
-      'deleteMyCredentials',
-      'getCurrentUser',
-      'getMyCredentials',
-      'getMyRights',
-      'getStrategies',
-      'login',
-      'logout',
-      'refreshToken',
-      'searchApiKeys',
-      'updateMyCredentials',
-      'updateSelf',
-      'validateMyCredentials',
+      "checkRights",
+      "checkToken",
+      "createApiKey",
+      "createMyCredentials",
+      "credentialsExist",
+      "deleteApiKey",
+      "deleteMyCredentials",
+      "getCurrentUser",
+      "getMyCredentials",
+      "getMyRights",
+      "getStrategies",
+      "login",
+      "logout",
+      "refreshToken",
+      "searchApiKeys",
+      "updateMyCredentials",
+      "updateSelf",
+      "validateMyCredentials",
     ]);
 
     this.anonymousId = null;
@@ -76,31 +76,35 @@ class AuthController extends NativeController {
    *
    * @returns {Promise}
    */
-  async init () {
-    const anonymous = await global.kuzzle.ask('core:security:user:anonymous:get');
+  async init() {
+    const anonymous = await global.kuzzle.ask(
+      "core:security:user:anonymous:get"
+    );
     this.anonymousId = anonymous._id;
   }
 
   /**
    * Checks if an API action can be executed by the current user
    */
-  async checkRights (request) {
+  async checkRights(request) {
     const requestPayload = request.getBody();
 
-    if (typeof requestPayload.controller !== 'string') {
-      throw kerror.get('api', 'assert', 'missing_argument', 'body.controller');
+    if (typeof requestPayload.controller !== "string") {
+      throw kerror.get("api", "assert", "missing_argument", "body.controller");
     }
 
-    if (typeof requestPayload.action !== 'string') {
-      throw kerror.get('api', 'assert', 'missing_argument', 'body.action');
+    if (typeof requestPayload.action !== "string") {
+      throw kerror.get("api", "assert", "missing_argument", "body.action");
     }
 
     const user = request.context.user;
 
-    const allowed = await user.isActionAllowed(new KuzzleRequest(requestPayload));
+    const allowed = await user.isActionAllowed(
+      new KuzzleRequest(requestPayload)
+    );
 
     return {
-      allowed
+      allowed,
     };
   }
 
@@ -108,11 +112,11 @@ class AuthController extends NativeController {
    * Creates a new API key for the user
    * @param {KuzzleRequest} request
    */
-  async createApiKey (request) {
+  async createApiKey(request) {
     const expiresIn = request.input.args.expiresIn || -1;
-    const refresh = request.getRefresh('wait_for');
-    const apiKeyId = request.getId({ ifMissing: 'generate' });
-    const description = request.getBodyString('description');
+    const refresh = request.getRefresh("wait_for");
+    const apiKeyId = request.getId({ ifMissing: "generate" });
+    const description = request.getBodyString("description");
 
     const user = request.context.user;
 
@@ -128,14 +132,14 @@ class AuthController extends NativeController {
   /**
    * Search in the user API keys
    */
-  async searchApiKeys (request) {
+  async searchApiKeys(request) {
     let query = request.getBody({});
     const { from, size } = request.getSearchParams();
     const lang = request.getLangParam();
 
     const user = request.context.user;
 
-    if (lang === 'koncorde') {
+    if (lang === "koncorde") {
       query = await this.translateKoncorde(query);
     }
 
@@ -143,23 +147,23 @@ class AuthController extends NativeController {
       query: {
         bool: {
           filter: { bool: { must: { term: { userId: user._id } } } },
-          must: isEmpty(query) ? { match_all: {} } : query
-        }
-      }
+          must: isEmpty(query) ? { match_all: {} } : query,
+        },
+      },
     };
 
     const apiKeys = await ApiKey.search(searchBody, { from, size });
 
     return {
-      hits: apiKeys.map(apiKey => apiKey.serialize()),
-      total: apiKeys.length
+      hits: apiKeys.map((apiKey) => apiKey.serialize()),
+      total: apiKeys.length,
     };
   }
 
   /**
    * Deletes an API key
    */
-  async deleteApiKey (request) {
+  async deleteApiKey(request) {
     const apiKeyId = request.getId();
     const refresh = request.getRefresh();
 
@@ -176,54 +180,56 @@ class AuthController extends NativeController {
    * @param {KuzzleRequest} request
    * @returns {Promise<object>}
    */
-  async logout (request) {
-    if ( ! global.kuzzle.config.http.cookieAuthentication
-      || ! request.getBoolean('cookieAuth')
+  async logout(request) {
+    if (
+      !global.kuzzle.config.http.cookieAuthentication ||
+      !request.getBoolean("cookieAuth")
     ) {
       this.assertIsAuthenticated(request);
     }
 
-    if (global.kuzzle.config.internal.notifiableProtocols.includes(request.context.connection.protocol)) {
+    if (
+      global.kuzzle.config.internal.notifiableProtocols.includes(
+        request.context.connection.protocol
+      )
+    ) {
       // Unlink connection so the connection will not be notified when the token expires.
       global.kuzzle.tokenManager.unlink(
         request.context.token,
-        request.context.connection.id);
+        request.context.connection.id
+      );
     }
 
     if (request.context.user._id !== this.anonymousId) {
-
-      if (request.getBoolean('global')) {
+      if (request.getBoolean("global")) {
         await global.kuzzle.ask(
-          'core:security:token:deleteByKuid',
+          "core:security:token:deleteByKuid",
           request.getKuid(),
-          { keepApiKeys: true });
-      }
-      else if ( request.context.token
-        && request.context.token.type !== 'apiKey'
+          { keepApiKeys: true }
+        );
+      } else if (
+        request.context.token &&
+        request.context.token.type !== "apiKey"
       ) {
         await global.kuzzle.ask(
-          'core:security:token:delete',
+          "core:security:token:delete",
           request.context.token
         );
       }
-
     }
 
-    if ( global.kuzzle.config.http.cookieAuthentication
-      && request.getBoolean('cookieAuth')
+    if (
+      global.kuzzle.config.http.cookieAuthentication &&
+      request.getBoolean("cookieAuth")
     ) {
       request.response.configure({
         headers: {
-          'Set-Cookie': Cookie.serialize(
-            'authToken',
-            null,
-            {
-              httpOnly: true,
-              path: '/',
-              sameSite: 'strict',
-            }
-          )
-        }
+          "Set-Cookie": Cookie.serialize("authToken", null, {
+            httpOnly: true,
+            path: "/",
+            sameSite: "strict",
+          }),
+        },
       });
     }
 
@@ -231,13 +237,14 @@ class AuthController extends NativeController {
   }
 
   // Used to send the Token using different ways when in cookieAuth mode. (DRY)
-  async _sendToken (token, request) {
+  async _sendToken(token, request) {
     // Only if the support of Browser Cookie as Authentication Token is enabled
     // otherwise we should send a normal response because
     // even if the SDK / Browser can handle the cookie,
     // Kuzzle would not be capable of doing anything with it
-    if ( global.kuzzle.config.http.cookieAuthentication
-      && request.getBoolean('cookieAuth')
+    if (
+      global.kuzzle.config.http.cookieAuthentication &&
+      request.getBoolean("cookieAuth")
     ) {
       // Here we are not sending auth token when cookieAuth is set to true
       // This allow us to detect if kuzzle does support cookie as auth token directly from the SDK
@@ -245,17 +252,13 @@ class AuthController extends NativeController {
 
       request.response.configure({
         headers: {
-          'Set-Cookie': Cookie.serialize(
-            'authToken',
-            token.jwt,
-            {
-              expires: new Date(token.expiresAt),
-              httpOnly: true,
-              path: '/',
-              sameSite: 'strict',
-            }
-          )
-        }
+          "Set-Cookie": Cookie.serialize("authToken", token.jwt, {
+            expires: new Date(token.expiresAt),
+            httpOnly: true,
+            path: "/",
+            sameSite: "strict",
+          }),
+        },
       });
 
       return {
@@ -269,7 +272,7 @@ class AuthController extends NativeController {
       _id: token.userId,
       expiresAt: token.expiresAt,
       jwt: token.jwt,
-      ttl: token.ttl
+      ttl: token.ttl,
     };
   }
 
@@ -280,15 +283,15 @@ class AuthController extends NativeController {
    * @param {KuzzleRequest} request
    * @returns {Promise<Token>}
    */
-  async login (request) {
-    const strategy = request.getString('strategy');
+  async login(request) {
+    const strategy = request.getString("strategy");
     const passportRequest = new IncomingMessage();
 
     // Even in http, the url and the method are not pushed back to the request object
     // set some arbitrary values to get a pseudo-valid object.
     passportRequest.url = `/login?strategy=${strategy}`;
-    passportRequest.method = 'POST';
-    passportRequest.httpVersion = '1.1';
+    passportRequest.method = "POST";
+    passportRequest.httpVersion = "1.1";
     passportRequest.httpVersionMajor = 1;
     passportRequest.httpVersionMinor = 1;
     passportRequest.body = request.input.body;
@@ -301,26 +304,27 @@ class AuthController extends NativeController {
     }
     passportRequest.original = request;
 
-    if (! has(global.kuzzle.pluginsManager.strategies, strategy)) {
-      throw kerror.get('security', 'credentials', 'unknown_strategy', strategy);
+    if (!has(global.kuzzle.pluginsManager.strategies, strategy)) {
+      throw kerror.get("security", "credentials", "unknown_strategy", strategy);
     }
 
     const content = await global.kuzzle.passport.authenticate(
       passportRequest,
-      strategy);
+      strategy
+    );
 
     // do not trigger the "auth:strategyAutenticated" pipe if the result is
     // not a User object, i.e. if we are a intermediate step of a multi-step
     // authentication strategy
     // (example: first redirection call for oAuth strategies)
-    const authResponse = (! (content instanceof User))
+    const authResponse = !(content instanceof User)
       ? { content, strategy }
-      : await this.pipe('auth:strategyAuthenticated', { content, strategy });
+      : await this.pipe("auth:strategyAuthenticated", { content, strategy });
 
-    if (! (authResponse.content instanceof User)) {
+    if (!(authResponse.content instanceof User)) {
       request.response.configure({
         headers: authResponse.content.headers,
-        status: authResponse.content.statusCode || 200
+        status: authResponse.content.statusCode || 200,
       });
 
       return authResponse.content;
@@ -333,7 +337,8 @@ class AuthController extends NativeController {
 
     const existingToken = global.kuzzle.tokenManager.getConnectedUserToken(
       authResponse.content._id,
-      request.context.connection.id);
+      request.context.connection.id
+    );
 
     /**
      * If a previous token from the same User is linked to this connection
@@ -341,24 +346,30 @@ class AuthController extends NativeController {
      * we dont need to create a new token or refresh anything, just send back the exact same token
      * to avoid breaking changes.
      */
-    if (existingToken && (existingToken.type === 'apiKey' || existingToken.ttl < 0)) {
+    if (
+      existingToken &&
+      (existingToken.type === "apiKey" || existingToken.ttl < 0)
+    ) {
       return this._sendToken(existingToken, request);
     }
 
     const token = await this.ask(
-      'core:security:token:create',
+      "core:security:token:create",
       authResponse.content,
-      options);
+      options
+    );
 
     if (existingToken) {
       global.kuzzle.tokenManager.refresh(existingToken, token);
     }
 
-    if (global.kuzzle.config.internal.notifiableProtocols.includes(request.context.connection.protocol)) {
+    if (
+      global.kuzzle.config.internal.notifiableProtocols.includes(
+        request.context.connection.protocol
+      )
+    ) {
       // Link the connection with the token, this way the connection can be notified when the token has expired.
-      global.kuzzle.tokenManager.link(
-        token,
-        request.context.connection.id);
+      global.kuzzle.tokenManager.link(token, request.context.connection.id);
     }
 
     return this._sendToken(token, request);
@@ -370,36 +381,35 @@ class AuthController extends NativeController {
    * @param {KuzzleRequest} request
    * @returns {Promise<Object>}
    */
-  getCurrentUser (request) {
-    const
-      userId = request.context.token.userId,
+  getCurrentUser(request) {
+    const userId = request.context.token.userId,
       formattedUser = formatProcessing.serializeUser(request.context.user),
       promises = [];
 
     if (this.anonymousId === userId) {
       promises.push(Bluebird.resolve([]));
-    }
-    else {
+    } else {
       for (const strategy of global.kuzzle.pluginsManager.listStrategies()) {
         const existsMethod = global.kuzzle.pluginsManager.getStrategyMethod(
           strategy,
-          'exists');
+          "exists"
+        );
 
         promises.push(
           existsMethod(request, userId, strategy)
-            .then(exists => exists ? strategy : null)
-            .catch(err => wrapPluginError(err)));
+            .then((exists) => (exists ? strategy : null))
+            .catch((err) => wrapPluginError(err))
+        );
       }
     }
 
-    return Bluebird.all(promises)
-      .then(strategies => {
-        if (strategies.length > 0) {
-          formattedUser.strategies = strategies.filter(item => item !== null);
-        }
+    return Bluebird.all(promises).then((strategies) => {
+      if (strategies.length > 0) {
+        formattedUser.strategies = strategies.filter((item) => item !== null);
+      }
 
-        return formattedUser;
-      });
+      return formattedUser;
+    });
   }
 
   /**
@@ -408,12 +418,16 @@ class AuthController extends NativeController {
    * @param {KuzzleRequest} request
    * @returns {Promise<object>}
    */
-  getMyRights (request) {
-    return request.context.user.getRights(global.kuzzle)
-      .then(rights => Object.keys(rights)
-        .reduce((array, item) => array.concat(rights[item]), [])
+  getMyRights(request) {
+    return request.context.user
+      .getRights(global.kuzzle)
+      .then((rights) =>
+        Object.keys(rights).reduce(
+          (array, item) => array.concat(rights[item]),
+          []
+        )
       )
-      .then(rights => ({ hits: rights, total: rights.length }));
+      .then((rights) => ({ hits: rights, total: rights.length }));
   }
 
   /**
@@ -422,24 +436,26 @@ class AuthController extends NativeController {
    * @param {KuzzleRequest} request
    * @returns {Promise<object>}
    */
-  async checkToken (request) {
-    let token = '';
+  async checkToken(request) {
+    let token = "";
 
-    if ( global.kuzzle.config.http.cookieAuthentication
-      && request.getBoolean('cookieAuth')
+    if (
+      global.kuzzle.config.http.cookieAuthentication &&
+      request.getBoolean("cookieAuth")
     ) {
       token = request.input.jwt;
-    }
-    else {
-      token = request.getBodyString('token', '') || null;
+    } else {
+      token = request.getBodyString("token", "") || null;
     }
 
     try {
-      const { expiresAt = -1, userId } = await this.ask('core:security:token:verify', token);
+      const { expiresAt = -1, userId } = await this.ask(
+        "core:security:token:verify",
+        token
+      );
 
       return { expiresAt, kuid: userId, valid: true };
-    }
-    catch (error) {
+    } catch (error) {
       if (error.status === 401) {
         return { state: error.message, valid: false };
       }
@@ -454,25 +470,30 @@ class AuthController extends NativeController {
    * @param {KuzzleRequest} request
    * @returns {Promise<object>}
    */
-  async updateSelf (request) {
+  async updateSelf(request) {
     this.assertIsAuthenticated(request);
-    this.assertBodyHasNotAttributes(request, '_id', 'profileIds');
+    this.assertBodyHasNotAttributes(request, "_id", "profileIds");
 
     const userId = request.getKuid();
     const body = request.getBody();
 
     const user = await this.ask(
-      'core:security:user:update',
+      "core:security:user:update",
       userId,
       null,
       body,
       {
-        refresh: request.getRefresh('wait_for'),
-        retryOnConflict: request.getInteger('retryOnConflict', 10),
+        refresh: request.getRefresh("wait_for"),
+        retryOnConflict: request.getInteger("retryOnConflict", 10),
         userId,
-      });
+      }
+    );
 
-    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${request.input.action}" on user "${userId}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${
+        request.input.action
+      }" on user "${userId}."`
+    );
 
     return formatProcessing.serializeUser(user);
   }
@@ -482,7 +503,7 @@ class AuthController extends NativeController {
    *
    * @returns {Promise.<string[]>}
    */
-  getStrategies () {
+  getStrategies() {
     return Bluebird.resolve(global.kuzzle.pluginsManager.listStrategies());
   }
 
@@ -490,181 +511,187 @@ class AuthController extends NativeController {
    * @param {KuzzleRequest} request
    * @returns {Promise.<Object>}
    */
-  createMyCredentials (request) {
+  createMyCredentials(request) {
     this.assertIsAuthenticated(request);
 
-    const
-      userId = request.getKuid(),
-      strategy = request.getString('strategy'),
+    const userId = request.getKuid(),
+      strategy = request.getString("strategy"),
       credentials = request.getBody();
 
     this.assertIsStrategyRegistered(strategy);
 
-    const
-      createMethod = global.kuzzle.pluginsManager.getStrategyMethod(
+    const createMethod = global.kuzzle.pluginsManager.getStrategyMethod(
         strategy,
-        'create'),
+        "create"
+      ),
       validateMethod = global.kuzzle.pluginsManager.getStrategyMethod(
         strategy,
-        'validate');
+        "validate"
+      );
 
     return validateMethod(request, credentials, userId, strategy, false)
       .then(() => createMethod(request, credentials, userId, strategy))
-      .catch(err => wrapPluginError(err));
+      .catch((err) => wrapPluginError(err));
   }
 
   /**
    * @param {KuzzleRequest} request
    * @returns {Promise.<Object>}
    */
-  updateMyCredentials (request) {
+  updateMyCredentials(request) {
     this.assertIsAuthenticated(request);
 
-    const
-      userId = request.getKuid(),
-      strategy = request.getString('strategy'),
+    const userId = request.getKuid(),
+      strategy = request.getString("strategy"),
       credentials = request.getBody();
 
     this.assertIsStrategyRegistered(strategy);
 
-    const
-      updateMethod = global.kuzzle.pluginsManager.getStrategyMethod(
+    const updateMethod = global.kuzzle.pluginsManager.getStrategyMethod(
         request.input.args.strategy,
-        'update'),
+        "update"
+      ),
       validateMethod = global.kuzzle.pluginsManager.getStrategyMethod(
         request.input.args.strategy,
-        'validate');
+        "validate"
+      );
 
     return validateMethod(request, credentials, userId, strategy, true)
       .then(() => updateMethod(request, credentials, userId, strategy))
-      .catch(err => wrapPluginError(err));
+      .catch((err) => wrapPluginError(err));
   }
 
   /**
    * @param {KuzzleRequest} request
    * @returns {Promise.<Object>}
    */
-  credentialsExist (request) {
+  credentialsExist(request) {
     this.assertIsAuthenticated(request);
 
-    const
-      userId = request.getKuid(),
-      strategy = request.getString('strategy');
+    const userId = request.getKuid(),
+      strategy = request.getString("strategy");
 
     this.assertIsStrategyRegistered(strategy);
 
     const existsMethod = global.kuzzle.pluginsManager.getStrategyMethod(
       strategy,
-      'exists');
+      "exists"
+    );
 
-    return existsMethod(request, userId, strategy)
-      .catch(err => wrapPluginError(err));
+    return existsMethod(request, userId, strategy).catch((err) =>
+      wrapPluginError(err)
+    );
   }
 
   /**
    * @param {KuzzleRequest} request
    * @returns {Promise.<Object>}
    */
-  validateMyCredentials (request) {
+  validateMyCredentials(request) {
     this.assertIsAuthenticated(request);
 
-    const
-      userId = request.getKuid(),
-      strategy = request.getString('strategy'),
+    const userId = request.getKuid(),
+      strategy = request.getString("strategy"),
       credentials = request.getBody();
 
     this.assertIsStrategyRegistered(strategy);
 
     const validateMethod = global.kuzzle.pluginsManager.getStrategyMethod(
       strategy,
-      'validate');
+      "validate"
+    );
 
-    return validateMethod(request, credentials, userId, strategy, false)
-      .catch(err => wrapPluginError(err));
+    return validateMethod(request, credentials, userId, strategy, false).catch(
+      (err) => wrapPluginError(err)
+    );
   }
 
   /**
    * @param {KuzzleRequest} request
    * @returns {Promise.<Object>}
    */
-  deleteMyCredentials (request) {
+  deleteMyCredentials(request) {
     this.assertIsAuthenticated(request);
 
-    const
-      userId = request.getKuid(),
-      strategy = request.getString('strategy');
+    const userId = request.getKuid(),
+      strategy = request.getString("strategy");
 
     this.assertIsStrategyRegistered(strategy);
 
     const deleteMethod = global.kuzzle.pluginsManager.getStrategyMethod(
       strategy,
-      'delete');
+      "delete"
+    );
 
     return deleteMethod(request, userId, strategy)
       .then(() => ({ acknowledged: true }))
-      .catch(err => wrapPluginError(err));
+      .catch((err) => wrapPluginError(err));
   }
 
   /**
    * @param {KuzzleRequest} request
    * @returns {Promise.<Object>}
    */
-  getMyCredentials (request) {
+  getMyCredentials(request) {
     this.assertIsAuthenticated(request);
 
-    const
-      userId = request.getKuid(),
-      strategy = request.getString('strategy');
+    const userId = request.getKuid(),
+      strategy = request.getString("strategy");
 
     this.assertIsStrategyRegistered(strategy);
 
-    if (! global.kuzzle.pluginsManager.hasStrategyMethod(strategy, 'getInfo')) {
+    if (!global.kuzzle.pluginsManager.hasStrategyMethod(strategy, "getInfo")) {
       return Bluebird.resolve({});
     }
 
     const getInfoMethod = global.kuzzle.pluginsManager.getStrategyMethod(
       strategy,
-      'getInfo');
+      "getInfo"
+    );
 
-    return getInfoMethod(request, userId, strategy)
-      .catch(err => wrapPluginError(err));
+    return getInfoMethod(request, userId, strategy).catch((err) =>
+      wrapPluginError(err)
+    );
   }
 
   /**
    * @param {KuzzleRequest} request
    */
-  async refreshToken (request) {
+  async refreshToken(request) {
     this.assertIsAuthenticated(request);
 
     const token = await this.ask(
-      'core:security:token:refresh',
+      "core:security:token:refresh",
       request.context.user,
       request.context.token,
-      request.input.args.expiresIn);
+      request.input.args.expiresIn
+    );
 
     return this._sendToken(token, request);
   }
 
-  assertIsAuthenticated (request) {
+  assertIsAuthenticated(request) {
     if (request.context.user._id === this.anonymousId) {
       throw kerror.get(
-        'security',
-        'rights',
-        'unauthorized',
+        "security",
+        "rights",
+        "unauthorized",
         request.input.controller,
-        request.input.action);
+        request.input.action
+      );
     }
   }
 }
 
-function wrapPluginError (error) {
-  if (! (error instanceof KuzzleError)) {
+function wrapPluginError(error) {
+  if (!(error instanceof KuzzleError)) {
     throw kerror.getFrom(
       error,
-      'plugin',
-      'runtime',
-      'unexpected_error',
-      error.message);
+      "plugin",
+      "runtime",
+      "unexpected_error",
+      error.message
+    );
   }
 
   throw error;