kuzzle 2.19.2 → 2.19.3

package/lib/service/storage/elasticsearch.js

@@ -19,49 +19,54 @@
  * limitations under the License.
  */
 
-'use strict';
-
-const assert = require('assert');
-const _ = require('lodash');
-const { Client: StorageClient } = require('@elastic/elasticsearch');
-const ms = require('ms');
-const Bluebird = require('bluebird');
-const semver = require('semver');
-
-const debug = require('../../util/debug')('kuzzle:services:elasticsearch');
-const ESWrapper = require('./esWrapper');
-const QueryTranslator = require('./queryTranslator');
-const didYouMean = require('../../util/didYouMean');
-const Service = require('../service');
-const { assertIsObject } = require('../../util/requestAssertions');
-const kerror = require('../../kerror').wrap('services', 'storage');
-const { isPlainObject } = require('../../util/safeObject');
-const scopeEnum = require('../../core/storage/storeScopeEnum');
-const extractFields = require('../../util/extractFields');
-const { Mutex } = require('../../util/mutex');
-const { randomNumber } = require('../../util/name-generator');
-
-const SCROLL_CACHE_PREFIX = '_docscroll_';
-
-const ROOT_MAPPING_PROPERTIES = ['properties', '_meta', 'dynamic', 'dynamic_templates'];
-const CHILD_MAPPING_PROPERTIES = ['type'];
+"use strict";
+
+const assert = require("assert");
+const _ = require("lodash");
+const { Client: StorageClient } = require("@elastic/elasticsearch");
+const ms = require("ms");
+const Bluebird = require("bluebird");
+const semver = require("semver");
+
+const debug = require("../../util/debug")("kuzzle:services:elasticsearch");
+const ESWrapper = require("./esWrapper");
+const QueryTranslator = require("./queryTranslator");
+const didYouMean = require("../../util/didYouMean");
+const Service = require("../service");
+const { assertIsObject } = require("../../util/requestAssertions");
+const kerror = require("../../kerror").wrap("services", "storage");
+const { isPlainObject } = require("../../util/safeObject");
+const scopeEnum = require("../../core/storage/storeScopeEnum");
+const extractFields = require("../../util/extractFields");
+const { Mutex } = require("../../util/mutex");
+const { randomNumber } = require("../../util/name-generator");
+
+const SCROLL_CACHE_PREFIX = "_docscroll_";
+
+const ROOT_MAPPING_PROPERTIES = [
+  "properties",
+  "_meta",
+  "dynamic",
+  "dynamic_templates",
+];
+const CHILD_MAPPING_PROPERTIES = ["type"];
 
 // Used for collection emulation
-const HIDDEN_COLLECTION = '_kuzzle_keep';
-const ALIAS_PREFIX = '@'; // @todo next major release: Add ALIAS_PREFIX in FORBIDDEN_CHARS
-const PRIVATE_PREFIX = '%';
-const PUBLIC_PREFIX = '&';
+const HIDDEN_COLLECTION = "_kuzzle_keep";
+const ALIAS_PREFIX = "@"; // @todo next major release: Add ALIAS_PREFIX in FORBIDDEN_CHARS
+const PRIVATE_PREFIX = "%";
+const PUBLIC_PREFIX = "&";
 const INDEX_PREFIX_POSITION_IN_INDICE = 0;
 const INDEX_PREFIX_POSITION_IN_ALIAS = 1;
-const NAME_SEPARATOR = '.';
+const NAME_SEPARATOR = ".";
 const FORBIDDEN_CHARS = `\\/*?"<>| \t\r\n,+#:${NAME_SEPARATOR}${PUBLIC_PREFIX}${PRIVATE_PREFIX}`;
-const DYNAMIC_PROPERTY_VALUES = ['true', 'false', 'strict'];
+const DYNAMIC_PROPERTY_VALUES = ["true", "false", "strict"];
 
 // used to check whether we need to wait for ES to initialize or not
 const esStateEnum = Object.freeze({
-  'AWAITING': 1,
-  'NONE': 2,
-  'OK': 3,
+  AWAITING: 1,
+  NONE: 2,
+  OK: 3,
 });
 let esState = esStateEnum.NONE;
 
