kuzzle 2.19.2 → 2.19.3

package/lib/api/controllers/securityController.js

@@ -19,133 +19,132 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const { isEmpty, isNil } = require('lodash');
-const Bluebird = require('bluebird');
-const { v4: uuidv4 } = require('uuid');
+const { isEmpty, isNil } = require("lodash");
+const Bluebird = require("bluebird");
+const { v4: uuidv4 } = require("uuid");
 
-const { KuzzleError, BadRequestError } = require('../../kerror/errors');
-const { Request } = require('../request');
-const { NativeController } = require('./baseController');
-const formatProcessing = require('../../core/auth/formatProcessing');
-const ApiKey = require('../../model/storage/apiKey');
-const kerror = require('../../kerror');
-const { has } = require('../../util/safeObject');
-const { NameGenerator } = require('../../util/name-generator');
+const { KuzzleError, BadRequestError } = require("../../kerror/errors");
+const { Request } = require("../request");
+const { NativeController } = require("./baseController");
+const formatProcessing = require("../../core/auth/formatProcessing");
+const ApiKey = require("../../model/storage/apiKey");
+const kerror = require("../../kerror");
+const { has } = require("../../util/safeObject");
+const { NameGenerator } = require("../../util/name-generator");
 
 /**
  * @class SecurityController
  */
 class SecurityController extends NativeController {
-
-  static userOrSdk (userId) {
-    return userId === null ? 'EmbeddedSDK' : `User "${userId}"`;
+  static userOrSdk(userId) {
+    return userId === null ? "EmbeddedSDK" : `User "${userId}"`;
   }
 
-  constructor () {
+  constructor() {
     super([
-      'checkRights',
-      'createApiKey',
-      'createCredentials',
-      'createFirstAdmin',
-      'createOrReplaceProfile',
-      'createOrReplaceRole',
-      'createProfile',
-      'createRestrictedUser',
-      'createRole',
-      'createUser',
-      'deleteApiKey',
-      'deleteCredentials',
-      'deleteProfile',
-      'deleteRole',
-      'deleteUser',
-      'getAllCredentialFields',
-      'getCredentialFields',
-      'getCredentials',
-      'getCredentialsById',
-      'getProfile',
-      'getProfileMapping',
-      'getProfileRights',
-      'getRole',
-      'getRoleMapping',
-      'getUser',
-      'getUserMapping',
-      'getUserRights',
-      'getUserStrategies',
-      'hasCredentials',
-      'mDeleteProfiles',
-      'mDeleteRoles',
-      'mDeleteUsers',
-      'mGetProfiles',
-      'mGetRoles',
-      'mGetUsers',
-      'refresh',
-      'replaceUser',
-      'revokeTokens',
-      'scrollProfiles',
-      'scrollUsers',
-      'searchApiKeys',
-      'searchProfiles',
-      'searchRoles',
-      'searchUsers',
-      'searchUsersByCredentials',
-      'updateCredentials',
-      'updateProfile',
-      'updateProfileMapping',
-      'updateRole',
-      'updateRoleMapping',
-      'updateUser',
-      'updateUserMapping',
-      'upsertUser',
-      'validateCredentials'
+      "checkRights",
+      "createApiKey",
+      "createCredentials",
+      "createFirstAdmin",
+      "createOrReplaceProfile",
+      "createOrReplaceRole",
+      "createProfile",
+      "createRestrictedUser",
+      "createRole",
+      "createUser",
+      "deleteApiKey",
+      "deleteCredentials",
+      "deleteProfile",
+      "deleteRole",
+      "deleteUser",
+      "getAllCredentialFields",
+      "getCredentialFields",
+      "getCredentials",
+      "getCredentialsById",
+      "getProfile",
+      "getProfileMapping",
+      "getProfileRights",
+      "getRole",
+      "getRoleMapping",
+      "getUser",
+      "getUserMapping",
+      "getUserRights",
+      "getUserStrategies",
+      "hasCredentials",
+      "mDeleteProfiles",
+      "mDeleteRoles",
+      "mDeleteUsers",
+      "mGetProfiles",
+      "mGetRoles",
+      "mGetUsers",
+      "refresh",
+      "replaceUser",
+      "revokeTokens",
+      "scrollProfiles",
+      "scrollUsers",
+      "searchApiKeys",
+      "searchProfiles",
+      "searchRoles",
+      "searchUsers",
+      "searchUsersByCredentials",
+      "updateCredentials",
+      "updateProfile",
+      "updateProfileMapping",
+      "updateRole",
+      "updateRoleMapping",
+      "updateUser",
+      "updateUserMapping",
+      "upsertUser",
+      "validateCredentials",
     ]);
 
-    this.subdomain = 'security';
+    this.subdomain = "security";
 
-    this.securityCollections = ['users', 'profiles', 'roles'];
+    this.securityCollections = ["users", "profiles", "roles"];
 
     // @deprecated - helper, will be loosely coupled in the near future
-    this.getStrategyMethod = global.kuzzle.pluginsManager.getStrategyMethod
-      .bind(global.kuzzle.pluginsManager);
+    this.getStrategyMethod =
+      global.kuzzle.pluginsManager.getStrategyMethod.bind(
+        global.kuzzle.pluginsManager
+      );
   }
 
   /**
    * Checks if an API action can be executed by a user
    */
-  async checkRights (request) {
-    const userId = request.getString('userId');
+  async checkRights(request) {
+    const userId = request.getString("userId");
     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 = await global.kuzzle.ask(
-      'core:security:user:get',
-      userId);
+    const user = await global.kuzzle.ask("core:security:user:get", userId);
 
     const allowed = await user.isActionAllowed(new Request(requestPayload));
 
     return {
-      allowed
+      allowed,
     };
   }
   /**
    * Creates a new API key for a user
    */
-  async createApiKey (request) {
+  async createApiKey(request) {
     const expiresIn = request.input.args.expiresIn || -1;
-    const refresh = request.getRefresh('wait_for');
-    const userId = request.getString('userId');
-    const apiKeyId = request.getId({ ifMissing: 'generate' });
-    const description = request.getBodyString('description');
+    const refresh = request.getRefresh("wait_for");
+    const userId = request.getString("userId");
+    const apiKeyId = request.getId({ ifMissing: "generate" });
+    const description = request.getBodyString("description");
 
-    const user = await this.ask('core:security:user:get', userId);
+    const user = await this.ask("core:security:user:get", userId);
     const creatorId = request.getKuid();
 
     const apiKey = await ApiKey.create(user, expiresIn, description, {
@@ -155,20 +154,24 @@ class SecurityController extends NativeController {
       refresh,
     });
 
-    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(creatorId)} applied action "${request.input.action}" on user "${userId}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(creatorId)} applied action "${
+        request.input.action
+      }" on user "${userId}."`
+    );
     return apiKey.serialize({ includeToken: true });
   }
 
   /**
    * Search in an user API keys
    */
-  async searchApiKeys (request) {
-    const userId = request.getString('userId');
+  async searchApiKeys(request) {
+    const userId = request.getString("userId");
     let query = request.getBody({});
     const { from, size, scrollTTL } = request.getSearchParams();
     const lang = request.getLangParam();
 
-    if (lang === 'koncorde') {
+    if (lang === "koncorde") {
       query = await this.translateKoncorde(query);
     }
 
@@ -176,44 +179,49 @@ class SecurityController extends NativeController {
       query: {
         bool: {
           filter: { bool: { must: { term: { userId } } } },
-          must: isEmpty(query) ? { match_all: {} } : query
-        }
-      }
+          must: isEmpty(query) ? { match_all: {} } : query,
+        },
+      },
     };
 
-    const apiKeys = await ApiKey.search(searchBody, { from, scroll: scrollTTL, size });
+    const apiKeys = await ApiKey.search(searchBody, {
+      from,
+      scroll: scrollTTL,
+      size,
+    });
 
     return {
-      hits: apiKeys.map(apiKey => apiKey.serialize()),
-      total: apiKeys.length
+      hits: apiKeys.map((apiKey) => apiKey.serialize()),
+      total: apiKeys.length,
     };
   }
 
   /**
    * Deletes an user API key
    */
-  async deleteApiKey (request) {
-    const userId = request.getString('userId');
+  async deleteApiKey(request) {
+    const userId = request.getString("userId");
     const apiKeyId = request.getId();
-    const refresh = request.getRefresh('wait_for');
+    const refresh = request.getRefresh("wait_for");
 
     const apiKey = await ApiKey.load(userId, apiKeyId);
 
     await apiKey.delete({ refresh });
 
     return {
-      _id: apiKeyId
+      _id: apiKeyId,
     };
   }
 
-
   /**
    * Get the role mapping
    *
    * @returns {Promise}
    */
-  async getRoleMapping () {
-    const { properties } = await global.kuzzle.internalIndex.getMapping('roles');
+  async getRoleMapping() {
+    const { properties } = await global.kuzzle.internalIndex.getMapping(
+      "roles"
+    );
 
     return { mapping: properties };
   }
@@ -223,10 +231,10 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise}
    */
-  async updateRoleMapping (request) {
+  async updateRoleMapping(request) {
     const mappings = request.getBody();
 
-    return global.kuzzle.internalIndex.updateMapping('roles', mappings);
+    return global.kuzzle.internalIndex.updateMapping("roles", mappings);
   }
 
   /**
@@ -234,8 +242,10 @@ class SecurityController extends NativeController {
    *
    * @returns {Promise}
    */
-  async getProfileMapping () {
-    const { properties } = await global.kuzzle.internalIndex.getMapping('profiles');
+  async getProfileMapping() {
+    const { properties } = await global.kuzzle.internalIndex.getMapping(
+      "profiles"
+    );
 
     return { mapping: properties };
   }
@@ -246,10 +256,10 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise}
    */
-  updateProfileMapping (request) {
+  updateProfileMapping(request) {
     const mappings = request.getBody();
 
-    return global.kuzzle.internalIndex.updateMapping('profiles', mappings);
+    return global.kuzzle.internalIndex.updateMapping("profiles", mappings);
   }
 
   /**
@@ -257,8 +267,10 @@ class SecurityController extends NativeController {
    *
    * @returns {Promise}
    */
-  async getUserMapping () {
-    const { properties } = await global.kuzzle.internalIndex.getMapping('users');
+  async getUserMapping() {
+    const { properties } = await global.kuzzle.internalIndex.getMapping(
+      "users"
+    );
 
     return { mapping: properties };
   }
@@ -269,10 +281,10 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise}
    */
-  async updateUserMapping (request) {
+  async updateUserMapping(request) {
     const mappings = request.getBody();
 
-    return global.kuzzle.internalIndex.updateMapping('users', mappings);
+    return global.kuzzle.internalIndex.updateMapping("users", mappings);
   }
 
   /**
@@ -281,10 +293,10 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async getRole (request) {
+  async getRole(request) {
     const id = request.getId();
 
-    const role = await this.ask('core:security:role:get', id);
+    const role = await this.ask("core:security:role:get", id);
 
     return formatProcessing.serializeRole(role);
   }
@@ -295,9 +307,9 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async mGetRoles (request) {
-    const ids = request.getBodyArray('ids');
-    const roles = await this.ask('core:security:role:mGet', ids);
+  async mGetRoles(request) {
+    const ids = request.getBodyArray("ids");
+    const roles = await this.ask("core:security:role:mGet", ids);
 
     return { hits: roles.map(formatProcessing.serializeRole) };
   }
@@ -308,16 +320,17 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise}
    */
-  async refresh (request) {
+  async refresh(request) {
     const collection = request.getCollection();
 
-    if (! this.securityCollections.includes(collection)) {
+    if (!this.securityCollections.includes(collection)) {
       throw kerror.get(
-        'api',
-        'assert',
-        'unexpected_argument',
+        "api",
+        "assert",
+        "unexpected_argument",
         collection,
-        this.securityCollections);
+        this.securityCollections
+      );
     }
 
     await global.kuzzle.internalIndex.refreshCollection(collection);
@@ -331,29 +344,31 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async searchRoles (request) {
-    const from = request.getInteger('from', 0);
+  async searchRoles(request) {
+    const from = request.getInteger("from", 0);
     const size = this._getSearchPageSize(request);
     const lang = request.getLangParam();
     const body = request.getBody({});
 
     if (body.controllers && body.query) {
-      throw new BadRequestError('You cannot specifify both "controllers" and "query". Prefer the usage of "query" property with a search query.');
+      throw new BadRequestError(
+        'You cannot specifify both "controllers" and "query". Prefer the usage of "query" property with a search query.'
+      );
     }
 
     if (body.controllers) {
       // Type checking
-      request.getBodyArray('controllers');
+      request.getBodyArray("controllers");
     }
 
-    if (lang === 'koncorde') {
+    if (lang === "koncorde") {
       body.query = await this.translateKoncorde(body.query || {});
     }
 
-    const response = await this.ask(
-      'core:security:role:search',
-      body,
-      { from, size });
+    const response = await this.ask("core:security:role:search", body, {
+      from,
+      size,
+    });
 
     response.hits = response.hits.map(formatProcessing.serializeRole);
 
@@ -366,18 +381,27 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async createOrReplaceRole (request) {
+  async createOrReplaceRole(request) {
     const id = request.getId();
     const body = request.getBody();
     const userId = request.getKuid();
 
-    const role = await this.ask('core:security:role:createOrReplace', id, body, {
-      force: request.getBoolean('force'),
-      refresh: request.getRefresh('wait_for'),
-      userId,
-    });
+    const role = await this.ask(
+      "core:security:role:createOrReplace",
+      id,
+      body,
+      {
+        force: request.getBoolean("force"),
+        refresh: request.getRefresh("wait_for"),
+        userId,
+      }
+    );
 
-    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${request.input.action}" on role "${role._id}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${
+        request.input.action
+      }" on role "${role._id}."`
+    );
     return formatProcessing.serializeRole(role);
   }
 
@@ -387,18 +411,22 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async createRole (request) {
+  async createRole(request) {
     const id = request.getId();
     const body = request.getBody();
     const userId = request.getKuid();
 
-    const role = await this.ask('core:security:role:create', id, body, {
-      force: request.getBoolean('force'),
-      refresh: request.getRefresh('wait_for'),
+    const role = await this.ask("core:security:role:create", id, body, {
+      force: request.getBoolean("force"),
+      refresh: request.getRefresh("wait_for"),
       userId,
     });
 
-    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${request.input.action}" on role "${role._id}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${
+        request.input.action
+      }" on role "${role._id}."`
+    );
     return formatProcessing.serializeRole(role);
   }
 
@@ -408,14 +436,18 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async deleteRole (request) {
+  async deleteRole(request) {
     const id = request.getId();
 
-    await this.ask('core:security:role:delete', id, {
-      refresh: request.getRefresh('wait_for')
+    await this.ask("core:security:role:delete", id, {
+      refresh: request.getRefresh("wait_for"),
     });
 
-    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(request.getKuid())} applied action "${request.input.action} on role "${id}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(
+        request.getKuid()
+      )} applied action "${request.input.action} on role "${id}."`
+    );
 
     // @todo This avoids a breaking change... but we should really return
     // an acknowledgment.
@@ -428,10 +460,10 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async getProfile (request) {
+  async getProfile(request) {
     const id = request.getId();
 
-    const profile = await this.ask('core:security:profile:get', id);
+    const profile = await this.ask("core:security:profile:get", id);
 
     return formatProcessing.serializeProfile(profile);
   }
@@ -442,15 +474,17 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async mGetProfiles (request) {
-    const ids = request.getBodyArray('ids');
+  async mGetProfiles(request) {
+    const ids = request.getBodyArray("ids");
 
-    const profiles = await this.ask('core:security:profile:mGet', ids);
+    const profiles = await this.ask("core:security:profile:mGet", ids);
 
     // @todo - should return an array of profiles directly, this is not a
     // search route...
     return {
-      hits: profiles.map(profile => formatProcessing.serializeProfile(profile))
+      hits: profiles.map((profile) =>
+        formatProcessing.serializeProfile(profile)
+      ),
     };
   }
 
@@ -460,25 +494,30 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async createOrReplaceProfile (request) {
+  async createOrReplaceProfile(request) {
     const id = request.getId();
     const content = request.getBody();
     const userId = request.getKuid();
 
     // Assert: must have a "policies" array
-    request.getBodyArray('policies');
+    request.getBodyArray("policies");
 
     const profile = await this.ask(
-      'core:security:profile:createOrReplace',
+      "core:security:profile:createOrReplace",
       id,
       content,
       {
-        refresh: request.getRefresh('wait_for'),
-        strict: request.getBoolean('strict'),
+        refresh: request.getRefresh("wait_for"),
+        strict: request.getBoolean("strict"),
         userId,
-      });
+      }
+    );
 
-    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${request.input.action}" on profile "${profile._id}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${
+        request.input.action
+      }" on profile "${profile._id}."`
+    );
 
     return formatProcessing.serializeProfile(profile);
   }
@@ -489,25 +528,30 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async createProfile (request) {
+  async createProfile(request) {
     const id = request.getId();
     const content = request.getBody();
     const userId = request.getKuid();
 
     // Assert: must have a "policies" array
-    request.getBodyArray('policies');
+    request.getBodyArray("policies");
 
     const profile = await this.ask(
-      'core:security:profile:create',
+      "core:security:profile:create",
       id,
       content,
       {
-        refresh: request.getRefresh('wait_for'),
-        strict: request.getBoolean('strict'),
+        refresh: request.getRefresh("wait_for"),
+        strict: request.getBoolean("strict"),
         userId,
-      });
+      }
+    );
 
-    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${request.input.action}" on profile "${profile._id}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${
+        request.input.action
+      }" on profile "${profile._id}."`
+    );
 
     return formatProcessing.serializeProfile(profile);
   }
@@ -518,17 +562,22 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async deleteProfile (request) {
+  async deleteProfile(request) {
     const id = request.getId();
     const userId = request.getKuid();
     const options = {
-      onAssignedUsers: request.getString('onAssignedUsers', 'fail'),
-      refresh: request.getRefresh('wait_for'),
-      userId };
+      onAssignedUsers: request.getString("onAssignedUsers", "fail"),
+      refresh: request.getRefresh("wait_for"),
+      userId,
+    };
 
-    await this.ask('core:security:profile:delete', id, options);
+    await this.ask("core:security:profile:delete", id, options);
 
-    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${request.input.action}" on profile "${id}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${
+        request.input.action
+      }" on profile "${id}."`
+    );
 
     // @todo - replace by an acknowledgement
     return { _id: id };
@@ -540,39 +589,47 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async searchProfiles (request) {
+  async searchProfiles(request) {
     const size = this._getSearchPageSize(request);
     const { from, scrollTTL, searchBody } = request.getSearchParams();
     const lang = request.getLangParam();
     const body = request.getBody({});
 
     if (body.roles && body.query) {
-      throw new BadRequestError('You cannot specifify both "roles" and "query". Prefer the usage of "query" property with a search query.');
+      throw new BadRequestError(
+        'You cannot specifify both "roles" and "query". Prefer the usage of "query" property with a search query.'
+      );
     }
 
     if (body.roles) {
-      const roles = request.getBodyArray('roles');
+      const roles = request.getBodyArray("roles");
 
-      request.addDeprecation('auto-version', 'Usage of the "roles" property is deprecated. Prefer the usage of "query" property with a search query.');
+      request.addDeprecation(
+        "auto-version",
+        'Usage of the "roles" property is deprecated. Prefer the usage of "query" property with a search query.'
+      );
 
       if (roles.length > 0) {
-        searchBody.query = { terms: { 'policies.roleId': roles } };
-      }
-      else {
+        searchBody.query = { terms: { "policies.roleId": roles } };
+      } else {
         searchBody.query = { match_all: {} };
       }
       delete body.roles;
     }
 
-    if (lang === 'koncorde') {
+    if (lang === "koncorde") {
       searchBody.query = await this.translateKoncorde(searchBody.query || {});
     }
 
-    const response = await this.ask('core:security:profile:search', searchBody, {
-      from,
-      scroll: scrollTTL,
-      size,
-    });
+    const response = await this.ask(
+      "core:security:profile:search",
+      searchBody,
+      {
+        from,
+        scroll: scrollTTL,
+        size,
+      }
+    );
 
     response.hits = response.hits.map(formatProcessing.serializeProfile);
 
@@ -585,9 +642,9 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async getUser (request) {
+  async getUser(request) {
     const id = request.getId();
-    const user = await this.ask('core:security:user:get', id);
+    const user = await this.ask("core:security:user:get", id);
 
     return formatProcessing.serializeUser(user);
   }
@@ -598,23 +655,23 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise.<Object>}
    */
-  async mGetUsers (request) {
+  async mGetUsers(request) {
     let ids;
 
-    if ( request.input.body
-      && request.input.body.ids
-      && Object.keys(request.input.body.ids).length
+    if (
+      request.input.body &&
+      request.input.body.ids &&
+      Object.keys(request.input.body.ids).length
     ) {
-      ids = request.getBodyArray('ids');
-    }
-    else {
+      ids = request.getBodyArray("ids");
+    } else {
       // @deprecated Should be replaced with request.getArray('ids')
-      ids = request.getArrayLegacy('ids');
+      ids = request.getArrayLegacy("ids");
     }
 
-    const users = await this.ask('core:security:user:mGet', ids);
+    const users = await this.ask("core:security:user:mGet", ids);
 
-    return { hits: users.map(user => formatProcessing.serializeUser(user)) };
+    return { hits: users.map((user) => formatProcessing.serializeUser(user)) };
   }
 
   /**
@@ -623,18 +680,19 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async getProfileRights (request) {
+  async getProfileRights(request) {
     const id = request.getId();
 
-    const profile = await this.ask('core:security:profile:get', id);
+    const profile = await this.ask("core:security:profile:get", id);
     const rights = await profile.getRights();
-    const hits = Object
-      .keys(rights)
-      .reduce((array, item) => array.concat(rights[item]), []);
+    const hits = Object.keys(rights).reduce(
+      (array, item) => array.concat(rights[item]),
+      []
+    );
 
     return {
       hits,
-      total: hits.length
+      total: hits.length,
     };
   }
 
@@ -644,18 +702,19 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async getUserRights (request) {
+  async getUserRights(request) {
     const id = request.getId();
 
-    const user = await this.ask('core:security:user:get', id);
+    const user = await this.ask("core:security:user:get", id);
     const rights = await user.getRights();
-    const hits = Object
-      .keys(rights)
-      .reduce((array, item) => array.concat(rights[item]), []);
+    const hits = Object.keys(rights).reduce(
+      (array, item) => array.concat(rights[item]),
+      []
+    );
 
     return {
       hits,
-      total: hits.length
+      total: hits.length,
     };
   }
 
@@ -665,34 +724,36 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async getUserStrategies (request) {
+  async getUserStrategies(request) {
     const userId = request.getId();
     const checkPromises = [];
 
     // Throws if the user doesn't exist
-    await this.ask('core:security:user:get', userId);
+    await this.ask("core:security:user:get", userId);
 
     if (this.anonymousId === userId) {
       checkPromises.push(Bluebird.resolve(null));
-    }
-    else {
+    } else {
       const availableStrategies = global.kuzzle.pluginsManager.listStrategies();
 
       for (const strategy of availableStrategies) {
-        const existMethod = this.getStrategyMethod(strategy, 'exists');
+        const existMethod = this.getStrategyMethod(strategy, "exists");
 
         checkPromises.push(
-          existMethod(request, userId, strategy)
-            .then(exists => exists ? strategy : null));
+          existMethod(request, userId, strategy).then((exists) =>
+            exists ? strategy : null
+          )
+        );
       }
     }
 
-    const strategies = await Bluebird.all(checkPromises)
-      .filter(item => item !== null);
+    const strategies = await Bluebird.all(checkPromises).filter(
+      (item) => item !== null
+    );
 
     return {
       strategies,
-      total: strategies.length
+      total: strategies.length,
     };
   }
 
@@ -702,16 +763,16 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async searchUsers (request) {
+  async searchUsers(request) {
     const size = this._getSearchPageSize(request);
     const { from, scrollTTL, searchBody } = request.getSearchParams();
     const lang = request.getLangParam();
 
-    if (lang === 'koncorde') {
+    if (lang === "koncorde") {
       searchBody.query = await this.translateKoncorde(searchBody.query);
     }
 
-    const response = await this.ask('core:security:user:search', searchBody, {
+    const response = await this.ask("core:security:user:search", searchBody, {
       from,
       scroll: scrollTTL,
       size,
@@ -730,20 +791,26 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async searchUsersByCredentials (request) {
-    const strategy = request.getString('strategy');
+  async searchUsersByCredentials(request) {
+    const strategy = request.getString("strategy");
     const lang = request.getLangParam();
     const { from, size, searchBody } = request.getSearchParams();
 
     this.assertIsStrategyRegistered(strategy);
 
-    const searchMethod = this.getStrategyMethod(strategy, 'search');
+    const searchMethod = this.getStrategyMethod(strategy, "search");
 
-    if (! searchMethod) {
-      throw kerror.get('plugin', 'strategy', 'missing_optional_method', 'search', strategy);
+    if (!searchMethod) {
+      throw kerror.get(
+        "plugin",
+        "strategy",
+        "missing_optional_method",
+        "search",
+        strategy
+      );
     }
 
-    if (lang === 'koncorde') {
+    if (lang === "koncorde") {
       searchBody.query = await this.translateKoncorde(searchBody.query || {});
     }
 
@@ -758,13 +825,17 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async deleteUser (request) {
+  async deleteUser(request) {
     const id = request.getId();
-    const options = { refresh: request.getRefresh('wait_for') };
+    const options = { refresh: request.getRefresh("wait_for") };
 
-    await this.ask('core:security:user:delete', id, options);
+    await this.ask("core:security:user:delete", id, options);
 
-    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(request.getKuid())} applied action "${request.input.action}" on user "${id}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(
+        request.getKuid()
+      )} applied action "${request.input.action}" on user "${id}."`
+    );
 
     return { _id: id };
   }
@@ -775,10 +846,10 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async createUser (request) {
-    const content = request.getBodyObject('content');
-    const profileIds = request.getBodyArray('content.profileIds');
-    const humanReadableId = request.getString('kuid', 'human') !== 'uuid';
+  async createUser(request) {
+    const content = request.getBodyObject("content");
+    const profileIds = request.getBodyArray("content.profileIds");
+    const humanReadableId = request.getString("kuid", "human") !== "uuid";
 
     return this._persistUser(request, profileIds, content, { humanReadableId });
   }
@@ -789,19 +860,25 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async createRestrictedUser (request) {
-    const content = request.getBodyObject('content', {});
-    const humanReadableId = request.getString('kuid', 'human') !== 'uuid';
+  async createRestrictedUser(request) {
+    const content = request.getBodyObject("content", {});
+    const humanReadableId = request.getString("kuid", "human") !== "uuid";
 
-    if (has(content, 'profileIds')) {
-      throw kerror.get('api', 'assert', 'forbidden_argument', 'body.content.profileIds');
+    if (has(content, "profileIds")) {
+      throw kerror.get(
+        "api",
+        "assert",
+        "forbidden_argument",
+        "body.content.profileIds"
+      );
     }
 
     return this._persistUser(
       request,
       global.kuzzle.config.security.restrictedProfileIds,
       content,
-      { humanReadableId });
+      { humanReadableId }
+    );
   }
 
   /**
@@ -810,13 +887,13 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async updateUser (request) {
+  async updateUser(request) {
     const id = request.getId();
     const content = request.getBody();
     const userId = request.getKuid();
     const profileIds = isNil(content.profileIds)
       ? null
-      : request.getBodyArray('profileIds');
+      : request.getBodyArray("profileIds");
 
     return this._changeUser(request, id, content, userId, profileIds);
   }
@@ -828,18 +905,17 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise}
    */
-  async upsertUser (request) {
+  async upsertUser(request) {
     const id = request.getId();
-    const content = request.getBodyObject('content');
+    const content = request.getBodyObject("content");
     const userId = request.getKuid();
-    const profileIds = request.getBodyArray('content.profileIds');
-    const defaultValues = request.getBodyObject('default', {});
+    const profileIds = request.getBodyArray("content.profileIds");
+    const defaultValues = request.getBodyObject("default", {});
 
     try {
       return await this._changeUser(request, id, content, userId, profileIds);
-    }
-    catch (error) {
-      if (error.id && error.id === 'security.user.not_found') {
+    } catch (error) {
+      if (error.id && error.id === "security.user.not_found") {
         const creatingContent = {
           ...defaultValues,
           ...content, // Order important, content erase default duplicates
@@ -858,20 +934,25 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async replaceUser (request) {
+  async replaceUser(request) {
     const id = request.getId();
     const content = request.getBody();
-    const profileIds = request.getBodyArray('profileIds');
+    const profileIds = request.getBodyArray("profileIds");
     const userId = request.getKuid();
 
     const user = await this.ask(
-      'core:security:user:replace',
+      "core:security:user:replace",
       id,
       profileIds,
       content,
-      { refresh: request.getRefresh('wait_for'), userId });
+      { refresh: request.getRefresh("wait_for"), userId }
+    );
 
-    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${request.input.action}" on user "${id}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${
+        request.input.action
+      }" on user "${id}."`
+    );
 
     return formatProcessing.serializeUser(user);
   }
@@ -882,19 +963,23 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async updateProfile (request) {
+  async updateProfile(request) {
     const id = request.getId();
     const body = request.getBody();
     const userId = request.getKuid();
 
-    const updated = await this.ask('core:security:profile:update', id, body, {
-      refresh: request.getRefresh('wait_for'),
-      retryOnConflict: request.getInteger('retryOnConflict', 10),
-      strict: request.getBoolean('strict'),
+    const updated = await this.ask("core:security:profile:update", id, body, {
+      refresh: request.getRefresh("wait_for"),
+      retryOnConflict: request.getInteger("retryOnConflict", 10),
+      strict: request.getBoolean("strict"),
       userId,
     });
 
-    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${request.input.action}" on profile "${id}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${
+        request.input.action
+      }" on profile "${id}."`
+    );
     return formatProcessing.serializeProfile(updated);
   }
 
@@ -904,19 +989,23 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async updateRole (request) {
+  async updateRole(request) {
     const id = request.getId();
     const body = request.getBody();
     const userId = request.getKuid();
 
-    const updated = await this.ask('core:security:role:update', id, body, {
-      force: request.getBoolean('force'),
-      refresh: request.getRefresh('wait_for'),
-      retryOnConflict: request.getInteger('retryOnConflict', 10),
+    const updated = await this.ask("core:security:role:update", id, body, {
+      force: request.getBoolean("force"),
+      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 role "${id}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${
+        request.input.action
+      }" on role "${id}."`
+    );
 
     return formatProcessing.serializeRole(updated);
   }
@@ -927,37 +1016,51 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async createFirstAdmin (request) {
-    const adminExists = await global.kuzzle.ask('core:security:user:admin:exist');
+  async createFirstAdmin(request) {
+    const adminExists = await global.kuzzle.ask(
+      "core:security:user:admin:exist"
+    );
 
     if (adminExists) {
-      throw kerror.get('api', 'process', 'admin_exists');
+      throw kerror.get("api", "process", "admin_exists");
     }
 
     const userId = request.getKuid();
-    const content = request.getBodyObject('content', {});
-    const reset = request.getBoolean('reset');
-    const humanReadableId = request.getString('kuid', 'human') !== 'uuid';
+    const content = request.getBodyObject("content", {});
+    const reset = request.getBoolean("reset");
+    const humanReadableId = request.getString("kuid", "human") !== "uuid";
 
-    if (has(content, 'profileIds')) {
-      throw kerror.get('api', 'assert', 'forbidden_argument', 'body.content.profileIds');
+    if (has(content, "profileIds")) {
+      throw kerror.get(
+        "api",
+        "assert",
+        "forbidden_argument",
+        "body.content.profileIds"
+      );
     }
 
-    const user = await this._persistUser(request, [ 'admin' ], content, { humanReadableId });
+    const user = await this._persistUser(request, ["admin"], content, {
+      humanReadableId,
+    });
 
     if (reset) {
-      for (const type of ['role', 'profile']) {
+      for (const type of ["role", "profile"]) {
         await Bluebird.map(
           Object.entries(global.kuzzle.config.security.standard[`${type}s`]),
-          ([name, value]) => this.ask(
-            `core:security:${type}:createOrReplace`,
-            name,
-            value,
-            { refresh: 'wait_for', userId }));
+          ([name, value]) =>
+            this.ask(`core:security:${type}:createOrReplace`, name, value, {
+              refresh: "wait_for",
+              userId,
+            })
+        );
       }
     }
 
-    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${request.input.action}".`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${
+        request.input.action
+      }".`
+    );
 
     return user;
   }
@@ -968,8 +1071,8 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  mDeleteProfiles (request) {
-    return this._mDelete('profile', request);
+  mDeleteProfiles(request) {
+    return this._mDelete("profile", request);
   }
 
   /**
@@ -978,8 +1081,8 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  mDeleteRoles (request) {
-    return this._mDelete('role', request);
+  mDeleteRoles(request) {
+    return this._mDelete("role", request);
   }
 
   /**
@@ -988,8 +1091,8 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  mDeleteUsers (request) {
-    return this._mDelete('user', request);
+  mDeleteUsers(request) {
+    return this._mDelete("user", request);
   }
 
   /**
@@ -998,11 +1101,11 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async scrollUsers (request) {
-    const id = request.getString('scrollId');
+  async scrollUsers(request) {
+    const id = request.getString("scrollId");
     const ttl = request.getScrollTTLParam();
 
-    const response = await this.ask('core:security:user:scroll', id, ttl);
+    const response = await this.ask("core:security:user:scroll", id, ttl);
 
     response.hits = response.hits.map(formatProcessing.serializeUser);
 
@@ -1015,11 +1118,11 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async scrollProfiles (request) {
-    const id = request.getString('scrollId');
+  async scrollProfiles(request) {
+    const id = request.getString("scrollId");
     const ttl = request.getScrollTTLParam();
 
-    const response = await this.ask('core:security:profile:scroll', id, ttl);
+    const response = await this.ask("core:security:profile:scroll", id, ttl);
 
     response.hits = response.hits.map(formatProcessing.serializeProfile);
 
@@ -1030,23 +1133,27 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async createCredentials (request) {
+  async createCredentials(request) {
     const id = request.getId();
     const body = request.getBody();
-    const strategy = request.getString('strategy');
+    const strategy = request.getString("strategy");
 
     this.assertIsStrategyRegistered(strategy);
 
     // Throws if the user doesn't exist
-    await this.ask('core:security:user:get', id);
+    await this.ask("core:security:user:get", id);
 
-    const validateMethod = this.getStrategyMethod(strategy, 'validate');
+    const validateMethod = this.getStrategyMethod(strategy, "validate");
 
     await validateMethod(request, body, id, strategy, false);
 
-    const createMethod = this.getStrategyMethod(strategy, 'create');
+    const createMethod = this.getStrategyMethod(strategy, "create");
 
-    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(request.getKuid())} applied action "${request.input.action}" on user "${id}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(
+        request.getKuid()
+      )} applied action "${request.input.action}" on user "${id}."`
+    );
     return createMethod(request, body, id, strategy);
   }
 
@@ -1054,23 +1161,27 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async updateCredentials (request) {
+  async updateCredentials(request) {
     const id = request.getId();
     const body = request.getBody();
-    const strategy = request.getString('strategy');
+    const strategy = request.getString("strategy");
 
     this.assertIsStrategyRegistered(strategy);
 
     // Throws if the user doesn't exist
-    await this.ask('core:security:user:get', id);
+    await this.ask("core:security:user:get", id);
 
-    const validateMethod = this.getStrategyMethod(strategy, 'validate');
+    const validateMethod = this.getStrategyMethod(strategy, "validate");
 
     await validateMethod(request, body, id, strategy, true);
 
-    const updateMethod = this.getStrategyMethod(strategy, 'update');
+    const updateMethod = this.getStrategyMethod(strategy, "update");
 
-    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(request.getKuid())} applied action "${request.input.action}" on user "${id}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(
+        request.getKuid()
+      )} applied action "${request.input.action}" on user "${id}."`
+    );
 
     return updateMethod(request, body, id, strategy);
   }
@@ -1079,13 +1190,13 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise.<Object>}
    */
-  async hasCredentials (request) {
+  async hasCredentials(request) {
     const id = request.getId();
-    const strategy = request.getString('strategy');
+    const strategy = request.getString("strategy");
 
     this.assertIsStrategyRegistered(strategy);
 
-    const existsMethod = this.getStrategyMethod(strategy, 'exists');
+    const existsMethod = this.getStrategyMethod(strategy, "exists");
 
     return existsMethod(request, id, strategy);
   }
@@ -1094,36 +1205,41 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise.<Object>}
    */
-  async validateCredentials (request) {
-    const strategy = request.getString('strategy');
+  async validateCredentials(request) {
+    const strategy = request.getString("strategy");
 
     this.assertIsStrategyRegistered(strategy);
 
-    const validateMethod = this.getStrategyMethod(strategy, 'validate');
+    const validateMethod = this.getStrategyMethod(strategy, "validate");
 
     return validateMethod(
       request,
       request.getBody(),
-      request.getId({ ifMissing: 'ignore' }),
+      request.getId({ ifMissing: "ignore" }),
       strategy,
-      false);
+      false
+    );
   }
 
   /**
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async deleteCredentials (request) {
+  async deleteCredentials(request) {
     const id = request.getId();
-    const strategy = request.getString('strategy');
+    const strategy = request.getString("strategy");
 
     this.assertIsStrategyRegistered(strategy);
 
-    const deleteMethod = this.getStrategyMethod(strategy, 'delete');
+    const deleteMethod = this.getStrategyMethod(strategy, "delete");
 
     await deleteMethod(request, id, strategy);
 
-    global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(request.getKuid())} applied action "${request.input.action}" on user "${id}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(
+        request.getKuid()
+      )} applied action "${request.input.action}" on user "${id}."`
+    );
 
     return { acknowledged: true };
   }
@@ -1132,14 +1248,14 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async getCredentials (request) {
+  async getCredentials(request) {
     const id = request.getId();
-    const strategy = request.getString('strategy');
+    const strategy = request.getString("strategy");
 
     this.assertIsStrategyRegistered(strategy);
 
-    if (global.kuzzle.pluginsManager.hasStrategyMethod(strategy, 'getInfo')) {
-      const getInfoMethod = this.getStrategyMethod(strategy, 'getInfo');
+    if (global.kuzzle.pluginsManager.hasStrategyMethod(strategy, "getInfo")) {
+      const getInfoMethod = this.getStrategyMethod(strategy, "getInfo");
 
       return getInfoMethod(request, id, strategy);
     }
@@ -1151,14 +1267,14 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async getCredentialsById (request) {
+  async getCredentialsById(request) {
     const id = request.getId();
-    const strategy = request.getString('strategy');
+    const strategy = request.getString("strategy");
 
     this.assertIsStrategyRegistered(strategy);
 
-    if (global.kuzzle.pluginsManager.hasStrategyMethod(strategy, 'getById')) {
-      const getByIdMethod = this.getStrategyMethod(strategy, 'getById');
+    if (global.kuzzle.pluginsManager.hasStrategyMethod(strategy, "getById")) {
+      const getByIdMethod = this.getStrategyMethod(strategy, "getById");
 
       return getByIdMethod(request, id, strategy);
     }
@@ -1170,8 +1286,8 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise<Object>}
    */
-  async getCredentialFields (request) {
-    const strategy = request.getString('strategy');
+  async getCredentialFields(request) {
+    const strategy = request.getString("strategy");
 
     this.assertIsStrategyRegistered(strategy);
 
@@ -1181,14 +1297,13 @@ class SecurityController extends NativeController {
   /**
    * @returns {Promise<Object>}
    */
-  async getAllCredentialFields () {
+  async getAllCredentialFields() {
     const strategyFields = {};
 
-    global.kuzzle.pluginsManager.listStrategies()
-      .forEach(strategy => {
-        strategyFields[strategy] =
-          global.kuzzle.pluginsManager.getStrategyFields(strategy);
-      });
+    global.kuzzle.pluginsManager.listStrategies().forEach((strategy) => {
+      strategyFields[strategy] =
+        global.kuzzle.pluginsManager.getStrategyFields(strategy);
+    });
 
     return strategyFields;
   }
@@ -1197,10 +1312,10 @@ class SecurityController extends NativeController {
    * @param {Request} request
    * @returns {Promise.<null>}
    */
-  async revokeTokens (request) {
+  async revokeTokens(request) {
     const id = request.getId();
 
-    await this.ask('core:security:token:deleteByKuid', id);
+    await this.ask("core:security:token:deleteByKuid", id);
 
     return null;
   }
@@ -1211,33 +1326,43 @@ class SecurityController extends NativeController {
    * @returns {Promise.<Array.<string>>}
    * @private
    */
-  async _mDelete (type, request) {
-    const ids = request.getBodyArray('ids');
-    const refresh = request.getRefresh('wait_for');
+  async _mDelete(type, request) {
+    const ids = request.getBodyArray("ids");
+    const refresh = request.getRefresh("wait_for");
 
     if (ids.length > global.kuzzle.config.limits.documentsWriteCount) {
-      throw kerror.get('services', 'storage', 'write_limit_exceeded');
+      throw kerror.get("services", "storage", "write_limit_exceeded");
     }
 
     const successes = [];
     const errors = [];
 
-    await Bluebird.map(
-      ids,
-      id => this.ask(`core:security:${type}:delete`, id, { refresh })
+    await Bluebird.map(ids, (id) =>
+      this.ask(`core:security:${type}:delete`, id, { refresh })
         .then(() => successes.push(id))
-        .catch(err => errors.push(err)));
+        .catch((err) => errors.push(err))
+    );
 
     if (errors.length) {
       request.setError(
-        kerror.get('services', 'storage', 'incomplete_delete', errors));
+        kerror.get("services", "storage", "incomplete_delete", errors)
+      );
     }
 
     if (successes.length > 1000) {
-      global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(request.getKuid())} deleted the following ${type}s: ${successes.slice(0, 1000).join(', ')}... (${successes.length - 1000} more users deleted)."`);
-    }
-    else {
-      global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(request.getKuid())} deleted the following ${type}s: ${successes.join(', ')}."`);
+      global.kuzzle.log.info(
+        `[SECURITY] ${SecurityController.userOrSdk(
+          request.getKuid()
+        )} deleted the following ${type}s: ${successes
+          .slice(0, 1000)
+          .join(", ")}... (${successes.length - 1000} more users deleted)."`
+      );
+    } else {
+      global.kuzzle.log.info(
+        `[SECURITY] ${SecurityController.userOrSdk(
+          request.getKuid()
+        )} deleted the following ${type}s: ${successes.join(", ")}."`
+      );
     }
 
     return successes;
@@ -1247,19 +1372,24 @@ class SecurityController extends NativeController {
    * @returns {Promise}
    * @private
    */
-  async _changeUser (request, id, content, userId, profileIds) {
+  async _changeUser(request, id, content, userId, profileIds) {
     const updated = await this.ask(
-      'core:security:user:update',
+      "core:security:user:update",
       id,
       profileIds,
       content,
       {
-        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 "${id}."`);
+    global.kuzzle.log.info(
+      `[SECURITY] ${SecurityController.userOrSdk(userId)} applied action "${
+        request.input.action
+      }" on user "${id}."`
+    );
 
     return formatProcessing.serializeUser(updated);
   }
@@ -1269,14 +1399,19 @@ class SecurityController extends NativeController {
    * @returns {Promise}
    * @private
    */
-  async _persistUser (request, profileIds, content, { humanReadableId = true } = {}) {
-    const credentials = request.getBodyObject('credentials', {});
+  async _persistUser(
+    request,
+    profileIds,
+    content,
+    { humanReadableId = true } = {}
+  ) {
+    const credentials = request.getBodyObject("credentials", {});
     const strategies = Object.keys(credentials);
     const generator = humanReadableId
-      ? () => NameGenerator.generateRandomName({ prefix: 'kuid' })
-      : () => 'kuid-' + uuidv4();
+      ? () => NameGenerator.generateRandomName({ prefix: "kuid" })
+      : () => "kuid-" + uuidv4();
 
-    let id = '';
+    let id = "";
     let alreadyExists = false;
     // Early checks before the user is created
     do {
@@ -1287,19 +1422,20 @@ class SecurityController extends NativeController {
 
           return generator();
         },
-        ifMissing: 'generate',
+        ifMissing: "generate",
       });
 
       for (const strategy of strategies) {
-        if (! global.kuzzle.pluginsManager.listStrategies().includes(strategy)) {
+        if (!global.kuzzle.pluginsManager.listStrategies().includes(strategy)) {
           throw kerror.get(
-            'security',
-            'credentials',
-            'unknown_strategy',
-            strategy);
+            "security",
+            "credentials",
+            "unknown_strategy",
+            strategy
+          );
         }
 
-        const exists = this.getStrategyMethod(strategy, 'exists');
+        const exists = this.getStrategyMethod(strategy, "exists");
         alreadyExists = await exists(request, id, strategy);
         if (alreadyExists) {
           if (generated) {
@@ -1307,21 +1443,22 @@ class SecurityController extends NativeController {
           }
 
           throw kerror.get(
-            'security',
-            'credentials',
-            'database_inconsistency',
-            id);
+            "security",
+            "credentials",
+            "database_inconsistency",
+            id
+          );
         }
       }
-
     } while (alreadyExists);
 
     const user = await this.ask(
-      'core:security:user:create',
+      "core:security:user:create",
       id,
       profileIds,
       content,
-      { refresh: request.getRefresh('wait_for') });
+      { refresh: request.getRefresh("wait_for") }
+    );
 
     const createdUser = formatProcessing.serializeUser(user);
 
@@ -1331,29 +1468,31 @@ class SecurityController extends NativeController {
 
     for (const strategy of strategies) {
       try {
-        const validate = this.getStrategyMethod(strategy, 'validate');
+        const validate = this.getStrategyMethod(strategy, "validate");
 
         await validate(request, credentials[strategy], id, strategy, false);
-      }
-      catch (error) {
+      } catch (error) {
         creationFailure = { error, validation: true };
         break;
       }
 
       try {
-        const create = this.getStrategyMethod(strategy, 'create');
+        const create = this.getStrategyMethod(strategy, "create");
 
         await create(request, credentials[strategy], id, strategy);
         createdStrategies.push(strategy);
-      }
-      catch (error) {
+      } catch (error) {
         creationFailure = { error, validation: false };
         break;
       }
     }
 
     if (creationFailure === null) {
-      global.kuzzle.log.info(`[SECURITY] ${SecurityController.userOrSdk(request.getKuid())} applied action "${request.input.action}" on user "${id}."`);
+      global.kuzzle.log.info(
+        `[SECURITY] ${SecurityController.userOrSdk(
+          request.getKuid()
+        )} applied action "${request.input.action}" on user "${id}."`
+      );
       return createdUser;
     }
 
@@ -1361,10 +1500,9 @@ class SecurityController extends NativeController {
     const deletionErrors = [];
     for (const strategy of createdStrategies) {
       try {
-        const del = this.getStrategyMethod(strategy, 'delete');
+        const del = this.getStrategyMethod(strategy, "delete");
         await del(request, id, strategy);
-      }
-      catch (e) {
+      } catch (e) {
         // We catch any error produced by delete as we want to make as much
         // cleanup as possible
         deletionErrors.push(e);
@@ -1372,22 +1510,22 @@ class SecurityController extends NativeController {
     }
 
     try {
-      this.ask('core:security:user:delete', id, { refresh: 'false' });
-    }
-    catch (e) {
+      this.ask("core:security:user:delete", id, { refresh: "false" });
+    } catch (e) {
       global.kuzzle.log.error(`User rollback error: ${e}`);
     }
 
     if (deletionErrors.length > 0) {
       // 2 errors > we
       throw kerror.get(
-        'plugin',
-        'runtime',
-        'unexpected_error',
+        "plugin",
+        "runtime",
+        "unexpected_error",
         [
           creationFailure.error.message,
-          ...deletionErrors.map(e => e.message)
-        ].join('\n'));
+          ...deletionErrors.map((e) => e.message),
+        ].join("\n")
+      );
     }
 
     if (creationFailure.error instanceof KuzzleError) {
@@ -1397,18 +1535,20 @@ class SecurityController extends NativeController {
     if (creationFailure.validation) {
       throw kerror.getFrom(
         creationFailure.error,
-        'security',
-        'credentials',
-        'rejected',
-        creationFailure.error.message);
+        "security",
+        "credentials",
+        "rejected",
+        creationFailure.error.message
+      );
     }
 
     throw kerror.getFrom(
       creationFailure.error,
-      'plugin',
-      'runtime',
-      'unexpected_error',
-      creationFailure.error.message);
+      "plugin",
+      "runtime",
+      "unexpected_error",
+      creationFailure.error.message
+    );
   }
 
   /**
@@ -1417,10 +1557,11 @@ class SecurityController extends NativeController {
    * @param {number} limit
    * @throws
    */
-  _getSearchPageSize (request) {
+  _getSearchPageSize(request) {
     const size = request.getInteger(
-      'size',
-      global.kuzzle.config.limits.documentsFetchCount);
+      "size",
+      global.kuzzle.config.limits.documentsFetchCount
+    );
 
     this.assertNotExceedMaxFetch(size);