kuzzle 2.19.2 → 2.19.3

package/lib/core/validation/validation.js

@@ -19,24 +19,24 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const Bluebird = require('bluebird');
-const _ = require('lodash');
-const { Koncorde } = require('koncorde');
+const Bluebird = require("bluebird");
+const _ = require("lodash");
+const { Koncorde } = require("koncorde");
 
-const debug = require('../../util/debug')('core:validation');
-const kerror = require('../../kerror');
-const { KuzzleError } = require('../../kerror/errors');
-const { has, isPlainObject, get } = require('../../util/safeObject');
-const { koncordeTest, toKoncordeIndex } = require('../../util/koncordeCompat');
+const debug = require("../../util/debug")("core:validation");
+const kerror = require("../../kerror");
+const { KuzzleError } = require("../../kerror/errors");
+const { has, isPlainObject, get } = require("../../util/safeObject");
+const { koncordeTest, toKoncordeIndex } = require("../../util/koncordeCompat");
 
-const assertionError = kerror.wrap('validation', 'assert');
+const assertionError = kerror.wrap("validation", "assert");
 /**
  * @class Validation
  */
 class Validation {
-  constructor () {
+  constructor() {
     /** @type {...ValidationType} */
     this.types = {};
 
@@ -55,22 +55,22 @@ class Validation {
   /**
    * Walks through all types in "defaultTypesFiles" initializes all types
    */
-  init () {
+  init() {
     [
-      'anything',
-      'boolean',
-      'date',
-      'email',
-      'enum',
-      'geoPoint',
-      'geoShape',
-      'integer',
-      'ipAddress',
-      'numeric',
-      'object',
-      'string',
-      'url'
-    ].forEach(typeFile => {
+      "anything",
+      "boolean",
+      "date",
+      "email",
+      "enum",
+      "geoPoint",
+      "geoShape",
+      "integer",
+      "ipAddress",
+      "numeric",
+      "object",
+      "string",
+      "url",
+    ].forEach((typeFile) => {
       const TypeConstructor = require(`./types/${typeFile}`);
       this.addType(new TypeConstructor());
     });
@@ -83,28 +83,29 @@ class Validation {
    * @param {boolean} [verbose]
    * @returns {Promise.<{documentBody: *, errorMessages:string[], valid: boolean}|KuzzleRequest>}
    */
-  async validate (request, verbose = false) {
-    const
-      { _id, index, collection } = request.input.resource,
+  async validate(request, verbose = false) {
+    const { _id, index, collection } = request.input.resource,
       collectionSpec =
-        isPlainObject(this.specification) &&
-        has(this.specification, index) &&
-        get(this.specification[index], collection) || {};
+        (isPlainObject(this.specification) &&
+          has(this.specification, index) &&
+          get(this.specification[index], collection)) ||
+        {};
 
-    let
-      isUpdate = false,
+    let isUpdate = false,
       body = request.input.body;
 
-    if ( request.input.controller === 'document'
-      && request.input.action === 'update'
+    if (
+      request.input.controller === "document" &&
+      request.input.action === "update"
     ) {
       isUpdate = true;
 
       const document = await global.kuzzle.ask(
-        'core:storage:public:document:get',
+        "core:storage:public:document:get",
         index,
         collection,
-        _id);
+        _id
+      );
 
       // Avoid side effects on the request during the update validation
       body = _.cloneDeep(request.input.body);
@@ -122,45 +123,54 @@ class Validation {
             collectionSpec.fields.children,
             collectionSpec.strict,
             errorMessages,
-            verbose);
-        }
-        catch (error) {
+            verbose
+          );
+        } catch (error) {
           // The strictness message can be received here only if it happens at
           // the validation of the document's root
-          if (error.message !== 'strictness') {
+          if (error.message !== "strictness") {
             throw error;
           }
 
           isValid = false;
           manageErrorMessage(
-            'document',
+            "document",
             errorMessages,
             `The document validation is strict. Cannot add unspecified sub-field "${error.details.field}"`,
-            verbose);
+            verbose
+          );
         }
       }
 
       if (collectionSpec.validators) {
-        const filters = koncordeTest(this.koncorde, index, collection, body, _id);
+        const filters = koncordeTest(
+          this.koncorde,
+          index,
+          collection,
+          body,
+          _id
+        );
 
-        if ( filters.length === 0 || filters[0] !== collectionSpec.validators) {
+        if (filters.length === 0 || filters[0] !== collectionSpec.validators) {
           isValid = false;
           manageErrorMessage(
-            'document',
+            "document",
             errorMessages,
-            'The document does not match validation filters.',
-            verbose);
+            "The document does not match validation filters.",
+            verbose
+          );
         }
       }
     }
 
-    if (! verbose) {
+    if (!verbose) {
       // We only modify the request if the validation succeeds
       if (collectionSpec.fields && collectionSpec.fields.children) {
         request.input.body = this.recurseApplyDefault(
           isUpdate,
           request.input.body,
-          collectionSpec.fields.children);
+          collectionSpec.fields.children
+        );
       }
 
       return request;
@@ -174,32 +184,34 @@ class Validation {
    * @param {*} documentSubset
    * @param {...StructuredFieldSpecification} collectionSpecSubset
    */
-  recurseApplyDefault (isUpdate, documentSubset, collectionSpecSubset) {
-    Object.keys(collectionSpecSubset).forEach(fieldName => {
-      const
-        specSubset = collectionSpecSubset[fieldName],
+  recurseApplyDefault(isUpdate, documentSubset, collectionSpecSubset) {
+    Object.keys(collectionSpecSubset).forEach((fieldName) => {
+      const specSubset = collectionSpecSubset[fieldName],
         field = documentSubset[fieldName];
 
-      if (has(documentSubset, fieldName)
-        && this.types[specSubset.type].allowChildren && specSubset.children
+      if (
+        has(documentSubset, fieldName) &&
+        this.types[specSubset.type].allowChildren &&
+        specSubset.children
       ) {
         if (Array.isArray(field)) {
           for (let i = 0; i < field.length; i++) {
             field[i] = this.recurseApplyDefault(
               isUpdate,
               field[i],
-              specSubset.children);
+              specSubset.children
+            );
           }
-        }
-        else {
+        } else {
           documentSubset[fieldName] = this.recurseApplyDefault(
             isUpdate,
             field,
-            specSubset.children);
+            specSubset.children
+          );
         }
-      }
-      else if (specSubset.defaultValue
-        && (field === null || (! isUpdate && ! has(documentSubset, fieldName)))
+      } else if (
+        specSubset.defaultValue &&
+        (field === null || (!isUpdate && !has(documentSubset, fieldName)))
       ) {
         documentSubset[fieldName] = specSubset.defaultValue;
       }
@@ -215,7 +227,7 @@ class Validation {
    * @param {string[]} errorMessages
    * @param {boolean} verbose
    */
-  recurseFieldValidation (
+  recurseFieldValidation(
     documentSubset,
     collectionSpecSubset,
     strictness,
@@ -224,36 +236,41 @@ class Validation {
   ) {
     if (strictness) {
       for (const field of Object.keys(documentSubset)) {
-        if (! collectionSpecSubset[field]) {
-          const error = new Error('strictness');
+        if (!collectionSpecSubset[field]) {
+          const error = new Error("strictness");
           error.details = { field };
           throw error;
         }
       }
     }
 
-    if (! verbose) {
+    if (!verbose) {
       // We stop as soon as one field is not valid
-      return Object.keys(collectionSpecSubset).every(fieldName =>
+      return Object.keys(collectionSpecSubset).every((fieldName) =>
         this.isValidField(
           fieldName,
           documentSubset,
           collectionSpecSubset,
           strictness,
           errorMessages,
-          verbose));
+          verbose
+        )
+      );
     }
 
     // We try to validate every field in order to get all error messages if any
     return Object.keys(collectionSpecSubset).reduce(
-      (reductionResult, fieldName) => this.isValidField(
-        fieldName,
-        documentSubset,
-        collectionSpecSubset,
-        strictness,
-        errorMessages,
-        verbose) && reductionResult,
-      true);
+      (reductionResult, fieldName) =>
+        this.isValidField(
+          fieldName,
+          documentSubset,
+          collectionSpecSubset,
+          strictness,
+          errorMessages,
+          verbose
+        ) && reductionResult,
+      true
+    );
   }
 
   /**
@@ -265,7 +282,7 @@ class Validation {
    * @param {boolean} verbose
    * @returns {boolean}
    */
-  isValidField (
+  isValidField(
     fieldName,
     documentSubset,
     collectionSpecSubset,
@@ -277,64 +294,70 @@ class Validation {
     const field = collectionSpecSubset[fieldName];
     let result = true;
 
-    if (field.mandatory
-      && ! has(field, 'defaultValue')
-      && _.isNil(documentSubset[fieldName])
+    if (
+      field.mandatory &&
+      !has(field, "defaultValue") &&
+      _.isNil(documentSubset[fieldName])
     ) {
       manageErrorMessage(
         field.path,
         errorMessages,
-        'The field is mandatory.',
-        verbose);
+        "The field is mandatory.",
+        verbose
+      );
       return false;
     }
 
-    if (! _.isNil(documentSubset[fieldName])) {
-      let
-        nestedStrictness = false,
+    if (!_.isNil(documentSubset[fieldName])) {
+      let nestedStrictness = false,
         fieldValues;
 
       if (field.multivalued.value) {
-        if (! Array.isArray(documentSubset[fieldName])) {
+        if (!Array.isArray(documentSubset[fieldName])) {
           manageErrorMessage(
             field.path,
             errorMessages,
-            'The field must be multivalued, unary value provided.',
-            verbose);
+            "The field must be multivalued, unary value provided.",
+            verbose
+          );
           return false;
         }
 
-        if ( has(field.multivalued, 'minCount')
-          && documentSubset[fieldName].length < field.multivalued.minCount
+        if (
+          has(field.multivalued, "minCount") &&
+          documentSubset[fieldName].length < field.multivalued.minCount
         ) {
           manageErrorMessage(
             field.path,
             errorMessages,
             `Not enough elements. Minimum count is set to ${field.multivalued.minCount}.`,
-            verbose);
+            verbose
+          );
           return false;
         }
 
-        if ( has(field.multivalued, 'maxCount')
-          && documentSubset[fieldName].length > field.multivalued.maxCount
+        if (
+          has(field.multivalued, "maxCount") &&
+          documentSubset[fieldName].length > field.multivalued.maxCount
         ) {
           manageErrorMessage(
             field.path,
             errorMessages,
             `Too many elements. Maximum count is set to ${field.multivalued.maxCount}.`,
-            verbose);
+            verbose
+          );
           return false;
         }
 
         fieldValues = documentSubset[fieldName];
-      }
-      else {
+      } else {
         if (Array.isArray(documentSubset[fieldName])) {
           manageErrorMessage(
             field.path,
             errorMessages,
-            'The field is not a multivalued field; Multiple values provided.',
-            verbose);
+            "The field is not a multivalued field; Multiple values provided.",
+            verbose
+          );
           return false;
         }
 
@@ -344,64 +367,61 @@ class Validation {
       if (this.types[field.type].allowChildren) {
         nestedStrictness = this.types[field.type].getStrictness(
           field.typeOptions,
-          strictness);
+          strictness
+        );
       }
 
       for (const val of fieldValues) {
         const fieldErrors = [];
 
-        if (! this.types[field.type].validate(
-          field.typeOptions,
-          val,
-          fieldErrors)
+        if (
+          !this.types[field.type].validate(field.typeOptions, val, fieldErrors)
         ) {
           if (fieldErrors.length === 0) {
             // We still want to trigger an error, even if no message is provided
             manageErrorMessage(
               field.path,
               errorMessages,
-              'An error has occurred during validation.',
-              verbose);
-          }
-          else {
-            fieldErrors.forEach(
-              message => manageErrorMessage(
-                field.path,
-                errorMessages,
-                message,
-                verbose));
+              "An error has occurred during validation.",
+              verbose
+            );
+          } else {
+            fieldErrors.forEach((message) =>
+              manageErrorMessage(field.path, errorMessages, message, verbose)
+            );
           }
           return false;
         }
 
         if (this.types[field.type].allowChildren && field.children) {
           try {
-            if (! this.recurseFieldValidation(
-              val,
-              field.children,
-              nestedStrictness,
-              errorMessages,
-              verbose
-            )) {
+            if (
+              !this.recurseFieldValidation(
+                val,
+                field.children,
+                nestedStrictness,
+                errorMessages,
+                verbose
+              )
+            ) {
               result = false;
             }
-          }
-          catch (error) {
-            if (error.message === 'strictness') {
+          } catch (error) {
+            if (error.message === "strictness") {
               manageErrorMessage(
                 field.path,
                 errorMessages,
                 `The field is set to "strict"; cannot add unspecified sub-field "${error.details.field}".`,
-                verbose);
-            }
-            else if (verbose) {
+                verbose
+              );
+            } else if (verbose) {
               manageErrorMessage(
                 field.path,
                 errorMessages,
                 error.message,
-                verbose);
-            }
-            else {
+                verbose
+              );
+            } else {
               throw error;
             }
 
@@ -416,51 +436,47 @@ class Validation {
   /**
    * @returns {Promise.<T>}
    */
-  curateSpecification () {
-    const
-      promises = [],
+  curateSpecification() {
+    const promises = [],
       specification = {};
 
-    return getValidationConfiguration()
-      .then(validation => {
-        this.rawConfiguration = validation;
-
-        for (const indexName of Object.keys(this.rawConfiguration)) {
-          for (const collectionName of Object.keys(
-            this.rawConfiguration[indexName])
-          ) {
-            const promise = this.curateCollectionSpecification(
-              indexName,
-              collectionName,
-              this.rawConfiguration[indexName][collectionName]
-            )
-              .then(curatedSpec => {
-
-                if (! has(specification, indexName)) {
-                  specification[indexName] = {};
-                }
-
-                specification[indexName][collectionName] = curatedSpec;
-
-                return null;
-              })
-              .catch(error => {
-                global.kuzzle.log.error(
-                  `Specification for the collection ${collectionName} triggered an error`);
-                global.kuzzle.log.error(`Error: ${error.message}`);
-
-                return null;
-              });
-            promises.push(promise);
-          }
+    return getValidationConfiguration().then((validation) => {
+      this.rawConfiguration = validation;
+
+      for (const indexName of Object.keys(this.rawConfiguration)) {
+        for (const collectionName of Object.keys(
+          this.rawConfiguration[indexName]
+        )) {
+          const promise = this.curateCollectionSpecification(
+            indexName,
+            collectionName,
+            this.rawConfiguration[indexName][collectionName]
+          )
+            .then((curatedSpec) => {
+              if (!has(specification, indexName)) {
+                specification[indexName] = {};
+              }
+
+              specification[indexName][collectionName] = curatedSpec;
+
+              return null;
+            })
+            .catch((error) => {
+              global.kuzzle.log.error(
+                `Specification for the collection ${collectionName} triggered an error`
+              );
+              global.kuzzle.log.error(`Error: ${error.message}`);
+
+              return null;
+            });
+          promises.push(promise);
         }
+      }
 
-        return Bluebird
-          .all(promises)
-          .then(() => {
-            this.specification = specification;
-          });
+      return Bluebird.all(promises).then(() => {
+        this.specification = specification;
       });
+    });
   }
 
   /**
@@ -470,7 +486,7 @@ class Validation {
    * @param {boolean} [verboseErrors]
    * @returns {Promise<object>}
    */
-  validateFormat (
+  validateFormat(
     indexName,
     collectionName,
     collectionSpec,
@@ -479,21 +495,24 @@ class Validation {
     // We make a deep clone to avoid side effects
     const specification = _.cloneDeep(collectionSpec);
 
-    return this.curateCollectionSpecification(
-      indexName,
-      collectionName,
-      specification,
-      true,
-      verboseErrors)
-      .then(result => {
-        if (verboseErrors && result.isValid === false) {
-          return result;
-        }
-        return { isValid: true };
-      })
-      // we do not want to reject since this method goal is
-      // to know what is going wrong with the given spec
-      .catch(error => ({ errors: [error], isValid: false }));
+    return (
+      this.curateCollectionSpecification(
+        indexName,
+        collectionName,
+        specification,
+        true,
+        verboseErrors
+      )
+        .then((result) => {
+          if (verboseErrors && result.isValid === false) {
+            return result;
+          }
+          return { isValid: true };
+        })
+        // we do not want to reject since this method goal is
+        // to know what is going wrong with the given spec
+        .catch((error) => ({ errors: [error], isValid: false }))
+    );
   }
 
   /**
@@ -505,26 +524,27 @@ class Validation {
    * @returns {Promise<CollectionSpecification>}
    * @rejects PreconditionError
    */
-  async curateCollectionSpecification (
+  async curateCollectionSpecification(
     index,
     collection,
     spec,
     dryRun = false,
     verbose = false
   ) {
-    let error = '';
+    let error = "";
     const processed = {
       fields: {},
       strict: spec.strict || false,
-      validators: null
+      validators: null,
     };
-    const allowed = ['strict', 'fields', 'validators'];
+    const allowed = ["strict", "fields", "validators"];
 
-    if (! checkAllowedProperties(spec, allowed)) {
+    if (!checkAllowedProperties(spec, allowed)) {
       error = assertionError.get(
-        'unexpected_properties',
+        "unexpected_properties",
         `${index}.${collection}`,
-        allowed.join(', '));
+        allowed.join(", ")
+      );
 
       if (verbose) {
         return { errors: [error.message], isValid: false };
@@ -538,7 +558,8 @@ class Validation {
         spec,
         index,
         collection,
-        verbose);
+        verbose
+      );
 
       if (result.isValid === false) {
         if (verbose) {
@@ -546,7 +567,10 @@ class Validation {
           return result;
         }
 
-        throw assertionError.get('invalid_specifications', result.errors.join('\n\t- '));
+        throw assertionError.get(
+          "invalid_specifications",
+          result.errors.join("\n\t- ")
+        );
       }
       processed.fields = result;
     }
@@ -557,33 +581,31 @@ class Validation {
           index,
           collection,
           spec.validators,
-          dryRun);
+          dryRun
+        );
 
         processed.validators = filterId;
-      }
-      catch (e) {
+      } catch (e) {
         global.kuzzle.log.error(e);
-        throw assertionError.getFrom(e, 'invalid_filters', e.message);
+        throw assertionError.getFrom(e, "invalid_filters", e.message);
       }
     }
 
     return processed;
   }
 
-  structureCollectionValidation (
+  structureCollectionValidation(
     collectionSpec,
     indexName,
     collectionName,
     verboseErrors = false
   ) {
     const fields = {};
-    let
-      errors = [],
+    let errors = [],
       maxDepth = 0;
 
     for (const fieldName of Object.keys(collectionSpec.fields)) {
-      const
-        // We deep clone the field because we will modify it
+      const // We deep clone the field because we will modify it
         fieldSpecClone = _.cloneDeep(collectionSpec.fields[fieldName]);
 
       try {
@@ -592,30 +614,29 @@ class Validation {
           indexName,
           collectionName,
           fieldName,
-          verboseErrors);
+          verboseErrors
+        );
 
         if (result.isValid === false) {
           errors = _.concat(errors, result.errors);
-          global.kuzzle.log.error(result.errors.join('\n'));
-        }
-        else {
+          global.kuzzle.log.error(result.errors.join("\n"));
+        } else {
           const field = result.fieldSpec;
 
-          field.path = fieldName.split('/');
+          field.path = fieldName.split("/");
           field.depth = field.path.length;
 
           if (field.depth > maxDepth) {
             maxDepth = field.depth;
           }
 
-          if (! fields[field.depth]) {
+          if (!fields[field.depth]) {
             fields[field.depth] = [];
           }
 
           fields[field.depth].push(field);
         }
-      }
-      catch (error) {
+      } catch (error) {
         global.kuzzle.log.error(error);
         throwOrStoreError(error, verboseErrors, errors);
       }
@@ -640,7 +661,7 @@ class Validation {
    * @returns {object}
    * @throws PreconditionError
    */
-  curateFieldSpecification (
+  curateFieldSpecification(
     fieldSpec,
     indexName,
     collectionName,
@@ -662,43 +683,46 @@ class Validation {
     }
 
     _.defaultsDeep(fieldSpec, {
-      'mandatory': false,
-      'multivalued': {
-        value: false
-      }
+      mandatory: false,
+      multivalued: {
+        value: false,
+      },
     });
 
-    if (! has(fieldSpec, 'typeOptions')) {
+    if (!has(fieldSpec, "typeOptions")) {
       fieldSpec.typeOptions = {};
     }
 
     const allowed = this.types[fieldSpec.type].allowedTypeOptions || [];
 
-    if (! checkAllowedProperties(fieldSpec.typeOptions, allowed)) {
+    if (!checkAllowedProperties(fieldSpec.typeOptions, allowed)) {
       throwOrStoreError(
         assertionError.get(
-          'unexpected_properties',
+          "unexpected_properties",
           `${indexName}.${collectionName}.${fieldName}`,
-          allowed.join(', ')),
+          allowed.join(", ")
+        ),
         verboseErrors,
-        errors);
+        errors
+      );
     }
 
     try {
-      fieldSpec.typeOptions = this.types[fieldSpec.type]
-        .validateFieldSpecification(fieldSpec.typeOptions);
-    }
-    catch (e) {
-      if (! verboseErrors) {
+      fieldSpec.typeOptions = this.types[
+        fieldSpec.type
+      ].validateFieldSpecification(fieldSpec.typeOptions);
+    } catch (e) {
+      if (!verboseErrors) {
         if (e instanceof KuzzleError) {
           throw e;
         }
         throw kerror.getFrom(
           e,
-          'plugin',
-          'runtime',
-          'unexpected_error',
-          e.message);
+          "plugin",
+          "runtime",
+          "unexpected_error",
+          e.message
+        );
       }
 
       errors.push(e.message);
@@ -709,11 +733,12 @@ class Validation {
     }
 
     debug(
-      'Loaded field validator: %s/%s/%s: %o',
+      "Loaded field validator: %s/%s/%s: %o",
       indexName,
       collectionName,
       fieldName,
-      fieldSpec);
+      fieldSpec
+    );
 
     return { fieldSpec, isValid: true };
   }
@@ -727,7 +752,7 @@ class Validation {
    * @returns {object}
    * @throws PreconditionError
    */
-  curateFieldSpecificationFormat (
+  curateFieldSpecificationFormat(
     fieldSpec,
     indexName,
     collectionName,
@@ -737,100 +762,118 @@ class Validation {
     const errors = [];
 
     const props = [
-      'mandatory',
-      'type',
-      'defaultValue',
-      'description',
-      'multivalued',
-      'typeOptions'
+      "mandatory",
+      "type",
+      "defaultValue",
+      "description",
+      "multivalued",
+      "typeOptions",
     ];
 
-    if (! checkAllowedProperties(fieldSpec, props)) {
+    if (!checkAllowedProperties(fieldSpec, props)) {
       throwOrStoreError(
         assertionError.get(
-          'unexpected_properties',
+          "unexpected_properties",
           `${indexName}.${collectionName}.${fieldName}`,
-          props.join(', ')),
+          props.join(", ")
+        ),
         verboseErrors,
-        errors);
+        errors
+      );
     }
 
-    if (! has(fieldSpec, 'type')) {
+    if (!has(fieldSpec, "type")) {
       throwOrStoreError(
         assertionError.get(
-          'missing_type',
-          `${indexName}.${collectionName}.${fieldName}`),
+          "missing_type",
+          `${indexName}.${collectionName}.${fieldName}`
+        ),
         verboseErrors,
-        errors);
+        errors
+      );
     }
 
-    if (! has(this.types, fieldSpec.type)) {
+    if (!has(this.types, fieldSpec.type)) {
       throwOrStoreError(
         assertionError.get(
-          'unknown_type',
+          "unknown_type",
           `${indexName}.${collectionName}.${fieldName}`,
-          fieldSpec.type),
+          fieldSpec.type
+        ),
         verboseErrors,
-        errors);
+        errors
+      );
     }
 
-    if (has(fieldSpec, 'multivalued')) {
-      const multivaluedProps = ['value', 'minCount', 'maxCount'];
-      if (! checkAllowedProperties(fieldSpec.multivalued, multivaluedProps)) {
+    if (has(fieldSpec, "multivalued")) {
+      const multivaluedProps = ["value", "minCount", "maxCount"];
+      if (!checkAllowedProperties(fieldSpec.multivalued, multivaluedProps)) {
         throwOrStoreError(
           assertionError.get(
-            'unexpected_properties',
+            "unexpected_properties",
             `${indexName}.${collectionName}.${fieldName}.multivalued`,
-            multivaluedProps.join(', ')),
+            multivaluedProps.join(", ")
+          ),
           verboseErrors,
-          errors);
+          errors
+        );
       }
 
-      if (! has(fieldSpec.multivalued, 'value')) {
+      if (!has(fieldSpec.multivalued, "value")) {
         throwOrStoreError(
           assertionError.get(
-            'missing_value',
-            `${indexName}.${collectionName}.${fieldName}.multivalued`),
+            "missing_value",
+            `${indexName}.${collectionName}.${fieldName}.multivalued`
+          ),
           verboseErrors,
-          errors);
+          errors
+        );
       }
 
-      if (typeof fieldSpec.multivalued.value !== 'boolean') {
+      if (typeof fieldSpec.multivalued.value !== "boolean") {
         throwOrStoreError(
           assertionError.get(
-            'invalid_type',
+            "invalid_type",
             `${indexName}.${collectionName}.${fieldName}.multivalued.value`,
-            'boolean'),
+            "boolean"
+          ),
           verboseErrors,
-          errors);
+          errors
+        );
       }
 
-      for (const unexpected of ['minCount', 'maxCount']) {
-        if ( ! fieldSpec.multivalued.value
-          && has(fieldSpec.multivalued, unexpected)
+      for (const unexpected of ["minCount", "maxCount"]) {
+        if (
+          !fieldSpec.multivalued.value &&
+          has(fieldSpec.multivalued, unexpected)
         ) {
           throwOrStoreError(
             assertionError.get(
-              'not_multivalued',
+              "not_multivalued",
               `${indexName}.${collectionName}.${fieldName}`,
-              unexpected),
+              unexpected
+            ),
             verboseErrors,
-            errors);
+            errors
+          );
         }
       }
 
-      if ( has(fieldSpec.multivalued, 'minCount')
-        && has(fieldSpec.multivalued, 'maxCount')
-        && fieldSpec.multivalued.minCount > fieldSpec.multivalued.maxCount
+      if (
+        has(fieldSpec.multivalued, "minCount") &&
+        has(fieldSpec.multivalued, "maxCount") &&
+        fieldSpec.multivalued.minCount > fieldSpec.multivalued.maxCount
       ) {
         throwOrStoreError(
           assertionError.get(
-            'invalid_range',
+            "invalid_range",
             `${indexName}.${collectionName}.${fieldName}`,
-            'minCount',
-            'maxCount'),
+            "minCount",
+            "maxCount"
+          ),
           verboseErrors,
-          errors);
+          errors
+        );
       }
     }
 
@@ -848,25 +891,27 @@ class Validation {
    * @param {boolean} dryRun
    * @returns {string}
    */
-  curateValidatorFilter (indexName, collectionName, validatorFilter, dryRun) {
+  curateValidatorFilter(indexName, collectionName, validatorFilter, dryRun) {
     const query = {
       bool: {
-        must: validatorFilter
-      }
+        must: validatorFilter,
+      },
     };
 
     this.koncorde.validate(query);
 
-    if (! dryRun) {
+    if (!dryRun) {
       debug(
-        'Registering filter validator %s/%s: %O',
+        "Registering filter validator %s/%s: %O",
         indexName,
         collectionName,
-        query);
+        query
+      );
 
       return this.koncorde.register(
         query,
-        toKoncordeIndex(indexName, collectionName));
+        toKoncordeIndex(indexName, collectionName)
+      );
     }
 
     return null;
@@ -876,45 +921,49 @@ class Validation {
    * @param {ValidationType} validationType
    * @throws {PluginImplementationError}
    */
-  addType (validationType) {
-    if (! validationType.typeName) {
-      throw kerror.get('validation', 'types', 'missing_type_name');
+  addType(validationType) {
+    if (!validationType.typeName) {
+      throw kerror.get("validation", "types", "missing_type_name");
     }
 
-    if ( ! validationType.validate
-      || typeof validationType.validate !== 'function'
+    if (
+      !validationType.validate ||
+      typeof validationType.validate !== "function"
     ) {
       throw kerror.get(
-        'validation',
-        'types',
-        'missing_function',
+        "validation",
+        "types",
+        "missing_function",
         validationType.typeName,
-        'validate');
+        "validate"
+      );
     }
 
-    if ( ! validationType.validateFieldSpecification
-      || typeof validationType.validateFieldSpecification !== 'function'
+    if (
+      !validationType.validateFieldSpecification ||
+      typeof validationType.validateFieldSpecification !== "function"
     ) {
       throw kerror.get(
-        'validation',
-        'types',
-        'missing_function',
+        "validation",
+        "types",
+        "missing_function",
         validationType.typeName,
-        'validateFieldSpecification');
+        "validateFieldSpecification"
+      );
     }
 
-    if (has(validationType, 'allowChildren')
-      && validationType.allowChildren
-    ) {
-      if (! validationType.getStrictness
-        || typeof validationType.getStrictness !== 'function'
+    if (has(validationType, "allowChildren") && validationType.allowChildren) {
+      if (
+        !validationType.getStrictness ||
+        typeof validationType.getStrictness !== "function"
       ) {
         throw kerror.get(
-          'validation',
-          'types',
-          'missing_function',
+          "validation",
+          "types",
+          "missing_function",
           validationType.typeName,
-          'getStrictness');
+          "getStrictness"
+        );
       }
 
       this.typeAllowsChildren.push(validationType.typeName);
@@ -922,15 +971,15 @@ class Validation {
 
     if (this.types[validationType.typeName]) {
       throw kerror.get(
-        'validation',
-        'types',
-        'already_exists',
-        validationType.typeName);
+        "validation",
+        "types",
+        "already_exists",
+        validationType.typeName
+      );
     }
 
     this.types[validationType.typeName] = validationType;
   }
-
 }
 
 /**
@@ -938,13 +987,14 @@ class Validation {
  * @param {string[]} allowedProperties
  * @returns {boolean}
  */
-function checkAllowedProperties (object, allowedProperties) {
-  if (! isPlainObject(object)) {
+function checkAllowedProperties(object, allowedProperties) {
+  if (!isPlainObject(object)) {
     return false;
   }
 
-  return ! Object.keys(object).some(
-    propertyName => ! allowedProperties.includes(propertyName));
+  return !Object.keys(object).some(
+    (propertyName) => !allowedProperties.includes(propertyName)
+  );
 }
 
 /**
@@ -953,29 +1003,27 @@ function checkAllowedProperties (object, allowedProperties) {
  * @param {number} maxDepth : depth of the fields; counting starts at 1
  * @throws PreconditionError
  */
-function curateStructuredFields (typeAllowsChildren, fields, maxDepth) {
-  const
-    /** @type StructuredFieldSpecification */
+function curateStructuredFields(typeAllowsChildren, fields, maxDepth) {
+  const /** @type StructuredFieldSpecification */
     structuredFields = {
       children: {},
-      root: true
+      root: true,
     };
 
   for (let i = 1; i <= maxDepth; i++) {
-    if (! has(fields, i)) {
-      throw assertionError.get('missing_nested_spec');
+    if (!has(fields, i)) {
+      throw assertionError.get("missing_nested_spec");
     }
 
-    fields[i].forEach(field => {
-      const
-        parent = getParent(structuredFields, field.path),
+    fields[i].forEach((field) => {
+      const parent = getParent(structuredFields, field.path),
         childKey = field.path[field.path.length - 1];
 
-      if (! parent.root && typeAllowsChildren.indexOf(parent.type) === -1) {
-        throw assertionError.get('unexpected_children', parent.type);
+      if (!parent.root && typeAllowsChildren.indexOf(parent.type) === -1) {
+        throw assertionError.get("unexpected_children", parent.type);
       }
 
-      if (! has(parent, 'children')) {
+      if (!has(parent, "children")) {
         parent.children = {};
       }
 
@@ -991,7 +1039,7 @@ function curateStructuredFields (typeAllowsChildren, fields, maxDepth) {
  * @param {string[]}fieldPath
  * @returns {StructuredFieldSpecification}
  */
-function getParent (structuredFields, fieldPath) {
+function getParent(structuredFields, fieldPath) {
   if (fieldPath.length === 1) {
     return structuredFields;
   }
@@ -999,8 +1047,8 @@ function getParent (structuredFields, fieldPath) {
   let pointer = structuredFields;
 
   for (let i = 0; i < fieldPath.length - 1; i++) {
-    if (! has(pointer.children, fieldPath[i])) {
-      throw assertionError.get('missing_parent', fieldPath.join('.'));
+    if (!has(pointer.children, fieldPath[i])) {
+      throw assertionError.get("missing_parent", fieldPath.join("."));
     }
 
     pointer = pointer.children[fieldPath[i]];
@@ -1014,8 +1062,8 @@ function getParent (structuredFields, fieldPath) {
  * @param {boolean} doNotThrow
  * @param {string[]} errors
  */
-function throwOrStoreError (error, doNotThrow, errorMessages) {
-  if (! doNotThrow) {
+function throwOrStoreError(error, doNotThrow, errorMessages) {
+  if (!doNotThrow) {
     throw error;
   }
 
@@ -1028,50 +1076,48 @@ function throwOrStoreError (error, doNotThrow, errorMessages) {
  * @param {string} message
  * @param {boolean} structured
  */
-function manageErrorMessage (errorContext, errorHolder, message, structured) {
+function manageErrorMessage(errorContext, errorHolder, message, structured) {
   if (structured) {
-    if (errorContext === 'document') {
-      if (! errorHolder.documentScope) {
+    if (errorContext === "document") {
+      if (!errorHolder.documentScope) {
         errorHolder.documentScope = [];
       }
 
       errorHolder.documentScope.push(message);
-    }
-    else {
-      if (! errorHolder.fieldScope) {
+    } else {
+      if (!errorHolder.fieldScope) {
         errorHolder.fieldScope = {};
       }
 
       let pointer = errorHolder.fieldScope;
 
       for (let i = 0; i < errorContext.length; i++) {
-        if (! pointer.children) {
+        if (!pointer.children) {
           pointer.children = {};
         }
 
-        if (! has(pointer.children, errorContext[i])) {
+        if (!has(pointer.children, errorContext[i])) {
           pointer.children[errorContext[i]] = {};
         }
         pointer = pointer.children[errorContext[i]];
       }
 
-      if (! has(pointer, 'messages')) {
+      if (!has(pointer, "messages")) {
         pointer.messages = [];
       }
 
       pointer.messages.push(message);
     }
-  }
-  else if (errorContext === 'document') {
-    throw kerror.get('validation', 'check', 'failed_document', message);
-  }
-  else {
+  } else if (errorContext === "document") {
+    throw kerror.get("validation", "check", "failed_document", message);
+  } else {
     throw kerror.get(
-      'validation',
-      'check',
-      'failed_field',
-      errorContext.join('.'),
-      message);
+      "validation",
+      "check",
+      "failed_field",
+      errorContext.join("."),
+      message
+    );
   }
 }
 
@@ -1081,49 +1127,47 @@ function manageErrorMessage (errorContext, errorHolder, message, structured) {
  *
  * @returns {Promise}
  */
-function getValidationConfiguration () {
+function getValidationConfiguration() {
   return global.kuzzle.internalIndex
-    .search('validations', {}, { from: 0, size: 1000 })
-    .then(result => {
+    .search("validations", {}, { from: 0, size: 1000 })
+    .then((result) => {
       let validation = {};
 
-      if ( result
-        && Array.isArray(result.hits)
-        && result.hits.length > 0
-      ) {
+      if (result && Array.isArray(result.hits) && result.hits.length > 0) {
         for (const { _source, _id } of result.hits) {
-          const collectionName = `${_id.split('#')[0]}/${_id.split('#')[1]}`;
+          const collectionName = `${_id.split("#")[0]}/${_id.split("#")[1]}`;
 
-          if (! get(_source, 'index')) {
+          if (!get(_source, "index")) {
             throw assertionError.get(
-              'incorrect_validation_format',
+              "incorrect_validation_format",
               collectionName,
-              'index');
+              "index"
+            );
           }
 
-          if (! get(_source, 'collection')) {
+          if (!get(_source, "collection")) {
             throw assertionError.get(
-              'incorrect_validation_format',
+              "incorrect_validation_format",
               collectionName,
-              'collection');
+              "collection"
+            );
           }
 
-          if (! get(_source, 'validation')) {
+          if (!get(_source, "validation")) {
             throw assertionError.get(
-              'incorrect_validation_format',
+              "incorrect_validation_format",
               collectionName,
-              'validation');
+              "validation"
+            );
           }
 
-          if (! has(validation, _source.index)) {
+          if (!has(validation, _source.index)) {
             validation[_source.index] = {};
           }
 
-          validation[_source.index][_source.collection] =
-            _source.validation;
+          validation[_source.index][_source.collection] = _source.validation;
         }
-      }
-      else if (global.kuzzle.config.validation) {
+      } else if (global.kuzzle.config.validation) {
         // We can't wait prepareDb as it runs outside of the rest of the start
         validation = global.kuzzle.config.validation;
       }