@@ -77,10 +82,10 @@ class ElasticSearch extends Service {
    *
    * @returns {Object}
    */
-  static buildClient (config) {
+  static buildClient(config) {
     // Passed to Elasticsearch's client to make it use
     // Bluebird instead of ES6 promises
-    const defer = function defer () {
+    const defer = function defer() {
       let resolve;
       let reject;
 
@@ -95,13 +100,12 @@ class ElasticSearch extends Service {
     return new StorageClient({ defer, ...config });
   }
 
-  constructor (config, scope = scopeEnum.PUBLIC) {
-    super('elasticsearch', config);
+  constructor(config, scope = scopeEnum.PUBLIC) {
+    super("elasticsearch", config);
 
     this._scope = scope;
-    this._indexPrefix = scope === scopeEnum.PRIVATE
-      ? PRIVATE_PREFIX
-      : PUBLIC_PREFIX;
+    this._indexPrefix =
+      scope === scopeEnum.PRIVATE ? PRIVATE_PREFIX : PUBLIC_PREFIX;
 
     this._client = null;
     this._esWrapper = null;
@@ -110,36 +114,36 @@ class ElasticSearch extends Service {
 
     // Allowed root key of a search query
     this.searchBodyKeys = [
-      'aggregations',
-      'aggs',
-      'collapse',
-      'explain',
-      'from',
-      'highlight',
-      'query',
-      'search_after',
-      'search_timeout',
-      'size',
-      'sort',
-      'suggest',
-      '_name',
-      '_source',
-      '_source_excludes',
-      '_source_includes'
+      "aggregations",
+      "aggs",
+      "collapse",
+      "explain",
+      "from",
+      "highlight",
+      "query",
+      "search_after",
+      "search_timeout",
+      "size",
+      "sort",
+      "suggest",
+      "_name",
+      "_source",
+      "_source_excludes",
+      "_source_includes",
     ];
 
     /**
      * Only allow stored-scripts in queries
      */
-    this.scriptKeys = ['script', '_script'];
-    this.scriptAllowedArgs = ['id', 'params'];
+    this.scriptKeys = ["script", "_script"];
+    this.scriptAllowedArgs = ["id", "params"];
 
-    this.maxScrollDuration = this._loadMsConfig('maxScrollDuration');
+    this.maxScrollDuration = this._loadMsConfig("maxScrollDuration");
 
-    this.scrollTTL = this._loadMsConfig('defaults.scrollTTL');
+    this.scrollTTL = this._loadMsConfig("defaults.scrollTTL");
   }
 
-  get scope () {
+  get scope() {
     return this._scope;
   }
 
@@ -149,19 +153,22 @@ class ElasticSearch extends Service {
    * @override
    * @returns {Promise}
    */
-  async _initSequence () {
+  async _initSequence() {
     if (this._client) {
       return;
     }
 
-    if ( global.NODE_ENV !== 'development'
-      && this._config.commonMapping.dynamic === 'true'
+    if (
+      global.NODE_ENV !== "development" &&
+      this._config.commonMapping.dynamic === "true"
     ) {
-      global.kuzzle.log.warn([
-        'Your dynamic mapping policy is set to \'true\' for new fields.',
-        'Elasticsearch will try to automatically infer mapping for new fields, and those cannot be changed afterward.',
-        'See the "services.storageEngine.commonMapping.dynamic" option in the kuzzlerc configuration file to change this value.'
-      ].join('\n'));
+      global.kuzzle.log.warn(
+        [
+          "Your dynamic mapping policy is set to 'true' for new fields.",
+          "Elasticsearch will try to automatically infer mapping for new fields, and those cannot be changed afterward.",
+          'See the "services.storageEngine.commonMapping.dynamic" option in the kuzzlerc configuration file to change this value.',
+        ].join("\n")
+      );
     }
 
     this._client = ElasticSearch.buildClient(this._config.client);
@@ -170,10 +177,15 @@ class ElasticSearch extends Service {
 
     this._esWrapper = new ESWrapper(this._client);
 
-    const { body: { version } } = await this._client.info();
+    const {
+      body: { version },
+    } = await this._client.info();
 
-    if (version && ! semver.satisfies(semver.coerce(version.number), '>= 7.0.0')) {
-      throw kerror.get('version_mismatch', version.number);
+    if (
+      version &&
+      !semver.satisfies(semver.coerce(version.number), ">= 7.0.0")
+    ) {
+      throw kerror.get("version_mismatch", version.number);
     }
 
     this._esVersion = version;
@@ -185,7 +197,7 @@ class ElasticSearch extends Service {
    * @param {Object} filters - Set of valid Koncorde filters
    * @returns {Object} Equivalent Elasticsearch query
    */
-  translateKoncordeFilters (filters) {
+  translateKoncordeFilters(filters) {
     return this._translator.translate(filters);
   }
 
@@ -195,13 +207,14 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<Object>} service informations
    */
-  info () {
+  info() {
     const result = {
-      type: 'elasticsearch',
-      version: this._esVersion
+      type: "elasticsearch",
+      version: this._esVersion,
     };
 
-    return this._client.info()
+    return this._client
+      .info()
       .then(({ body }) => {
         result.version = body.version.number;
         result.lucene = body.version.lucene_version;
@@ -219,7 +232,7 @@ class ElasticSearch extends Service {
 
         return result;
       })
-      .catch(error => this._esWrapper.reject(error));
+      .catch((error) => this._esWrapper.reject(error));
   }
 
   /**
@@ -227,9 +240,9 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<Object>}
    */
-  async stats () {
+  async stats() {
     const esRequest = {
-      metric: ['docs', 'store'],
+      metric: ["docs", "store"],
     };
 
     const { body } = await this._client.indices.stats(esRequest);
@@ -238,8 +251,10 @@ class ElasticSearch extends Service {
 
     for (const [indice, indiceInfo] of Object.entries(body.indices)) {
       // Ignore non-Kuzzle indices
-      if ( indice[INDEX_PREFIX_POSITION_IN_INDICE] !== PRIVATE_PREFIX
-        && indice[INDEX_PREFIX_POSITION_IN_INDICE] !== PUBLIC_PREFIX ) {
+      if (
+        indice[INDEX_PREFIX_POSITION_IN_INDICE] !== PRIVATE_PREFIX &&
+        indice[INDEX_PREFIX_POSITION_IN_INDICE] !== PUBLIC_PREFIX
+      ) {
         continue;
       }
 
@@ -248,12 +263,14 @@ class ElasticSearch extends Service {
       const indexName = this._extractIndex(alias);
       const collectionName = this._extractCollection(alias);
 
-      if ( alias[INDEX_PREFIX_POSITION_IN_ALIAS] !== this._indexPrefix
-        || collectionName === HIDDEN_COLLECTION ) {
+      if (
+        alias[INDEX_PREFIX_POSITION_IN_ALIAS] !== this._indexPrefix ||
+        collectionName === HIDDEN_COLLECTION
+      ) {
         continue;
       }
 
-      if (! indexes[indexName]) {
+      if (!indexes[indexName]) {
         indexes[indexName] = {
           collections: [],
           name: indexName,
@@ -285,29 +302,33 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ scrollId, hits, aggregations, total }>}
    */
-  async scroll (scrollId, { scrollTTL } = {}) {
+  async scroll(scrollId, { scrollTTL } = {}) {
     const _scrollTTL = scrollTTL || this._config.defaults.scrollTTL;
     const esRequest = {
       scroll: _scrollTTL,
       scrollId,
     };
 
-    const cacheKey = SCROLL_CACHE_PREFIX + global.kuzzle.hash(esRequest.scrollId);
+    const cacheKey =
+      SCROLL_CACHE_PREFIX + global.kuzzle.hash(esRequest.scrollId);
 
-    debug('Scroll: %o', esRequest);
+    debug("Scroll: %o", esRequest);
 
     if (_scrollTTL) {
       const scrollDuration = ms(_scrollTTL);
 
       if (scrollDuration > this.maxScrollDuration) {
-        throw kerror.get('scroll_duration_too_great', _scrollTTL);
+        throw kerror.get("scroll_duration_too_great", _scrollTTL);
       }
     }
 
-    const stringifiedScrollInfo = await global.kuzzle.ask('core:cache:internal:get', cacheKey);
+    const stringifiedScrollInfo = await global.kuzzle.ask(
+      "core:cache:internal:get",
+      cacheKey
+    );
 
-    if (! stringifiedScrollInfo) {
-      throw kerror.get('unknown_scroll_id');
+    if (!stringifiedScrollInfo) {
+      throw kerror.get("unknown_scroll_id");
     }
 
     const scrollInfo = JSON.parse(stringifiedScrollInfo);
@@ -318,25 +339,24 @@ class ElasticSearch extends Service {
       scrollInfo.fetched += body.hits.hits.length;
 
       if (scrollInfo.fetched >= body.hits.total.value) {
-        debug('Last scroll page fetched: deleting scroll %s', body._scroll_id);
-        await global.kuzzle.ask('core:cache:internal:del', cacheKey);
+        debug("Last scroll page fetched: deleting scroll %s", body._scroll_id);
+        await global.kuzzle.ask("core:cache:internal:del", cacheKey);
         await this.clearScroll(body._scroll_id);
-      }
-      else {
+      } else {
         await global.kuzzle.ask(
-          'core:cache:internal:store',
+          "core:cache:internal:store",
           cacheKey,
           JSON.stringify(scrollInfo),
           {
             ttl: ms(_scrollTTL) || this.scrollTTL,
-          });
+          }
+        );
       }
 
       body.remaining = body.hits.total.value - scrollInfo.fetched;
 
       return await this._formatSearchResult(body, scrollInfo);
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
@@ -351,7 +371,7 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ scrollId, hits, aggregations, suggest, total }>}
    */
-  async search (
+  async search(
     { index, collection, searchBody, targets } = {},
     { from, size, scroll } = {}
   ) {
@@ -367,9 +387,8 @@ class ElasticSearch extends Service {
         }
       }
 
-      esIndexes = Array.from(indexes).join(',');
-    }
-    else {
+      esIndexes = Array.from(indexes).join(",");
+    } else {
       esIndexes = this._getAlias(index, collection);
     }
 
@@ -386,29 +405,31 @@ class ElasticSearch extends Service {
       const scrollDuration = ms(scroll);
 
       if (scrollDuration > this.maxScrollDuration) {
-        throw kerror.get('scroll_duration_too_great', scroll);
+        throw kerror.get("scroll_duration_too_great", scroll);
       }
     }
 
-    debug('Search: %j', esRequest);
+    debug("Search: %j", esRequest);
 
     try {
       const { body } = await this._client.search(esRequest);
 
       if (body._scroll_id) {
-        const ttl = esRequest.scroll && ms(esRequest.scroll)
-          || ms(this._config.defaults.scrollTTL);
+        const ttl =
+          (esRequest.scroll && ms(esRequest.scroll)) ||
+          ms(this._config.defaults.scrollTTL);
 
         await global.kuzzle.ask(
-          'core:cache:internal:store',
+          "core:cache:internal:store",
           SCROLL_CACHE_PREFIX + global.kuzzle.hash(body._scroll_id),
           JSON.stringify({
             collection,
             fetched: body.hits.hits.length,
             index,
-            targets
+            targets,
           }),
-          { ttl });
+          { ttl }
+        );
 
         body.remaining = body.hits.total.value - body.hits.hits.length;
       }
@@ -416,27 +437,26 @@ class ElasticSearch extends Service {
       return await this._formatSearchResult(body, {
         collection,
         index,
-        targets
+        targets,
       });
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
 
   /**
    * Generate a map that associate an alias to a pair of index and collection
-   * 
-   * @param {*} targets 
-   * @returns 
+   *
+   * @param {*} targets
+   * @returns
    */
-  _mapTargetsToAlias (targets) {
+  _mapTargetsToAlias(targets) {
     const aliasToTargets = {};
 
     for (const target of targets) {
       for (const targetCollection of target.collections) {
         const alias = this._getAlias(target.index, targetCollection);
-        if (! aliasToTargets[alias]) {
+        if (!aliasToTargets[alias]) {
           aliasToTargets[alias] = {
             collection: targetCollection,
             index: target.index,
@@ -448,7 +468,7 @@ class ElasticSearch extends Service {
     return aliasToTargets;
   }
 
-  async _formatSearchResult (body, searchInfo = {}) {
+  async _formatSearchResult(body, searchInfo = {}) {
     let aliasToTargets = {};
     const aliasCache = new Map();
 
@@ -470,10 +490,9 @@ class ElasticSearch extends Service {
        * retrieve the appropriate index and collection based on the alias
        */
       if (hit._index && searchInfo.targets) {
-
         // Caching to reduce call to ES
         let aliases = aliasCache.get(hit._index);
-        if (! aliases) {
+        if (!aliases) {
           // Retrieve all the alias associated to one index
           aliases = await this._getAliasFromIndice(hit._index);
           aliasCache.set(hit._index, aliases);
@@ -484,7 +503,7 @@ class ElasticSearch extends Service {
          * find the first alias that exists in the map of aliases associated
          * to the targets.
          */
-        const alias = aliases.find(_alias => aliasToTargets[_alias]);
+        const alias = aliases.find((_alias) => aliasToTargets[_alias]);
         // Retrieve index and collection information based on the matching alias
         index = aliasToTargets[alias].index;
         collection = aliasToTargets[alias].collection;
@@ -500,21 +519,24 @@ class ElasticSearch extends Service {
       };
     };
 
-    async function formatInnerHits (innerHits) {
-      if (! innerHits) {
+    async function formatInnerHits(innerHits) {
+      if (!innerHits) {
         return undefined;
       }
 
       const formattedInnerHits = {};
       for (const [name, innerHit] of Object.entries(innerHits)) {
-        formattedInnerHits[name] = await Bluebird.map(innerHit.hits.hits, formatHit);
+        formattedInnerHits[name] = await Bluebird.map(
+          innerHit.hits.hits,
+          formatHit
+        );
       }
       return formattedInnerHits;
     }
 
-    const hits = await Bluebird.map(body.hits.hits, async hit => ({
+    const hits = await Bluebird.map(body.hits.hits, async (hit) => ({
       inner_hits: await formatInnerHits(hit.inner_hits),
-      ...await formatHit(hit)
+      ...(await formatHit(hit)),
     }));
 
     return {
@@ -536,20 +558,20 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ _id, _version, _source }>}
    */
-  async get (index, collection, id) {
+  async get(index, collection, id) {
     const esRequest = {
       id,
-      index: this._getAlias(index, collection)
+      index: this._getAlias(index, collection),
     };
 
     // Just in case the user make a GET on url /mainindex/test/_search
     // Without this test we return something weird: a result.hits.hits with all
     // document without filter because the body is empty in HTTP by default
-    if (esRequest.id === '_search') {
-      return kerror.reject('search_as_an_id');
+    if (esRequest.id === "_search") {
+      return kerror.reject("search_as_an_id");
     }
 
-    debug('Get document: %o', esRequest);
+    debug("Get document: %o", esRequest);
 
     try {
       const { body } = await this._client.get(esRequest);
@@ -557,10 +579,9 @@ class ElasticSearch extends Service {
       return {
         _id: body._id,
         _source: body._source,
-        _version: body._version
+        _version: body._version,
       };
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
@@ -576,31 +597,32 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ items: Array<{ _id, _source, _version }>, errors }>}
    */
-  async mGet (index, collection, ids) {
+  async mGet(index, collection, ids) {
     if (ids.length === 0) {
       return { errors: [], item: [] };
     }
 
     const esRequest = {
       body: {
-        docs: ids.map(_id => ({ _id, _index: this._getAlias(index, collection) }))
-      }
+        docs: ids.map((_id) => ({
+          _id,
+          _index: this._getAlias(index, collection),
+        })),
+      },
     };
 
-    debug('Multi-get documents: %o', esRequest);
+    debug("Multi-get documents: %o", esRequest);
 
     let body;
 
     try {
       ({ body } = await this._client.mget(esRequest)); // NOSONAR
-    }
-    catch (e) {
+    } catch (e) {
       throw this._esWrapper.formatESError(e);
     }
 
-    const
-      errors = [],
-      items = [];
+    const errors = [];
+    const items = [];
 
     for (let i = 0; i < body.docs.length; i++) {
       const doc = body.docs[i];
@@ -609,10 +631,9 @@ class ElasticSearch extends Service {
         items.push({
           _id: doc._id,
           _source: doc._source,
-          _version: doc._version
+          _version: doc._version,
         });
-      }
-      else {
+      } else {
         errors.push(doc._id);
       }
     }
@@ -629,19 +650,18 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<Number>} count
    */
-  async count (index, collection, searchBody = {}) {
+  async count(index, collection, searchBody = {}) {
     const esRequest = {
       body: this._sanitizeSearchBody(searchBody),
-      index: this._getAlias(index, collection)
+      index: this._getAlias(index, collection),
     };
 
-    debug('Count: %o', esRequest);
+    debug("Count: %o", esRequest);
 
     try {
       const { body } = await this._client.count(esRequest);
       return body.count;
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
@@ -657,19 +677,20 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<Object>} { _id, _version, _source }
    */
-  async create (
+  async create(
     index,
     collection,
     content,
-    { id, refresh, userId = null } = {}) {
+    { id, refresh, userId = null } = {}
+  ) {
     assertIsObject(content);
 
     const esRequest = {
       body: content,
       id,
       index: this._getAlias(index, collection),
-      op_type: id ? 'create' : 'index',
-      refresh
+      op_type: id ? "create" : "index",
+      refresh,
     };
 
     assertNoRouting(esRequest);
@@ -680,10 +701,10 @@ class ElasticSearch extends Service {
       author: getKuid(userId),
       createdAt: Date.now(),
       updatedAt: null,
-      updater: null
+      updater: null,
     };
 
-    debug('Create document: %o', esRequest);
+    debug("Create document: %o", esRequest);
 
     try {
       const { body } = await this._client.index(esRequest);
@@ -691,10 +712,9 @@ class ElasticSearch extends Service {
       return {
         _id: body._id,
         _source: esRequest.body,
-        _version: body._version
+        _version: body._version,
       };
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
@@ -710,17 +730,18 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<Object>} { _id, _version, _source, created }
    */
-  async createOrReplace (
+  async createOrReplace(
     index,
     collection,
     id,
     content,
-    { refresh, userId = null, injectKuzzleMeta = true } = {}) {
+    { refresh, userId = null, injectKuzzleMeta = true } = {}
+  ) {
     const esRequest = {
       body: content,
       id,
       index: this._getAlias(index, collection),
-      refresh
+      refresh,
     };
 
     assertNoRouting(esRequest);
@@ -732,11 +753,11 @@ class ElasticSearch extends Service {
         author: getKuid(userId),
         createdAt: Date.now(),
         updatedAt: Date.now(),
-        updater: getKuid(userId)
+        updater: getKuid(userId),
       };
     }
 
-    debug('Create or replace document: %o', esRequest);
+    debug("Create or replace document: %o", esRequest);
 
     try {
       const { body } = await this._client.index(esRequest);
@@ -745,10 +766,9 @@ class ElasticSearch extends Service {
         _id: body._id,
         _source: esRequest.body,
         _version: body._version,
-        created: body.result === 'created' // Needed by the notifier
+        created: body.result === "created", // Needed by the notifier
       };
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
@@ -764,19 +784,21 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ _id, _version }>}
    */
-  async update (
+  async update(
     index,
     collection,
     id,
     content,
-    { refresh, userId = null, retryOnConflict } = {}) {
+    { refresh, userId = null, retryOnConflict } = {}
+  ) {
     const esRequest = {
       _source: true,
       body: { doc: content },
       id,
       index: this._getAlias(index, collection),
       refresh,
-      retry_on_conflict: retryOnConflict || this._config.defaults.onUpdateConflictRetries
+      retry_on_conflict:
+        retryOnConflict || this._config.defaults.onUpdateConflictRetries,
     };
 
     assertNoRouting(esRequest);
@@ -785,20 +807,19 @@ class ElasticSearch extends Service {
     // Add metadata
     esRequest.body.doc._kuzzle_info = {
       updatedAt: Date.now(),
-      updater: getKuid(userId)
+      updater: getKuid(userId),
     };
 
-    debug('Update document: %o', esRequest);
+    debug("Update document: %o", esRequest);
 
     try {
       const { body } = await this._client.update(esRequest);
       return {
         _id: body._id,
         _source: body.get._source,
-        _version: body._version
+        _version: body._version,
       };
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
@@ -815,12 +836,13 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ _id, _version }>}
    */
-  async upsert (
+  async upsert(
     index,
     collection,
     id,
     content,
-    { defaultValues = {}, refresh, userId = null, retryOnConflict } = {}) {
+    { defaultValues = {}, refresh, userId = null, retryOnConflict } = {}
+  ) {
     const esRequest = {
       _source: true,
       body: {
@@ -830,7 +852,8 @@ class ElasticSearch extends Service {
       id,
       index: this._getAlias(index, collection),
       refresh,
-      retry_on_conflict: retryOnConflict || this._config.defaults.onUpdateConflictRetries,
+      retry_on_conflict:
+        retryOnConflict || this._config.defaults.onUpdateConflictRetries,
     };
 
     assertNoRouting(esRequest);
@@ -849,7 +872,7 @@ class ElasticSearch extends Service {
       createdAt: now,
     };
 
-    debug('Upsert document: %o', esRequest);
+    debug("Upsert document: %o", esRequest);
 
     try {
       const { body } = await this._client.update(esRequest);
@@ -858,10 +881,9 @@ class ElasticSearch extends Service {
         _id: body._id,
         _source: body.get._source,
         _version: body._version,
-        created: body.result === 'created',
+        created: body.result === "created",
       };
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
@@ -877,18 +899,19 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ _id, _version, _source }>}
    */
-  async replace (
+  async replace(
     index,
     collection,
     id,
     content,
-    { refresh, userId = null } = {}) {
+    { refresh, userId = null } = {}
+  ) {
     const alias = this._getAlias(index, collection);
     const esRequest = {
       body: content,
       id,
       index: alias,
-      refresh
+      refresh,
     };
 
     assertNoRouting(esRequest);
@@ -899,27 +922,26 @@ class ElasticSearch extends Service {
       author: getKuid(userId),
       createdAt: Date.now(),
       updatedAt: Date.now(),
-      updater: getKuid(userId)
+      updater: getKuid(userId),
     };
 
     try {
       const { body: exists } = await this._client.exists({ id, index: alias });
 
-      if (! exists) {
-        throw kerror.get('not_found', id, index, collection);
+      if (!exists) {
+        throw kerror.get("not_found", id, index, collection);
       }
 
-      debug('Replace document: %o', esRequest);
+      debug("Replace document: %o", esRequest);
 
       const { body } = await this._client.index(esRequest);
 
       return {
         _id: id,
         _source: esRequest.body,
-        _version: body._version
+        _version: body._version,
       };
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
@@ -934,25 +956,20 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise}
    */
-  async delete (
-    index,
-    collection,
-    id,
-    { refresh } = {}) {
+  async delete(index, collection, id, { refresh } = {}) {
     const esRequest = {
       id,
       index: this._getAlias(index, collection),
-      refresh
+      refresh,
     };
 
     assertWellFormedRefresh(esRequest);
 
-    debug('Delete document: %o', esRequest);
+    debug("Delete document: %o", esRequest);
 
     try {
       await this._client.delete(esRequest);
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
     return null;
@@ -974,20 +991,21 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ documents, total, deleted, failures: Array<{ _shardId, reason }> }>}
    */
-  async deleteByQuery (
+  async deleteByQuery(
     index,
     collection,
     query,
-    { refresh, size = 1000, fetch = true } = {}) {
+    { refresh, size = 1000, fetch = true } = {}
+  ) {
     const esRequest = {
       body: this._sanitizeSearchBody({ query }),
       index: this._getAlias(index, collection),
-      scroll: '5s',
-      size
+      scroll: "5s",
+      size,
     };
 
-    if (! isPlainObject(query)) {
-      throw kerror.get('missing_argument', 'body.query');
+    if (!isPlainObject(query)) {
+      throw kerror.get("missing_argument", "body.query");
     }
 
     try {
@@ -997,21 +1015,22 @@ class ElasticSearch extends Service {
         documents = await this._getAllDocumentsFromQuery(esRequest);
       }
 
-      debug('Delete by query: %o', esRequest);
+      debug("Delete by query: %o", esRequest);
 
-      esRequest.refresh = refresh === 'wait_for' ? true : refresh;
+      esRequest.refresh = refresh === "wait_for" ? true : refresh;
 
       const { body } = await this._client.deleteByQuery(esRequest);
 
       return {
         deleted: body.deleted,
         documents,
-        failures: body.failures
-          .map(({ shardId, reason }) => ({ reason, shardId })),
+        failures: body.failures.map(({ shardId, reason }) => ({
+          reason,
+          shardId,
+        })),
         total: body.total,
       };
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
@@ -1027,12 +1046,13 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ _id, _version, _source }>}
    */
-  async deleteFields (
+  async deleteFields(
     index,
     collection,
     id,
     fields,
-    { refresh, userId = null } = {}) {
+    { refresh, userId = null } = {}
+  ) {
     const alias = this._getAlias(index, collection);
     const esRequest = {
       id,
@@ -1040,7 +1060,7 @@ class ElasticSearch extends Service {
     };
 
     try {
-      debug('DeleteFields document: %o', esRequest);
+      debug("DeleteFields document: %o", esRequest);
       const { body } = await this._client.get(esRequest);
 
       for (const field of fields) {
@@ -1052,14 +1072,14 @@ class ElasticSearch extends Service {
       body._source._kuzzle_info = {
         ...body._source._kuzzle_info,
         updatedAt: Date.now(),
-        updater: getKuid(userId)
+        updater: getKuid(userId),
       };
 
       const newEsRequest = {
         body: body._source,
         id,
         index: alias,
-        refresh
+        refresh,
       };
 
       assertNoRouting(newEsRequest);
@@ -1070,38 +1090,37 @@ class ElasticSearch extends Service {
       return {
         _id: id,
         _source: body._source,
-        _version: updated._version
+        _version: updated._version,
       };
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
 
   /**
-  * Updates all documents matching the provided filters
-  *
-  * @param {String} index - Index name
-  * @param {String} collection - Collection name
-  * @param {Object} query - Query to match documents
-  * @param {Object} changes - Changes wanted on documents
-  * @param {Object} options - refresh (undefined), size (undefined)
-  *
-  * @returns {Promise.<{ successes: [_id, _source, _status], errors: [ document, status, reason ] }>}
-  */
-  async updateByQuery (
+   * Updates all documents matching the provided filters
+   *
+   * @param {String} index - Index name
+   * @param {String} collection - Collection name
+   * @param {Object} query - Query to match documents
+   * @param {Object} changes - Changes wanted on documents
+   * @param {Object} options - refresh (undefined), size (undefined)
+   *
+   * @returns {Promise.<{ successes: [_id, _source, _status], errors: [ document, status, reason ] }>}
+   */
+  async updateByQuery(
     index,
     collection,
     query,
     changes,
-    { refresh, size = 1000, userId = null } = {}) {
-
+    { refresh, size = 1000, userId = null } = {}
+  ) {
     try {
       const esRequest = {
         body: this._sanitizeSearchBody({ query }),
         index: this._getAlias(index, collection),
-        scroll: '5s',
-        size
+        scroll: "5s",
+        size,
       };
 
       const documents = await this._getAllDocumentsFromQuery(esRequest);
@@ -1113,44 +1132,45 @@ class ElasticSearch extends Service {
         document.body = changes;
       }
 
-      debug('Update by query: %o', esRequest);
+      debug("Update by query: %o", esRequest);
 
       const { errors, items } = await this.mUpdate(
         index,
         collection,
         documents,
-        { refresh, userId });
+        { refresh, userId }
+      );
 
       return {
         errors,
-        successes: items
+        successes: items,
       };
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
 
   /**
-  * Updates all documents matching the provided filters
-  *
-  * @param {String} index - Index name
-  * @param {String} collection - Collection name
-  * @param {Object} query - Query to match documents
-  * @param {Object} changes - Changes wanted on documents
-  * @param {Object} options - refresh (undefined)
-  *
-  * @returns {Promise.<{ successes: [_id, _source, _status], errors: [ document, status, reason ] }>}
-  */
-  async bulkUpdateByQuery (
+   * Updates all documents matching the provided filters
+   *
+   * @param {String} index - Index name
+   * @param {String} collection - Collection name
+   * @param {Object} query - Query to match documents
+   * @param {Object} changes - Changes wanted on documents
+   * @param {Object} options - refresh (undefined)
+   *
+   * @returns {Promise.<{ successes: [_id, _source, _status], errors: [ document, status, reason ] }>}
+   */
+  async bulkUpdateByQuery(
     index,
     collection,
     query,
     changes,
-    { refresh = 'false' } = {}) {
+    { refresh = "false" } = {}
+  ) {
     const script = {
       params: {},
-      source: ''
+      source: "",
     };
 
     const flatChanges = extractFields(changes, { alsoExtractValues: true });
@@ -1166,28 +1186,29 @@ class ElasticSearch extends Service {
         script,
       },
       index: this._getAlias(index, collection),
-      refresh
+      refresh,
     };
 
-    debug('Bulk Update by query: %o', esRequest);
+    debug("Bulk Update by query: %o", esRequest);
 
     let response;
     try {
       response = await this._client.updateByQuery(esRequest);
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
 
     if (response.body.failures.length) {
-      const errors = response.body.failures
-        .map(({ shardId, reason }) => ({ reason, shardId }));
+      const errors = response.body.failures.map(({ shardId, reason }) => ({
+        reason,
+        shardId,
+      }));
 
-      throw kerror.get('incomplete_update', response.body.updated, errors);
+      throw kerror.get("incomplete_update", response.body.updated, errors);
     }
 
     return {
-      updated: response.body.updated
+      updated: response.body.updated,
     };
   }
 
@@ -1203,22 +1224,23 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<any[]>} Array of results returned by the callback
    */
-  async mExecute (
+  async mExecute(
     index,
     collection,
     query,
     callback,
-    { size = 10, scrollTTl = '5s' } = {}) {
+    { size = 10, scrollTTl = "5s" } = {}
+  ) {
     const esRequest = {
       body: this._sanitizeSearchBody({ query }),
       from: 0,
       index: this._getAlias(index, collection),
       scroll: scrollTTl,
-      size
+      size,
     };
 
-    if (! isPlainObject(query)) {
-      throw kerror.get('missing_argument', 'body.query');
+    if (!isPlainObject(query)) {
+      throw kerror.get("missing_argument", "body.query");
     }
 
     const client = this._client;
@@ -1231,7 +1253,10 @@ class ElasticSearch extends Service {
       results = await new Bluebird((resolve, reject) => {
         this._client.search(
           esRequest,
-          async function getMoreUntilDone (error, { body: { hits, _scroll_id } }) {
+          async function getMoreUntilDone(
+            error,
+            { body: { hits, _scroll_id } }
+          ) {
             if (error) {
               reject(error);
               return;
@@ -1245,18 +1270,20 @@ class ElasticSearch extends Service {
             processed += hits.hits.length;
 
             if (hits.total.value !== processed) {
-              client.scroll({
-                scroll: esRequest.scroll,
-                scrollId: _scroll_id
-              }, getMoreUntilDone);
-            }
-            else {
+              client.scroll(
+                {
+                  scroll: esRequest.scroll,
+                  scrollId: _scroll_id,
+                },
+                getMoreUntilDone
+              );
+            } else {
               resolve(results);
             }
-          });
+          }
+        );
       });
-    }
-    finally {
+    } finally {
       this.clearScroll(scrollId);
     }
 
@@ -1275,15 +1302,14 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise}
    */
-  async createIndex (index) {
+  async createIndex(index) {
     this._assertValidIndexAndCollection(index);
 
     let body;
 
     try {
-      ({ body } = await this._client.cat.aliases({ format: 'json' })); // NOSONAR
-    }
-    catch (error) {
+      ({ body } = await this._client.cat.aliases({ format: "json" })); // NOSONAR
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
 
@@ -1292,11 +1318,12 @@ class ElasticSearch extends Service {
       const indexName = this._extractIndex(alias);
 
       if (index === indexName) {
-        const indexType = alias[INDEX_PREFIX_POSITION_IN_ALIAS] === PRIVATE_PREFIX
-          ? 'private'
-          : 'public';
+        const indexType =
+          alias[INDEX_PREFIX_POSITION_IN_ALIAS] === PRIVATE_PREFIX
+            ? "private"
+            : "public";
 
-        throw kerror.get('index_already_exists', indexType, index);
+        throw kerror.get("index_already_exists", indexType, index);
       }
     }
 
@@ -1315,11 +1342,15 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise}
    */
-  async createCollection (index, collection, { mappings = {}, settings = {} } = {}) {
+  async createCollection(
+    index,
+    collection,
+    { mappings = {}, settings = {} } = {}
+  ) {
     this._assertValidIndexAndCollection(index, collection);
 
     if (collection === HIDDEN_COLLECTION) {
-      throw kerror.get('collection_reserved', HIDDEN_COLLECTION);
+      throw kerror.get("collection_reserved", HIDDEN_COLLECTION);
     }
 
     const mutex = new Mutex(`hiddenCollection/create/${index}`);
@@ -1329,21 +1360,19 @@ class ElasticSearch extends Service {
       if (await this._hasHiddenCollection(index)) {
         await this.deleteCollection(index, HIDDEN_COLLECTION);
       }
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
-    }
-    finally {
+    } finally {
       await mutex.unlock();
     }
 
     const esRequest = {
       body: {
         aliases: {
-          [this._getAlias(index, collection)]: {}
+          [this._getAlias(index, collection)]: {},
         },
         mappings: {},
-        settings
+        settings,
       },
       index: await this._getAvailableIndice(index, collection),
     };
@@ -1362,14 +1391,17 @@ class ElasticSearch extends Service {
       dynamic: mappings.dynamic || this._config.commonMapping.dynamic,
       properties: _.merge(
         mappings.properties,
-        this._config.commonMapping.properties)
+        this._config.commonMapping.properties
+      ),
     };
 
     try {
       await this._client.indices.create(esRequest);
-    }
-    catch (error) {
-      if (_.get(error, 'meta.body.error.type') === 'resource_already_exists_exception') {
+    } catch (error) {
+      if (
+        _.get(error, "meta.body.error.type") ===
+        "resource_already_exists_exception"
+      ) {
         // race condition: the indice has been created between the "exists"
         // check above and this "create" attempt
         return null;
@@ -1381,6 +1413,31 @@ class ElasticSearch extends Service {
     return null;
   }
 
+  /**
+   * Retrieves settings definition for index/type
+   *
+   * @param {String} index - Index name
+   * @param {String} collection - Collection name
+   *
+   * @returns {Promise.<{ settings }>}
+   */
+  async getSettings(index, collection) {
+    const indice = await this._getIndice(index, collection);
+    const esRequest = {
+      index: indice,
+    };
+
+    debug("Get settings: %o", esRequest);
+
+    try {
+      const { body } = await this._client.indices.getSettings(esRequest);
+
+      return body[indice].settings.index;
+    } catch (error) {
+      throw this._esWrapper.formatESError(error);
+    }
+  }
+
   /**
    * Retrieves mapping definition for index/type
    *
@@ -1390,29 +1447,27 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ dynamic, _meta, properties }>}
    */
-  async getMapping (index, collection, { includeKuzzleMeta = false } = {}) {
-    const
-      indice = await this._getIndice(index, collection),
-      esRequest = {
-        index: indice
-      };
+  async getMapping(index, collection, { includeKuzzleMeta = false } = {}) {
+    const indice = await this._getIndice(index, collection);
+    const esRequest = {
+      index: indice,
+    };
 
-    debug('Get mapping: %o', esRequest);
+    debug("Get mapping: %o", esRequest);
 
     try {
       const { body } = await this._client.indices.getMapping(esRequest);
 
       const properties = includeKuzzleMeta
         ? body[indice].mappings.properties
-        : _.omit(body[indice].mappings.properties, '_kuzzle_info');
+        : _.omit(body[indice].mappings.properties, "_kuzzle_info");
 
       return {
         _meta: body[indice].mappings._meta,
         dynamic: body[indice].mappings.dynamic,
-        properties
+        properties,
       };
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
@@ -1426,9 +1481,13 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise}
    */
-  async updateCollection (index, collection, { mappings = {}, settings = {} } = {}) {
+  async updateCollection(
+    index,
+    collection,
+    { mappings = {}, settings = {} } = {}
+  ) {
     const esRequest = {
-      index: await this._getIndice(index, collection)
+      index: await this._getIndice(index, collection),
     };
 
     // If either the putMappings or the putSettings operation fail, we need to
@@ -1438,17 +1497,16 @@ class ElasticSearch extends Service {
     let indexSettings;
     try {
       indexSettings = await this._getSettings(esRequest);
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
 
-    if (! _.isEmpty(settings)) {
+    if (!_.isEmpty(settings)) {
       await this.updateSettings(index, collection, settings);
     }
 
     try {
-      if (! _.isEmpty(mappings)) {
+      if (!_.isEmpty(mappings)) {
         const previousMappings = await this.getMapping(index, collection);
 
         await this.updateMapping(index, collection, mappings);
@@ -1457,12 +1515,11 @@ class ElasticSearch extends Service {
           await this.updateSearchIndex(index, collection);
         }
       }
-    }
-    catch (error) {
+    } catch (error) {
       const allowedSettings = this.getAllowedIndexSettings(indexSettings);
 
       // Rollback to previous settings
-      if (! _.isEmpty(settings)) {
+      if (!_.isEmpty(settings)) {
         await this.updateSettings(index, collection, allowedSettings);
       }
 
@@ -1478,26 +1535,29 @@ class ElasticSearch extends Service {
    * @param indexSettings the index settings
    * @returns {{index: *}} a new index settings with only allowed settings.
    */
-  getAllowedIndexSettings (indexSettings) {
+  getAllowedIndexSettings(indexSettings) {
     return {
-      index: _.omit(
-        indexSettings.index,
-        ['creation_date', 'provided_name', 'uuid', 'version'])
+      index: _.omit(indexSettings.index, [
+        "creation_date",
+        "provided_name",
+        "uuid",
+        "version",
+      ]),
     };
   }
 
   /**
-  * Sends an empty UpdateByQuery request to update the search index
-  *
-  * @param {String} index - Index name
-  * @param {String} collection - Collection name
-  * @returns {Promise.<Object>} {}
-  */
-  async updateSearchIndex (index, collection) {
+   * Sends an empty UpdateByQuery request to update the search index
+   *
+   * @param {String} index - Index name
+   * @param {String} collection - Collection name
+   * @returns {Promise.<Object>} {}
+   */
+  async updateSearchIndex(index, collection) {
     const esRequest = {
       body: {},
       // @cluster: conflicts when two nodes start at the same time
-      conflicts: 'proceed',
+      conflicts: "proceed",
       index: this._getAlias(index, collection),
       refresh: true,
       // This operation can take some time: this should be an ES
@@ -1506,12 +1566,11 @@ class ElasticSearch extends Service {
       waitForCompletion: false,
     };
 
-    debug('UpdateByQuery: %o', esRequest);
+    debug("UpdateByQuery: %o", esRequest);
 
     try {
       await this._client.updateByQuery(esRequest);
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
@@ -1525,9 +1584,9 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ dynamic, _meta, properties }>}
    */
-  async updateMapping (index, collection, mappings = {}) {
+  async updateMapping(index, collection, mappings = {}) {
     const esRequest = {
-      index: this._getAlias(index, collection)
+      index: this._getAlias(index, collection),
     };
 
     this._checkDynamicProperty(mappings);
@@ -1539,26 +1598,26 @@ class ElasticSearch extends Service {
     esRequest.body = {
       _meta: mappings._meta || collectionMappings._meta,
       dynamic: mappings.dynamic || collectionMappings.dynamic,
-      properties: mappings.properties
+      properties: mappings.properties,
     };
 
-    debug('Update mapping: %o', esRequest);
+    debug("Update mapping: %o", esRequest);
 
     try {
       await this._client.indices.putMapping(esRequest);
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
 
     const fullProperties = _.merge(
       collectionMappings.properties,
-      mappings.properties);
+      mappings.properties
+    );
 
     return {
       _meta: esRequest.body._meta,
       dynamic: esRequest.body.dynamic,
-      properties: fullProperties
+      properties: fullProperties,
     };
   }
 
@@ -1571,20 +1630,18 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise}
    */
-  async updateSettings (index, collection, settings = {}) {
+  async updateSettings(index, collection, settings = {}) {
     const esRequest = {
-      index: this._getAlias(index, collection)
+      index: this._getAlias(index, collection),
     };
 
     await this._client.indices.close(esRequest);
 
     try {
       await this._client.indices.putSettings({ ...esRequest, body: settings });
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
-    }
-    finally {
+    } finally {
       await this._client.indices.open(esRequest);
     }
 
@@ -1599,20 +1656,22 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise}
    */
-  async truncateCollection (index, collection) {
+  async truncateCollection(index, collection) {
     let mappings;
     let settings;
 
     const esRequest = {
-      index: await this._getIndice(index, collection)
+      index: await this._getIndice(index, collection),
     };
 
     try {
-      mappings = await this.getMapping(index, collection, { includeKuzzleMeta: true });
+      mappings = await this.getMapping(index, collection, {
+        includeKuzzleMeta: true,
+      });
       settings = await this._getSettings(esRequest);
       settings = {
         ...settings,
-        ...this.getAllowedIndexSettings(settings)
+        ...this.getAllowedIndexSettings(settings),
       };
       await this._client.indices.delete(esRequest);
 
@@ -1620,16 +1679,15 @@ class ElasticSearch extends Service {
         ...esRequest,
         body: {
           aliases: {
-            [this._getAlias(index, collection)]: {}
+            [this._getAlias(index, collection)]: {},
           },
           mappings,
-          settings
-        }
+          settings,
+        },
       });
 
       return null;
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
@@ -1644,31 +1702,31 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ items, errors }>
    */
-  async import (
+  async import(
     index,
     collection,
     documents,
-    { refresh, timeout, userId = null } = {},
+    { refresh, timeout, userId = null } = {}
   ) {
     const alias = this._getAlias(index, collection);
-    const actionNames = ['index', 'create', 'update', 'delete'];
+    const actionNames = ["index", "create", "update", "delete"];
     const dateNow = Date.now();
     const esRequest = {
       body: documents,
       refresh,
-      timeout
+      timeout,
     };
     const kuzzleMeta = {
       created: {
         author: getKuid(userId),
         createdAt: dateNow,
         updatedAt: null,
-        updater: null
+        updater: null,
       },
       updated: {
         updatedAt: dateNow,
-        updater: getKuid(userId)
-      }
+        updater: getKuid(userId),
+      },
     };
 
     assertWellFormedRefresh(esRequest);
@@ -1693,13 +1751,11 @@ class ElasticSearch extends Service {
         if (item[action]._type) {
           item[action]._type = undefined;
         }
-      }
-      else if (lastAction === 'index' || lastAction === 'create') {
+      } else if (lastAction === "index" || lastAction === "create") {
         item._kuzzle_info = kuzzleMeta.created;
-      }
-      else if (lastAction === 'update') {
+      } else if (lastAction === "update") {
         // we can only update metadata on a partial update, or on an upsert
-        for (const prop of ['doc', 'upsert']) {
+        for (const prop of ["doc", "upsert"]) {
           if (isPlainObject(item[prop])) {
             item[prop]._kuzzle_info = kuzzleMeta.updated;
           }
@@ -1711,8 +1767,7 @@ class ElasticSearch extends Service {
     let response;
     try {
       response = await this._client.bulk(esRequest);
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
 
@@ -1720,7 +1775,7 @@ class ElasticSearch extends Service {
 
     const result = {
       errors: [],
-      items: []
+      items: [],
     };
 
     let idx = 0;
@@ -1738,16 +1793,15 @@ class ElasticSearch extends Service {
       if (item.status >= 400) {
         const error = {
           _id: item._id,
-          status: item.status
+          status: item.status,
         };
 
         // update action contain body in "doc" field
         // the delete action is not followed by an action payload
-        if (action === 'update') {
+        if (action === "update") {
           error._source = documents[idx + 1].doc;
           error._source._kuzzle_info = undefined;
-        }
-        else if (action !== 'delete') {
+        } else if (action !== "delete") {
           error._source = documents[idx + 1];
           error._source._kuzzle_info = undefined;
         }
@@ -1757,25 +1811,22 @@ class ElasticSearch extends Service {
         if (item.error) {
           error.error = {
             reason: item.error.reason,
-            type: item.error.type
+            type: item.error.type,
           };
         }
 
         result.errors.push({ [action]: error });
-      }
-      else {
+      } else {
         result.items.push({
           [action]: {
             _id: item._id,
-            status: item.status
-          }
+            status: item.status,
+          },
         });
       }
 
       // the delete action is not followed by an action payload
-      idx = action === 'delete'
-        ? idx + 1
-        : idx + 2;
+      idx = action === "delete" ? idx + 1 : idx + 2;
     }
     /* end critical code section */
 
@@ -1790,13 +1841,12 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<Array>} Collection names
    */
-  async listCollections (index, { includeHidden = false } = {}) {
+  async listCollections(index, { includeHidden = false } = {}) {
     let body;
 
     try {
-      ({ body } = await this._client.cat.aliases({ format: 'json' }));
-    }
-    catch (error) {
+      ({ body } = await this._client.cat.aliases({ format: "json" }));
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
 
@@ -1812,13 +1862,12 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<Array>} Index names
    */
-  async listIndexes () {
+  async listIndexes() {
     let body;
 
     try {
-      ({ body } = await this._client.cat.aliases({ format: 'json' }));
-    }
-    catch (error) {
+      ({ body } = await this._client.cat.aliases({ format: "json" }));
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
 
@@ -1834,16 +1883,15 @@ class ElasticSearch extends Service {
    *
    * @returns {Object.<String, String[]>} Object<index, collections>
    */
-  async getSchema () {
+  async getSchema() {
     // This check avoids a breaking change for those who were using Kuzzle before
     // alias attribution for each indice was the standard ('auto-version')
     await this._ensureAliasConsistency();
 
     let body;
     try {
-      ({ body } = await this._client.cat.aliases({ format: 'json' }));
-    }
-    catch (error) {
+      ({ body } = await this._client.cat.aliases({ format: "json" }));
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
 
@@ -1852,7 +1900,7 @@ class ElasticSearch extends Service {
     const schema = this._extractSchema(aliases, { includeHidden: true });
 
     for (const [index, collections] of Object.entries(schema)) {
-      schema[index] = collections.filter(c => c !== HIDDEN_COLLECTION);
+      schema[index] = collections.filter((c) => c !== HIDDEN_COLLECTION);
     }
 
     return schema;
@@ -1863,13 +1911,12 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<Object[]>} [ { alias, index, collection, indice } ]
    */
-  async listAliases () {
+  async listAliases() {
     let body;
 
     try {
-      ({ body } = await this._client.cat.aliases({ format: 'json' }));
-    }
-    catch (error) {
+      ({ body } = await this._client.cat.aliases({ format: "json" }));
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
 
@@ -1896,17 +1943,16 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise}
    */
-  async deleteCollection (index, collection) {
+  async deleteCollection(index, collection) {
     const esRequest = {
-      index: await this._getIndice(index, collection)
+      index: await this._getIndice(index, collection),
     };
 
     try {
       await this._client.indices.delete(esRequest);
 
       await this._createHiddenCollection(index);
-    }
-    catch (e) {
+    } catch (e) {
       throw this._esWrapper.formatESError(e);
     }
 
@@ -1920,33 +1966,38 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<String[]>}
    */
-  async deleteIndexes (indexes = []) {
+  async deleteIndexes(indexes = []) {
     if (indexes.length === 0) {
       return Bluebird.resolve([]);
     }
     const deleted = new Set();
 
     try {
-      const { body } = await this._client.cat.aliases({ format: 'json' });
+      const { body } = await this._client.cat.aliases({ format: "json" });
 
-      const esRequest = body.reduce((request, { alias, index: indice }) => {
-        const index = this._extractIndex(alias);
+      const esRequest = body.reduce(
+        (request, { alias, index: indice }) => {
+          const index = this._extractIndex(alias);
 
-        if (alias[INDEX_PREFIX_POSITION_IN_ALIAS] !== this._indexPrefix || ! indexes.includes(index)) {
-          return request;
-        }
+          if (
+            alias[INDEX_PREFIX_POSITION_IN_ALIAS] !== this._indexPrefix ||
+            !indexes.includes(index)
+          ) {
+            return request;
+          }
 
-        deleted.add(index);
-        request.index.push(indice);
+          deleted.add(index);
+          request.index.push(indice);
 
-        return request;
-      }, { index: [] });
+          return request;
+        },
+        { index: [] }
+      );
 
-      debug('Delete indexes: %o', esRequest);
+      debug("Delete indexes: %o", esRequest);
 
       await this._client.indices.delete(esRequest);
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
 
@@ -1960,7 +2011,7 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise}
    */
-  async deleteIndex (index) {
+  async deleteIndex(index) {
     await this.deleteIndexes([index]);
     return null;
   }
@@ -1976,7 +2027,7 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<Object>} { _shards }
    */
-  async refreshCollection (index, collection) {
+  async refreshCollection(index, collection) {
     const esRequest = {
       index: this._getAlias(index, collection),
     };
@@ -1984,9 +2035,10 @@ class ElasticSearch extends Service {
     let _shards;
 
     try {
-      ({ body: { _shards } } = await this._client.indices.refresh(esRequest));
-    }
-    catch (error) {
+      ({
+        body: { _shards },
+      } = await this._client.indices.refresh(esRequest));
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
 
@@ -2002,18 +2054,17 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<boolean>}
    */
-  async exists (index, collection, id) {
+  async exists(index, collection, id) {
     const esRequest = {
       id,
-      index: this._getAlias(index, collection)
+      index: this._getAlias(index, collection),
     };
 
     try {
       const { body: exists } = await this._client.exists(esRequest);
 
       return exists;
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
@@ -2029,7 +2080,7 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ items: Array<{ _id, _source, _version }>, errors }>}
    */
-  async mExists (index, collection, ids) {
+  async mExists(index, collection, ids) {
     if (ids.length === 0) {
       return { errors: [], item: [] };
     }
@@ -2037,19 +2088,18 @@ class ElasticSearch extends Service {
     const esRequest = {
       _source: false,
       body: {
-        docs: ids.map(_id => ({ _id })),
+        docs: ids.map((_id) => ({ _id })),
       },
-      index: this._getAlias(index, collection)
+      index: this._getAlias(index, collection),
     };
 
-    debug('mExists: %o', esRequest);
+    debug("mExists: %o", esRequest);
 
     let body;
 
     try {
       ({ body } = await this._client.mget(esRequest)); // NOSONAR
-    }
-    catch (e) {
+    } catch (e) {
       throw this._esWrapper.formatESError(e);
     }
 
@@ -2060,11 +2110,8 @@ class ElasticSearch extends Service {
       const doc = body.docs[i];
 
       if (doc.found) {
-        items.push(
-          doc._id,
-        );
-      }
-      else {
+        items.push(doc._id);
+      } else {
         errors.push(doc._id);
       }
     }
@@ -2079,10 +2126,10 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<boolean>}
    */
-  async hasIndex (index) {
+  async hasIndex(index) {
     const indexes = await this.listIndexes();
 
-    return indexes.some(idx => idx === index);
+    return indexes.some((idx) => idx === index);
   }
 
   /**
@@ -2093,10 +2140,10 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<boolean>}
    */
-  async hasCollection (index, collection) {
+  async hasCollection(index, collection) {
     const collections = await this.listCollections(index);
 
-    return collections.some(col => col === collection);
+    return collections.some((col) => col === collection);
   }
 
   /**
@@ -2106,10 +2153,12 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<boolean>}
    */
-  async _hasHiddenCollection (index) {
-    const collections = await this.listCollections(index, { includeHidden: true });
+  async _hasHiddenCollection(index) {
+    const collections = await this.listCollections(index, {
+      includeHidden: true,
+    });
 
-    return collections.some(col => col === HIDDEN_COLLECTION);
+    return collections.some((col) => col === HIDDEN_COLLECTION);
   }
 
   /**
@@ -2124,41 +2173,41 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<Object>} { items, errors }
    */
-  async mCreate (
+  async mCreate(
     index,
     collection,
     documents,
-    { refresh, timeout, userId = null } = {}) {
-    const
-      alias = this._getAlias(index, collection),
+    { refresh, timeout, userId = null } = {}
+  ) {
+    const alias = this._getAlias(index, collection),
       kuzzleMeta = {
         _kuzzle_info: {
           author: getKuid(userId),
           createdAt: Date.now(),
           updatedAt: null,
-          updater: null
-        }
+          updater: null,
+        },
       },
-      {
-        rejected,
-        extractedDocuments,
-        documentsToGet
-      } = this._extractMDocuments(documents, kuzzleMeta, { prepareMGet: true });
+      { rejected, extractedDocuments, documentsToGet } =
+        this._extractMDocuments(documents, kuzzleMeta, { prepareMGet: true });
 
     // prepare the mget request, but only for document having a specified id
-    const { body } = documentsToGet.length > 0
-      ? await this._client.mget({ body: { docs: documentsToGet }, index: alias })
-      : { body: { docs: [] } };
-
-    const
-      existingDocuments = body.docs,
-      esRequest = {
-        body: [],
-        index: alias,
-        refresh,
-        timeout
-      },
-      toImport = [];
+    const { body } =
+      documentsToGet.length > 0
+        ? await this._client.mget({
+            body: { docs: documentsToGet },
+            index: alias,
+          })
+        : { body: { docs: [] } };
+
+    const existingDocuments = body.docs;
+    const esRequest = {
+      body: [],
+      index: alias,
+      refresh,
+      timeout,
+    };
+    const toImport = [];
 
     /**
      * @warning Critical code section
@@ -2169,34 +2218,32 @@ class ElasticSearch extends Service {
       const document = extractedDocuments[i];
 
       // Documents are retrieved in the same order than we got them from user
-      if (typeof document._id === 'string' && existingDocuments[idx]) {
+      if (typeof document._id === "string" && existingDocuments[idx]) {
         if (existingDocuments[idx].found) {
           document._source._kuzzle_info = undefined;
 
           rejected.push({
             document: {
               _id: document._id,
-              body: document._source
+              body: document._source,
             },
-            reason: 'document already exists',
-            status: 400
+            reason: "document already exists",
+            status: 400,
           });
 
           idx++;
-        }
-        else {
+        } else {
           esRequest.body.push({
             index: {
               _id: document._id,
-              _index: alias
-            }
+              _index: alias,
+            },
           });
           esRequest.body.push(document._source);
 
           toImport.push(document);
         }
-      }
-      else {
+      } else {
         esRequest.body.push({ index: { _index: alias } });
         esRequest.body.push(document._source);
 
@@ -2218,11 +2265,19 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ items, errors }>
    */
-  async mCreateOrReplace (
+  async mCreateOrReplace(
     index,
     collection,
     documents,
-    { refresh, timeout, userId = null, injectKuzzleMeta = true, limits = true, source = true } = {}) {
+    {
+      refresh,
+      timeout,
+      userId = null,
+      injectKuzzleMeta = true,
+      limits = true,
+      source = true,
+    } = {}
+  ) {
     let kuzzleMeta = {};
 
     if (injectKuzzleMeta) {
@@ -2231,8 +2286,8 @@ class ElasticSearch extends Service {
           author: getKuid(userId),
           createdAt: Date.now(),
           updatedAt: null,
-          updater: null
-        }
+          updater: null,
+        },
       };
     }
 
@@ -2241,12 +2296,12 @@ class ElasticSearch extends Service {
       body: [],
       index: alias,
       refresh,
-      timeout
+      timeout,
     };
-    const {
-      rejected,
-      extractedDocuments
-    } = this._extractMDocuments(documents, kuzzleMeta);
+    const { rejected, extractedDocuments } = this._extractMDocuments(
+      documents,
+      kuzzleMeta
+    );
 
     esRequest.body = [];
 
@@ -2259,14 +2314,17 @@ class ElasticSearch extends Service {
       esRequest.body.push({
         index: {
           _id: extractedDocuments[i]._id,
-          _index: alias
-        }
+          _index: alias,
+        },
       });
       esRequest.body.push(extractedDocuments[i]._source);
     }
     /* end critical code section */
 
-    return this._mExecute(esRequest, extractedDocuments, rejected, { limits, source });
+    return this._mExecute(esRequest, extractedDocuments, rejected, {
+      limits,
+      source,
+    });
   }
 
   /**
@@ -2281,30 +2339,30 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<Object>} { items, errors }
    */
-  async mUpdate (
+  async mUpdate(
     index,
     collection,
     documents,
-    { refresh, retryOnConflict = 0, timeout, userId = null } = {}) {
-    const
-      alias = this._getAlias(index, collection),
+    { refresh, retryOnConflict = 0, timeout, userId = null } = {}
+  ) {
+    const alias = this._getAlias(index, collection),
       toImport = [],
       esRequest = {
         body: [],
         index: alias,
         refresh,
-        timeout
+        timeout,
       },
       kuzzleMeta = {
         _kuzzle_info: {
           updatedAt: Date.now(),
-          updater: getKuid(userId)
-        }
+          updater: getKuid(userId),
+        },
       },
-      {
-        rejected,
-        extractedDocuments
-      } = this._extractMDocuments(documents, kuzzleMeta);
+      { rejected, extractedDocuments } = this._extractMDocuments(
+        documents,
+        kuzzleMeta
+      );
 
     /**
      * @warning Critical code section
@@ -2314,33 +2372,33 @@ class ElasticSearch extends Service {
     for (let i = 0; i < extractedDocuments.length; i++) {
       const extractedDocument = extractedDocuments[i];
 
-      if (typeof extractedDocument._id === 'string') {
+      if (typeof extractedDocument._id === "string") {
         esRequest.body.push({
           update: {
             _id: extractedDocument._id,
             _index: alias,
-            retry_on_conflict: retryOnConflict || this._config.defaults.onUpdateConflictRetries
-          }
+            retry_on_conflict:
+              retryOnConflict || this._config.defaults.onUpdateConflictRetries,
+          },
         });
 
         // _source: true => makes ES return the updated document source in the
         // response. Required by the real-time notifier component
         esRequest.body.push({
           _source: true,
-          doc: extractedDocument._source
+          doc: extractedDocument._source,
         });
         toImport.push(extractedDocument);
-      }
-      else {
+      } else {
         extractedDocument._source._kuzzle_info = undefined;
 
         rejected.push({
           document: {
             _id: extractedDocument._id,
-            body: extractedDocument._source
+            body: extractedDocument._source,
           },
-          reason: 'document _id must be a string',
-          status: 400
+          reason: "document _id must be a string",
+          status: 400,
         });
       }
     }
@@ -2352,11 +2410,11 @@ class ElasticSearch extends Service {
     // response.result.get._source
     // => we replace response.result._source with it so that the notifier
     // module can seamlessly process all kind of m* response*
-    response.items = response.items.map(item => ({
+    response.items = response.items.map((item) => ({
       _id: item._id,
       _source: item.get._source,
       _version: item._version,
-      status: item.status
+      status: item.status,
     }));
 
     return response;
@@ -2372,16 +2430,17 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ items, errors }>
    */
-  async mUpsert (
+  async mUpsert(
     index,
     collection,
     documents,
-    { refresh, retryOnConflict = 0, timeout, userId = null } = {}) {
+    { refresh, retryOnConflict = 0, timeout, userId = null } = {}
+  ) {
     const alias = this._getAlias(index, collection);
     const esRequest = {
       body: [],
       refresh,
-      timeout
+      timeout,
     };
 
     const user = getKuid(userId);
@@ -2390,15 +2449,15 @@ class ElasticSearch extends Service {
       doc: {
         _kuzzle_info: {
           updatedAt: now,
-          updater: user
-        }
+          updater: user,
+        },
       },
       upsert: {
         _kuzzle_info: {
           author: user,
-          createdAt: now
-        }
-      }
+          createdAt: now,
+        },
+      },
     };
 
     const { rejected, extractedDocuments } = this._extractMDocuments(
@@ -2406,7 +2465,7 @@ class ElasticSearch extends Service {
       kuzzleMeta,
       {
         prepareMUpsert: true,
-        requireId: true
+        requireId: true,
       }
     );
 
@@ -2422,12 +2481,13 @@ class ElasticSearch extends Service {
             _id: extractedDocuments[i]._id,
             _index: alias,
             _source: true,
-            retry_on_conflict: retryOnConflict || this._config.defaults.onUpdateConflictRetries
-          }
+            retry_on_conflict:
+              retryOnConflict || this._config.defaults.onUpdateConflictRetries,
+          },
         },
         {
           doc: extractedDocuments[i]._source.changes,
-          upsert: extractedDocuments[i]._source.default
+          upsert: extractedDocuments[i]._source.default,
         }
       );
       // _source: true
@@ -2436,18 +2496,22 @@ class ElasticSearch extends Service {
     }
     /* end critical code section */
 
-    const response = await this._mExecute(esRequest, extractedDocuments, rejected);
+    const response = await this._mExecute(
+      esRequest,
+      extractedDocuments,
+      rejected
+    );
 
     // with _source: true, ES returns the updated document in
     // response.result.get._source
     // => we replace response.result._source with it so that the notifier
     // module can seamlessly process all kind of m* response*
-    response.items = response.items.map(item => ({
+    response.items = response.items.map((item) => ({
       _id: item._id,
       _source: item.get._source,
       _version: item._version,
-      created: item.result === 'created', // Needed by the notifier
-      status: item.status
+      created: item.result === "created", // Needed by the notifier
+      status: item.status,
     }));
 
     return response;
@@ -2465,29 +2529,26 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<Object>} { items, errors }
    */
-  async mReplace (
+  async mReplace(
     index,
     collection,
     documents,
-    { refresh, timeout, userId = null } = {}) {
-    const
-      alias = this._getAlias(index, collection),
+    { refresh, timeout, userId = null } = {}
+  ) {
+    const alias = this._getAlias(index, collection),
       kuzzleMeta = {
         _kuzzle_info: {
           author: getKuid(userId),
           createdAt: Date.now(),
           updatedAt: null,
-          updater: null
-        }
+          updater: null,
+        },
       },
-      {
-        rejected,
-        extractedDocuments,
-        documentsToGet
-      } = this._extractMDocuments(
-        documents,
-        kuzzleMeta,
-        { prepareMGet: true, requireId: true });
+      { rejected, extractedDocuments, documentsToGet } =
+        this._extractMDocuments(documents, kuzzleMeta, {
+          prepareMGet: true,
+          requireId: true,
+        });
 
     if (documentsToGet.length < 1) {
       return { errors: rejected, items: [] };
@@ -2495,17 +2556,16 @@ class ElasticSearch extends Service {
 
     const { body } = await this._client.mget({
       body: { docs: documentsToGet },
-      index: alias
+      index: alias,
     });
 
-    const
-      existingDocuments = body.docs,
-      esRequest = {
-        body: [],
-        refresh,
-        timeout
-      },
-      toImport = [];
+    const existingDocuments = body.docs;
+    const esRequest = {
+      body: [],
+      refresh,
+      timeout,
+    };
+    const toImport = [];
 
     /**
      * @warning Critical code section
@@ -2520,23 +2580,22 @@ class ElasticSearch extends Service {
         esRequest.body.push({
           index: {
             _id: document._id,
-            _index: alias
-          }
+            _index: alias,
+          },
         });
         esRequest.body.push(document._source);
 
         toImport.push(document);
-      }
-      else {
+      } else {
         document._source._kuzzle_info = undefined;
 
         rejected.push({
           document: {
             _id: document._id,
-            body: document._source
+            body: document._source,
           },
-          reason: 'document not found',
-          status: 404
+          reason: "document not found",
+          status: 404,
         });
       }
     }
@@ -2555,15 +2614,10 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<{ documents, errors }>
    */
-  async mDelete (
-    index,
-    collection,
-    ids,
-    { refresh, timeout } = {}) {
-    const
-      query = { ids: { values: [] } },
-      validIds = [],
-      partialErrors = [];
+  async mDelete(index, collection, ids, { refresh, timeout } = {}) {
+    const query = { ids: { values: [] } };
+    const validIds = [];
+    const partialErrors = [];
 
     /**
      * @warning Critical code section
@@ -2573,14 +2627,13 @@ class ElasticSearch extends Service {
     for (let i = 0; i < ids.length; i++) {
       const _id = ids[i];
 
-      if (typeof _id === 'string') {
+      if (typeof _id === "string") {
         validIds.push(_id);
-      }
-      else {
+      } else {
         partialErrors.push({
           _id,
-          reason: 'document _id must be a string',
-          status: 400
+          reason: "document _id must be a string",
+          status: 400,
         });
       }
     }
@@ -2597,19 +2650,17 @@ class ElasticSearch extends Service {
      * request can contain more than 10K elements
      */
     for (let i = 0; i < validIds.length; i++) {
-      const
-        validId = validIds[i],
-        item = items[idx];
+      const validId = validIds[i];
+      const item = items[idx];
 
       if (item && item._id === validId) {
         query.ids.values.push(validId);
         idx++;
-      }
-      else {
+      } else {
         partialErrors.push({
           _id: validId,
-          reason: 'document not found',
-          status: 404
+          reason: "document not found",
+          status: 404,
         });
       }
     }
@@ -2617,11 +2668,10 @@ class ElasticSearch extends Service {
 
     // @todo duplicated query to get documents body, mGet here and search in
     // deleteByQuery
-    const { documents } = await this.deleteByQuery(
-      index,
-      collection,
-      query,
-      { refresh, timeout });
+    const { documents } = await this.deleteByQuery(index, collection, query, {
+      refresh,
+      timeout,
+    });
 
     return { documents, errors: partialErrors };
   }
@@ -2638,13 +2688,19 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<Object[]>} results
    */
-  async _mExecute (esRequest, documents, partialErrors, { limits = true, source = true } = {}) {
+  async _mExecute(
+    esRequest,
+    documents,
+    partialErrors,
+    { limits = true, source = true } = {}
+  ) {
     assertWellFormedRefresh(esRequest);
 
-    if ( limits
-      && documents.length > global.kuzzle.config.limits.documentsWriteCount
+    if (
+      limits &&
+      documents.length > global.kuzzle.config.limits.documentsWriteCount
     ) {
-      return kerror.reject('write_limit_exceeded');
+      return kerror.reject("write_limit_exceeded");
     }
 
     let response = { body: { items: [] } };
@@ -2652,8 +2708,7 @@ class ElasticSearch extends Service {
     if (documents.length > 0) {
       try {
         response = await this._client.bulk(esRequest);
-      }
-      catch (error) {
+      } catch (error) {
         throw this._esWrapper.formatESError(error);
       }
     }
@@ -2675,26 +2730,24 @@ class ElasticSearch extends Service {
           partialErrors.push({
             document: {
               _id: documents[i]._id,
-              body: documents[i]._source
+              body: documents[i]._source,
             },
-            reason: 'document not found',
-            status: result.status
+            reason: "document not found",
+            status: result.status,
           });
-        }
-        else {
+        } else {
           partialErrors.push({
             document: documents[i],
             reason: result.error.reason,
-            status: result.status
+            status: result.status,
           });
         }
-      }
-      else {
+      } else {
         successes.push({
           _id: result._id,
           _source: source ? documents[i]._source : undefined,
           _version: result._version,
-          created: result.result === 'created',
+          created: result.result === "created",
           get: result.get,
           result: result.result,
           status: result.status, // used by mUpdate to get the full document body
@@ -2721,11 +2774,14 @@ class ElasticSearch extends Service {
    *
    * @returns {Object} { rejected, extractedDocuments, documentsToGet }
    */
-  _extractMDocuments (documents, metadata, { prepareMGet = false, requireId = false, prepareMUpsert = false } = {}) {
-    const
-      rejected = [],
-      extractedDocuments = [],
-      documentsToGet = [];
+  _extractMDocuments(
+    documents,
+    metadata,
+    { prepareMGet = false, requireId = false, prepareMUpsert = false } = {}
+  ) {
+    const rejected = [];
+    const extractedDocuments = [];
+    const documentsToGet = [];
 
     /**
      * @warning Critical code section
@@ -2735,63 +2791,66 @@ class ElasticSearch extends Service {
     for (let i = 0; i < documents.length; i++) {
       const document = documents[i];
 
-      if (! isPlainObject(document.body) && ! prepareMUpsert) {
+      if (!isPlainObject(document.body) && !prepareMUpsert) {
         rejected.push({
           document,
-          reason: 'document body must be an object',
-          status: 400
+          reason: "document body must be an object",
+          status: 400,
         });
-      }
-      else if (! isPlainObject(document.changes) && prepareMUpsert) {
+      } else if (!isPlainObject(document.changes) && prepareMUpsert) {
         rejected.push({
           document,
-          reason: 'document changes must be an object',
-          status: 400
+          reason: "document changes must be an object",
+          status: 400,
         });
-      }
-      else if (prepareMUpsert && document.default && ! isPlainObject(document.default)) {
+      } else if (
+        prepareMUpsert &&
+        document.default &&
+        !isPlainObject(document.default)
+      ) {
         rejected.push({
           document,
-          reason: 'document default must be an object',
-          status: 400
+          reason: "document default must be an object",
+          status: 400,
         });
-      }
-      else if (requireId && typeof document._id !== 'string') {
+      } else if (requireId && typeof document._id !== "string") {
         rejected.push({
           document,
-          reason: 'document _id must be a string',
-          status: 400
+          reason: "document _id must be a string",
+          status: 400,
         });
-      }
-      else {
+      } else {
         let extractedDocument;
         if (prepareMUpsert) {
           extractedDocument = {
             _source: {
               // Do not use destructuring, it's 10x slower
               changes: Object.assign({}, metadata.doc, document.changes),
-              default: Object.assign({}, metadata.upsert, document.changes, document.default)
-            }
+              default: Object.assign(
+                {},
+                metadata.upsert,
+                document.changes,
+                document.default
+              ),
+            },
           };
-        }
-        else {
+        } else {
           extractedDocument = {
             // Do not use destructuring, it's 10x slower
-            _source: Object.assign({}, metadata, document.body)
+            _source: Object.assign({}, metadata, document.body),
           };
         }
 
-
         if (document._id) {
           extractedDocument._id = document._id;
         }
 
         extractedDocuments.push(extractedDocument);
 
-        if (prepareMGet && typeof document._id === 'string') {
+        if (prepareMGet && typeof document._id === "string") {
           documentsToGet.push({
             _id: document._id,
-            _source: false
+            _source: false,
           });
         }
       }
@@ -2807,28 +2866,28 @@ class ElasticSearch extends Service {
    * @param {Object} mapping
    * @throws
    */
-  _checkMappings (mapping, path = [], check = true) {
-    const
-      properties = Object.keys(mapping),
-      mappingProperties = path.length === 0
+  _checkMappings(mapping, path = [], check = true) {
+    const properties = Object.keys(mapping);
+    const mappingProperties =
+      path.length === 0
         ? ROOT_MAPPING_PROPERTIES
         : [...ROOT_MAPPING_PROPERTIES, ...CHILD_MAPPING_PROPERTIES];
 
     for (const property of properties) {
-      if (check && ! mappingProperties.includes(property)) {
-        const currentPath = [...path, property].join('.');
+      if (check && !mappingProperties.includes(property)) {
+        const currentPath = [...path, property].join(".");
 
         throw kerror.get(
-          'invalid_mapping',
+          "invalid_mapping",
           currentPath,
-          didYouMean(property, mappingProperties));
+          didYouMean(property, mappingProperties)
+        );
       }
 
-      if (property === 'properties') {
+      if (property === "properties") {
         // type definition level, we don't check
-        this._checkMappings(mapping[property], [...path, 'properties'], false);
-      }
-      else if (mapping[property] && mapping[property].properties) {
+        this._checkMappings(mapping[property], [...path, "properties"], false);
+      } else if (mapping[property] && mapping[property].properties) {
         // root properties level, check for "properties", "dynamic" and "_meta"
         this._checkMappings(mapping[property], [...path, property], true);
       }
@@ -2844,7 +2903,7 @@ class ElasticSearch extends Service {
    *
    * @returns {String} Alias name (eg: '@&nepali.liia')
    */
-  _getAlias (index, collection) {
+  _getAlias(index, collection) {
     return `${ALIAS_PREFIX}${this._indexPrefix}${index}${NAME_SEPARATOR}${collection}`;
   }
 
@@ -2858,15 +2917,21 @@ class ElasticSearch extends Service {
    * @returns {String} Indice name (eg: '&nepali.liia')
    * @throws If there is not exactly one indice associated
    */
-  async _getIndice (index, collection) {
+  async _getIndice(index, collection) {
     const alias = `${ALIAS_PREFIX}${this._indexPrefix}${index}${NAME_SEPARATOR}${collection}`;
-    const { body } = await this._client.cat.aliases({ format: 'json', name: alias });
+    const { body } = await this._client.cat.aliases({
+      format: "json",
+      name: alias,
+    });
 
     if (body.length < 1) {
-      throw kerror.get('unknown_index_collection');
-    }
-    else if (body.length > 1) {
-      throw kerror.get('multiple_indice_alias', `"alias" starting with "${ALIAS_PREFIX}"`, '"indices"');
+      throw kerror.get("unknown_index_collection");
+    } else if (body.length > 1) {
+      throw kerror.get(
+        "multiple_indice_alias",
+        `"alias" starting with "${ALIAS_PREFIX}"`,
+        '"indices"'
+      );
     }
 
     return body[0].index;
@@ -2879,7 +2944,7 @@ class ElasticSearch extends Service {
    * @return {Promise<*>} the settings of the indice.
    * @private
    */
-  async _getSettings (esRequest) {
+  async _getSettings(esRequest) {
     const response = await this._client.indices.getSettings(esRequest);
     return response.body[esRequest.index].settings;
   }
@@ -2893,10 +2958,12 @@ class ElasticSearch extends Service {
    *
    * @returns {String} Available indice name (eg: '&nepali.liia2')
    */
-  async _getAvailableIndice (index, collection) {
-    let indice = this._getAlias(index, collection).substr(INDEX_PREFIX_POSITION_IN_ALIAS);
+  async _getAvailableIndice(index, collection) {
+    let indice = this._getAlias(index, collection).substr(
+      INDEX_PREFIX_POSITION_IN_ALIAS
+    );
 
-    if (! (await this._client.indices.exists({ index: indice })).body) {
+    if (!(await this._client.indices.exists({ index: indice })).body) {
       return indice;
     }
 
@@ -2906,14 +2973,17 @@ class ElasticSearch extends Service {
       suffix = `.${randomNumber(100000)}`;
 
       const overflow = Buffer.from(indice + suffix).length - 255;
-      if ( overflow > 0) {
+      if (overflow > 0) {
         const indiceBuffer = Buffer.from(indice);
-        indice = indiceBuffer.slice(0, indiceBuffer.length - overflow).toString();
+        indice = indiceBuffer
+          .slice(0, indiceBuffer.length - overflow)
+          .toString();
       }
 
-      notAvailable = await this._client.indices.exists({ index: indice + suffix }).body;
-    }
-    while (notAvailable);
+      notAvailable = await this._client.indices.exists({
+        index: indice + suffix,
+      }).body;
+    } while (notAvailable);
 
     return indice + suffix;
   }
@@ -2926,14 +2996,14 @@ class ElasticSearch extends Service {
    * @returns {String} Alias name (eg: '@&nepali.liia')
    * @throws If there is not exactly one alias associated that is prefixed with @
    */
-  async _getAliasFromIndice (indice) {
+  async _getAliasFromIndice(indice) {
     const { body } = await this._client.indices.getAlias({ index: indice });
-    const aliases =
-      Object.keys(body[indice].aliases)
-        .filter(alias => alias.startsWith(ALIAS_PREFIX));
+    const aliases = Object.keys(body[indice].aliases).filter((alias) =>
+      alias.startsWith(ALIAS_PREFIX)
+    );
 
     if (aliases.length < 1) {
-      throw kerror.get('unknown_index_collection');
+      throw kerror.get("unknown_index_collection");
     }
 
     return aliases;
@@ -2946,26 +3016,29 @@ class ElasticSearch extends Service {
    * This check avoids a breaking change for those who were using Kuzzle before
    * alias attribution for each indice turned into a standard ('auto-version').
    */
-  async _ensureAliasConsistency () {
+  async _ensureAliasConsistency() {
     try {
-      const { body } = await this._client.cat.indices({ format: 'json' });
+      const { body } = await this._client.cat.indices({ format: "json" });
       const indices = body.map(({ index: indice }) => indice);
       const aliases = await this.listAliases();
 
-      const indicesWithoutAlias = indices.filter(indice =>
-        indice[INDEX_PREFIX_POSITION_IN_INDICE] === this._indexPrefix
-        && ! aliases.some(alias => alias.indice === indice));
+      const indicesWithoutAlias = indices.filter(
+        (indice) =>
+          indice[INDEX_PREFIX_POSITION_IN_INDICE] === this._indexPrefix &&
+          !aliases.some((alias) => alias.indice === indice)
+      );
 
       const esRequest = { body: { actions: [] } };
       for (const indice of indicesWithoutAlias) {
-        esRequest.body.actions.push({ add: { alias: `${ALIAS_PREFIX}${indice}`, index: indice } });
+        esRequest.body.actions.push({
+          add: { alias: `${ALIAS_PREFIX}${indice}`, index: indice },
+        });
       }
 
       if (esRequest.body.actions.length > 0) {
         await this._client.indices.updateAliases(esRequest);
       }
-    }
-    catch (error) {
+    } catch (error) {
       throw this._esWrapper.formatESError(error);
     }
   }
@@ -2976,13 +3049,13 @@ class ElasticSearch extends Service {
    * @param {String} index
    * @param {String} collection
    */
-  _assertValidIndexAndCollection (index, collection = null) {
-    if (! this.isIndexNameValid(index)) {
-      throw kerror.get('invalid_index_name', index);
+  _assertValidIndexAndCollection(index, collection = null) {
+    if (!this.isIndexNameValid(index)) {
+      throw kerror.get("invalid_index_name", index);
     }
 
-    if (collection !== null && ! this.isCollectionNameValid(collection)) {
-      throw kerror.get('invalid_collection_name', collection);
+    if (collection !== null && !this.isCollectionNameValid(collection)) {
+      throw kerror.get("invalid_collection_name", collection);
     }
   }
 
@@ -2993,10 +3066,11 @@ class ElasticSearch extends Service {
    *
    * @returns {String} Index name
    */
-  _extractIndex (alias) {
+  _extractIndex(alias) {
     return alias.substr(
       INDEX_PREFIX_POSITION_IN_ALIAS + 1,
-      alias.indexOf(NAME_SEPARATOR) - INDEX_PREFIX_POSITION_IN_ALIAS - 1 );
+      alias.indexOf(NAME_SEPARATOR) - INDEX_PREFIX_POSITION_IN_ALIAS - 1
+    );
   }
 
   /**
@@ -3006,7 +3080,7 @@ class ElasticSearch extends Service {
    *
    * @returns {String} Collection name
    */
-  _extractCollection (alias) {
+  _extractCollection(alias) {
     const separatorPos = alias.indexOf(NAME_SEPARATOR);
 
     return alias.substr(separatorPos + 1, alias.length);
@@ -3020,22 +3094,23 @@ class ElasticSearch extends Service {
    *
    * @returns {Object.<String, String[]>} Indexes as key and an array of their collections as value
    */
-  _extractSchema (aliases, { includeHidden = false } = {}) {
+  _extractSchema(aliases, { includeHidden = false } = {}) {
     const schema = {};
 
     for (const alias of aliases) {
-      const [ indexName, collectionName ] = alias
+      const [indexName, collectionName] = alias
         .substr(INDEX_PREFIX_POSITION_IN_ALIAS + 1, alias.length)
         .split(NAME_SEPARATOR);
 
-      if ( alias[INDEX_PREFIX_POSITION_IN_ALIAS] === this._indexPrefix
-        && (collectionName !== HIDDEN_COLLECTION || includeHidden)
+      if (
+        alias[INDEX_PREFIX_POSITION_IN_ALIAS] === this._indexPrefix &&
+        (collectionName !== HIDDEN_COLLECTION || includeHidden)
       ) {
-        if (! schema[indexName]) {
+        if (!schema[indexName]) {
           schema[indexName] = [];
         }
 
-        if (! schema[indexName].includes(collectionName)) {
+        if (!schema[indexName].includes(collectionName)) {
           schema[indexName].push(collectionName);
         }
       }
@@ -3050,7 +3125,7 @@ class ElasticSearch extends Service {
    *
    * @param {String} index Index name
    */
-  async _createHiddenCollection (index) {
+  async _createHiddenCollection(index) {
     const mutex = new Mutex(`hiddenCollection/${index}`);
 
     try {
@@ -3063,20 +3138,18 @@ class ElasticSearch extends Service {
       await this._client.indices.create({
         body: {
           aliases: {
-            [this._getAlias(index, HIDDEN_COLLECTION)]: {}
+            [this._getAlias(index, HIDDEN_COLLECTION)]: {},
           },
           settings: {
             number_of_replicas: 1,
             number_of_shards: 1,
-          }
+          },
         },
         index: await this._getAvailableIndice(index, HIDDEN_COLLECTION),
       });
-    }
-    catch (e) {
+    } catch (e) {
       throw this._esWrapper.formatESError(e);
-    }
-    finally {
+    } finally {
       await mutex.unlock();
     }
   }
@@ -3090,25 +3163,31 @@ class ElasticSearch extends Service {
    *
    * @returns {Promise.<Array>} resolve to an array of documents
    */
-  async _getAllDocumentsFromQuery (esRequest) {
-    let { body: { hits, _scroll_id } } = await this._client.search(esRequest);
+  async _getAllDocumentsFromQuery(esRequest) {
+    let {
+      body: { hits, _scroll_id },
+    } = await this._client.search(esRequest);
 
     if (hits.total.value > global.kuzzle.config.limits.documentsWriteCount) {
-      throw kerror.get('write_limit_exceeded');
+      throw kerror.get("write_limit_exceeded");
     }
 
-    let documents = hits.hits.map(h => ({ _id: h._id, _source: h._source }));
+    let documents = hits.hits.map((h) => ({ _id: h._id, _source: h._source }));
 
     while (hits.total.value !== documents.length) {
-      ({ body: { hits, _scroll_id } } = await this._client.scroll({
+      ({
+        body: { hits, _scroll_id },
+      } = await this._client.scroll({
         scroll: esRequest.scroll,
-        scrollId: _scroll_id
+        scrollId: _scroll_id,
       }));
 
-      documents = documents.concat(hits.hits.map(h => ({
-        _id: h._id,
-        _source: h._source
-      })));
+      documents = documents.concat(
+        hits.hits.map((h) => ({
+          _id: h._id,
+          _source: h._source,
+        }))
+      );
     }
 
     await this.clearScroll(_scroll_id);
@@ -3122,11 +3201,11 @@ class ElasticSearch extends Service {
    *
    * @param {Object} searchBody - ES search body (with query, aggregations, sort, etc)
    */
-  _sanitizeSearchBody (searchBody) {
+  _sanitizeSearchBody(searchBody) {
     // Only allow a whitelist of top level properties
     for (const key of Object.keys(searchBody)) {
-      if (searchBody[key] !== undefined && ! this.searchBodyKeys.includes(key)) {
-        throw kerror.get('invalid_search_query', key);
+      if (searchBody[key] !== undefined && !this.searchBodyKeys.includes(key)) {
+        throw kerror.get("invalid_search_query", key);
       }
     }
 
@@ -3149,17 +3228,17 @@ class ElasticSearch extends Service {
    *
    * @param {Object} object
    */
-  _scriptCheck (object) {
+  _scriptCheck(object) {
     for (const [key, value] of Object.entries(object)) {
       if (this.scriptKeys.includes(key)) {
         for (const scriptArg of Object.keys(value)) {
-          if (! this.scriptAllowedArgs.includes(scriptArg)) {
-            throw kerror.get('invalid_query_keyword', `${key}.${scriptArg}`);
+          if (!this.scriptAllowedArgs.includes(scriptArg)) {
+            throw kerror.get("invalid_query_keyword", `${key}.${scriptArg}`);
           }
         }
       }
       // Every object must be checked here, even the ones nested into an array
-      else if (typeof value === 'object' && value !== null) {
+      else if (typeof value === "object" && value !== null) {
         this._scriptCheck(value);
       }
     }
@@ -3170,7 +3249,7 @@ class ElasticSearch extends Service {
    * @param  {string}  name
    * @returns {Boolean}
    */
-  isCollectionNameValid (name) {
+  isCollectionNameValid(name) {
     return _isObjectNameValid(name);
   }
 
@@ -3179,7 +3258,7 @@ class ElasticSearch extends Service {
    * @param  {string}  name
    * @returns {Boolean}
    */
-  isIndexNameValid (name) {
+  isIndexNameValid(name) {
     return _isObjectNameValid(name);
   }
 
@@ -3188,9 +3267,9 @@ class ElasticSearch extends Service {
    * @param  {[type]} id [description]
    * @returns {[type]}    [description]
    */
-  async clearScroll (id) {
+  async clearScroll(id) {
     if (id) {
-      debug('clearing scroll: %s', id);
+      debug("clearing scroll: %s", id);
       await this._client.clearScroll({ scrollId: id });
     }
   }
@@ -3203,18 +3282,20 @@ class ElasticSearch extends Service {
    *
    * @returns {Number} milliseconds
    */
-  _loadMsConfig (key) {
+  _loadMsConfig(key) {
     const configValue = _.get(this._config, key);
 
     assert(
-      typeof configValue === 'string',
-      `services.storageEngine.${key} must be a string.`);
+      typeof configValue === "string",
+      `services.storageEngine.${key} must be a string.`
+    );
 
     const parsedValue = ms(configValue);
 
     assert(
-      typeof parsedValue === 'number',
-      `Invalid parsed value from ms() for services.storageEngine.${key} ("${typeof parsedValue}").`);
+      typeof parsedValue === "number",
+      `Invalid parsed value from ms() for services.storageEngine.${key} ("${typeof parsedValue}").`
+    );
 
     return parsedValue;
   }
@@ -3223,17 +3304,17 @@ class ElasticSearch extends Service {
    * Returns true if one of the mappings dynamic property changes value from
    * false to true
    */
-  _dynamicChanges (previousMappings, newMappings) {
+  _dynamicChanges(previousMappings, newMappings) {
     const previousValues = findDynamic(previousMappings);
 
     for (const [path, previousValue] of Object.entries(previousValues)) {
-      if (previousValue.toString() !== 'false') {
+      if (previousValue.toString() !== "false") {
         continue;
       }
 
       const newValue = _.get(newMappings, path);
 
-      if (newValue && newValue.toString() !== 'false') {
+      if (newValue && newValue.toString() !== "false") {
         return true;
       }
     }
@@ -3241,7 +3322,7 @@ class ElasticSearch extends Service {
     return false;
   }
 
-  async waitForElasticsearch () {
+  async waitForElasticsearch() {
     if (esState !== esStateEnum.NONE) {
       while (esState !== esStateEnum.OK) {
         await Bluebird.delay(1000);
@@ -3252,7 +3333,7 @@ class ElasticSearch extends Service {
 
     esState = esStateEnum.AWAITING;
 
-    global.kuzzle.log.info('[ℹ] Trying to connect to Elasticsearch...');
+    global.kuzzle.log.info("[ℹ] Trying to connect to Elasticsearch...");
 
     while (esState !== esStateEnum.OK) {
       try {
@@ -3262,15 +3343,15 @@ class ElasticSearch extends Service {
         });
 
         if (health.body.number_of_pending_tasks === 0) {
-          global.kuzzle.log.info('[✔] Elasticsearch is ready');
+          global.kuzzle.log.info("[✔] Elasticsearch is ready");
           esState = esStateEnum.OK;
-        }
-        else {
-          global.kuzzle.log.info(`[ℹ] Still waiting for Elasticsearch: ${health.body.number_of_pending_tasks} cluster tasks remaining`);
+        } else {
+          global.kuzzle.log.info(
+            `[ℹ] Still waiting for Elasticsearch: ${health.body.number_of_pending_tasks} cluster tasks remaining`
+          );
           await Bluebird.delay(1000);
         }
-      }
-      catch (e) {
+      } catch (e) {
         await Bluebird.delay(1000);
       }
     }
@@ -3279,25 +3360,28 @@ class ElasticSearch extends Service {
   /**
    * Checks if the dynamic properties are correct
    */
-  _checkDynamicProperty (mappings) {
+  _checkDynamicProperty(mappings) {
     const dynamicProperties = findDynamic(mappings);
     for (const [path, value] of Object.entries(dynamicProperties)) {
       // Prevent common mistake
-      if (typeof value === 'boolean') {
+      if (typeof value === "boolean") {
         _.set(mappings, path, value.toString());
-      }
-      else if (typeof value !== 'string') {
+      } else if (typeof value !== "string") {
         throw kerror.get(
-          'invalid_mapping',
+          "invalid_mapping",
           path,
-          'Dynamic property value should be a string.');
+          "Dynamic property value should be a string."
+        );
       }
 
-      if (! DYNAMIC_PROPERTY_VALUES.includes(value.toString())) {
+      if (!DYNAMIC_PROPERTY_VALUES.includes(value.toString())) {
         throw kerror.get(
-          'invalid_mapping',
+          "invalid_mapping",
           path,
-          `Incorrect dynamic property value (${value}). Should be one of "${DYNAMIC_PROPERTY_VALUES.join('", "')}"`);
+          `Incorrect dynamic property value (${value}). Should be one of "${DYNAMIC_PROPERTY_VALUES.join(
+            '", "'
+          )}"`
+        );
       }
     }
   }
@@ -3316,9 +3400,9 @@ module.exports = ElasticSearch;
  *   "properties.user.properties.address.dynamic": "strict"
  * }
  */
-function findDynamic (mappings, path = [], results = {}) {
+function findDynamic(mappings, path = [], results = {}) {
   if (mappings.dynamic !== undefined) {
-    results[path.concat('dynamic').join('.')] = mappings.dynamic;
+    results[path.concat("dynamic").join(".")] = mappings.dynamic;
   }
 
   for (const [key, value] of Object.entries(mappings)) {
@@ -3336,9 +3420,9 @@ function findDynamic (mappings, path = [], results = {}) {
  * @param {Object} esRequest
  * @throws
  */
-function assertNoRouting (esRequest) {
+function assertNoRouting(esRequest) {
   if (esRequest.body._routing) {
-    throw kerror.get('no_routing');
+    throw kerror.get("no_routing");
   }
 }
 
@@ -3348,14 +3432,14 @@ function assertNoRouting (esRequest) {
  * @param {Object} esRequest
  * @throws
  */
-function assertWellFormedRefresh (esRequest) {
-  if (! ['wait_for', 'false', false, undefined].includes(esRequest.refresh)) {
-    throw kerror.get('invalid_argument', 'refresh', '"wait_for", false');
+function assertWellFormedRefresh(esRequest) {
+  if (!["wait_for", "false", false, undefined].includes(esRequest.refresh)) {
+    throw kerror.get("invalid_argument", "refresh", '"wait_for", false');
   }
 }
 
-function getKuid (userId) {
-  if (! userId) {
+function getKuid(userId) {
+  if (!userId) {
     return null;
   }
 
@@ -3377,8 +3461,8 @@ function getKuid (userId) {
  * @param  {string}  name
  * @returns {Boolean}
  */
-function _isObjectNameValid (name) {
-  if (typeof name !== 'string' || name.length === 0) {
+function _isObjectNameValid(name) {
+  if (typeof name !== "string" || name.length === 0) {
     return false;
   }
 
@@ -3390,14 +3474,14 @@ function _isObjectNameValid (name) {
     return false;
   }
 
-  if (name === '_all') {
+  if (name === "_all") {
     return false;
   }
 
   let valid = true;
 
   for (let i = 0; valid && i < FORBIDDEN_CHARS.length; i++) {
-    valid = ! name.includes(FORBIDDEN_CHARS[i]);
+    valid = !name.includes(FORBIDDEN_CHARS[i]);
   }
 
   return valid;