kuzzle 2.19.2 → 2.19.3

package/lib/core/validation/types/email.js

@@ -19,22 +19,21 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const
-  kerror = require('../../../kerror').wrap('validation', 'assert'),
-  BaseType = require('../baseType'),
-  validator = require('validator');
+const kerror = require("../../../kerror").wrap("validation", "assert"),
+  BaseType = require("../baseType"),
+  validator = require("validator");
 
 /**
  * @class EmailType
  */
 class EmailType extends BaseType {
-  constructor () {
+  constructor() {
     super();
-    this.typeName = 'email';
+    this.typeName = "email";
     this.allowChildren = false;
-    this.allowedTypeOptions = ['notEmpty'];
+    this.allowedTypeOptions = ["notEmpty"];
   }
 
   /**
@@ -43,31 +42,31 @@ class EmailType extends BaseType {
    * @param {string[]} errorMessages
    * @returns {boolean}
    */
-  validate (typeOptions, fieldValue, errorMessages) {
+  validate(typeOptions, fieldValue, errorMessages) {
     if (fieldValue === undefined || fieldValue === null) {
       if (typeOptions.notEmpty) {
-        errorMessages.push('Field cannot be undefined or null');
+        errorMessages.push("Field cannot be undefined or null");
         return false;
       }
 
       return true;
     }
 
-    if (typeof fieldValue !== 'string') {
-      errorMessages.push('The field must be a string.');
+    if (typeof fieldValue !== "string") {
+      errorMessages.push("The field must be a string.");
       return false;
     }
 
     if (fieldValue.length === 0) {
       if (typeOptions.notEmpty === true) {
-        errorMessages.push('The string must not be empty.');
+        errorMessages.push("The string must not be empty.");
         return false;
       }
       return true;
     }
 
-    if (! validator.isEmail(fieldValue)) {
-      errorMessages.push('The string must be a valid email address.');
+    if (!validator.isEmail(fieldValue)) {
+      errorMessages.push("The string must be a valid email address.");
       return false;
     }
 
@@ -79,14 +78,12 @@ class EmailType extends BaseType {
    * @returns {TypeOptions}
    * @throws {PreconditionError}
    */
-  validateFieldSpecification (typeOptions) {
-    if (! Object.prototype.hasOwnProperty.call(typeOptions, 'notEmpty')) {
+  validateFieldSpecification(typeOptions) {
+    if (!Object.prototype.hasOwnProperty.call(typeOptions, "notEmpty")) {
       typeOptions.notEmpty = false;
+    } else if (typeof typeOptions.notEmpty !== "boolean") {
+      throw kerror.get("invalid_type", "notEmpty", "boolean");
     }
-    else if (typeof typeOptions.notEmpty !== 'boolean') {
-      throw kerror.get('invalid_type', 'notEmpty', 'boolean');
-    }
-
 
     return typeOptions;
   }

package/lib/core/validation/types/enum.js

@@ -19,21 +19,20 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const
-  kerror = require('../../../kerror'),
-  BaseType = require('../baseType');
+const kerror = require("../../../kerror"),
+  BaseType = require("../baseType");
 
 /**
  * @class EnumType
  */
 class EnumType extends BaseType {
-  constructor () {
+  constructor() {
     super();
-    this.typeName = 'enum';
+    this.typeName = "enum";
     this.allowChildren = false;
-    this.allowedTypeOptions = ['values'];
+    this.allowedTypeOptions = ["values"];
   }
 
   /**
@@ -42,15 +41,18 @@ class EnumType extends BaseType {
    * @param {string[]} errorMessages
    * @returns {boolean}
    */
-  validate (typeOptions, fieldValue, errorMessages) {
-    if (typeof fieldValue !== 'string') {
-      errorMessages.push('The field must be a string.');
+  validate(typeOptions, fieldValue, errorMessages) {
+    if (typeof fieldValue !== "string") {
+      errorMessages.push("The field must be a string.");
       return false;
     }
 
-    if (! typeOptions.values.includes(fieldValue)) {
+    if (!typeOptions.values.includes(fieldValue)) {
       errorMessages.push(
-        `The field only accepts following values: "${typeOptions.values.join(', ')}".`);
+        `The field only accepts following values: "${typeOptions.values.join(
+          ", "
+        )}".`
+      );
       return false;
     }
 
@@ -62,22 +64,33 @@ class EnumType extends BaseType {
    * @returns {TypeOptions}
    * @throws {PreconditionError}
    */
-  validateFieldSpecification (typeOptions) {
-    if (! Object.prototype.hasOwnProperty.call(typeOptions, 'values')) {
-      throw kerror.get('validation', 'types', 'missing_enum_values');
+  validateFieldSpecification(typeOptions) {
+    if (!Object.prototype.hasOwnProperty.call(typeOptions, "values")) {
+      throw kerror.get("validation", "types", "missing_enum_values");
     }
 
-    if (! Array.isArray(typeOptions.values)
-      || typeOptions.values.length === 0
-    ) {
-      throw kerror.get('validation', 'assert', 'invalid_type', 'values', 'string[]');
+    if (!Array.isArray(typeOptions.values) || typeOptions.values.length === 0) {
+      throw kerror.get(
+        "validation",
+        "assert",
+        "invalid_type",
+        "values",
+        "string[]"
+      );
     }
 
     const nonString = typeOptions.values.filter(
-      value => typeof value !== 'string');
+      (value) => typeof value !== "string"
+    );
 
     if (nonString.length > 0) {
-      throw kerror.get('validation', 'assert', 'invalid_type', 'values', 'string[]');
+      throw kerror.get(
+        "validation",
+        "assert",
+        "invalid_type",
+        "values",
+        "string[]"
+      );
     }
 
     return typeOptions;

package/lib/core/validation/types/geoPoint.js

@@ -19,18 +19,18 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const BaseType = require('../baseType');
-const { Koncorde } = require('../../shared/KoncordeWrapper');
+const BaseType = require("../baseType");
+const { Koncorde } = require("../../shared/KoncordeWrapper");
 
 /**
  * @class GeoPointType
  */
 class GeoPointType extends BaseType {
-  constructor () {
+  constructor() {
     super();
-    this.typeName = 'geo_point';
+    this.typeName = "geo_point";
     this.allowChildren = false;
     this.allowedTypeOptions = [];
   }
@@ -41,9 +41,9 @@ class GeoPointType extends BaseType {
    * @param {string[]} errorMessages
    * @returns {boolean}
    */
-  validate (typeOptions, fieldValue, errorMessages) {
+  validate(typeOptions, fieldValue, errorMessages) {
     if (Koncorde.convertGeopoint(fieldValue) === null) {
-      errorMessages.push('Invalid GeoPoint format');
+      errorMessages.push("Invalid GeoPoint format");
       return false;
     }
 

package/lib/core/validation/types/geoShape.js

@@ -19,55 +19,50 @@
  * limitations under the License.
  */
 
-'use strict';
+"use strict";
 
-const { Koncorde } = require('koncorde');
+const { Koncorde } = require("koncorde");
 
-const kerror = require('../../../kerror');
-const BaseType = require('../baseType');
+const kerror = require("../../../kerror");
+const BaseType = require("../baseType");
 
-const
-  allowedShapeProperties = [
-    'type',
-    'coordinates',
-    'radius',
-    'orientation',
-    'geometries'
+const allowedShapeProperties = [
+    "type",
+    "coordinates",
+    "radius",
+    "orientation",
+    "geometries",
   ],
   allowedOrientations = [
-    'right',
-    'ccw',
-    'counterclockwise',
-    'left',
-    'cw',
-    'clockwise'
-  ],
-  multiTypes = [
-    'multipoint',
-    'multilinestring',
-    'multipolygon'
+    "right",
+    "ccw",
+    "counterclockwise",
+    "left",
+    "cw",
+    "clockwise",
   ],
+  multiTypes = ["multipoint", "multilinestring", "multipolygon"],
   allowedShapeTypes = [
-    'point',
-    'linestring',
-    'polygon',
-    'multipoint',
-    'multilinestring',
-    'multipolygon',
-    'geometrycollection',
-    'envelope',
-    'circle'
+    "point",
+    "linestring",
+    "polygon",
+    "multipoint",
+    "multilinestring",
+    "multipolygon",
+    "geometrycollection",
+    "envelope",
+    "circle",
   ];
 
 /**
  * @class GeoShapeType
  */
 class GeoShapeType extends BaseType {
-  constructor () {
+  constructor() {
     super();
-    this.typeName = 'geo_shape';
+    this.typeName = "geo_shape";
     this.allowChildren = false;
-    this.allowedTypeOptions = ['shapeTypes'];
+    this.allowedTypeOptions = ["shapeTypes"];
   }
 
   /**
@@ -76,7 +71,7 @@ class GeoShapeType extends BaseType {
    * @param {string[]} errorMessages
    * @returns {boolean}
    */
-  validate (typeOptions, fieldValue, errorMessages) {
+  validate(typeOptions, fieldValue, errorMessages) {
     return this.recursiveShapeValidation(
       typeOptions.shapeTypes,
       fieldValue,
@@ -90,67 +85,67 @@ class GeoShapeType extends BaseType {
    * @param {string[]} errorMessages
    * @returns {boolean}
    */
-  recursiveShapeValidation (allowedShapes, shape, errorMessages) {
-    if (! this.checkStructure(allowedShapes, shape, errorMessages)) {
+  recursiveShapeValidation(allowedShapes, shape, errorMessages) {
+    if (!this.checkStructure(allowedShapes, shape, errorMessages)) {
       return false;
     }
 
     const isMulti = multiTypes.indexOf(shape.type) !== -1;
-    let
-      coordinateValidation,
+    let coordinateValidation,
       result = true;
 
     switch (shape.type) {
-      case 'point':
-      case 'multipoint':
+      case "point":
+      case "multipoint":
         coordinateValidation = isPoint;
         break;
-      case 'linestring':
-      case 'multilinestring':
+      case "linestring":
+      case "multilinestring":
         coordinateValidation = isLine;
         break;
-      case 'polygon':
-      case 'multipolygon':
+      case "polygon":
+      case "multipolygon":
         coordinateValidation = isPolygon;
-        if (shape.orientation
-          && ! allowedOrientations.includes(shape.orientation)
+        if (
+          shape.orientation &&
+          !allowedOrientations.includes(shape.orientation)
         ) {
-          errorMessages.push('The orientation property has not a valid value.');
+          errorMessages.push("The orientation property has not a valid value.");
           result = false;
         }
         break;
-      case 'geometrycollection':
+      case "geometrycollection":
         coordinateValidation = () => true;
 
         for (let i = 0; i < shape.geometries.length; i++) {
-          if (! this.recursiveShapeValidation(
-            allowedShapes,
-            shape.geometries[i],
-            errorMessages)
+          if (
+            !this.recursiveShapeValidation(
+              allowedShapes,
+              shape.geometries[i],
+              errorMessages
+            )
           ) {
             result = false;
           }
         }
         break;
-      case 'envelope':
+      case "envelope":
         coordinateValidation = isEnvelope;
         break;
-      case 'circle':
+      case "circle":
         coordinateValidation = isPoint;
-        if (typeof shape.radius === 'string') {
+        if (typeof shape.radius === "string") {
           try {
-            if (typeof Koncorde.convertDistance(shape.radius) !== 'number') {
-              errorMessages.push('The radius property has not a valid format.');
+            if (typeof Koncorde.convertDistance(shape.radius) !== "number") {
+              errorMessages.push("The radius property has not a valid format.");
               result = false;
             }
-          }
-          catch (error) {
-            errorMessages.push('The radius property has not a valid format.');
+          } catch (error) {
+            errorMessages.push("The radius property has not a valid format.");
             result = false;
           }
-        }
-        else if (typeof shape.radius !== 'number') {
-          errorMessages.push('The radius property has not a valid format.');
+        } else if (typeof shape.radius !== "number") {
+          errorMessages.push("The radius property has not a valid format.");
           result = false;
         }
         break;
@@ -162,16 +157,17 @@ class GeoShapeType extends BaseType {
     }
 
     if (isMulti) {
-      if (shape.coordinates.some(
-        coordinate => ! coordinateValidation(coordinate)
-      )) {
+      if (
+        shape.coordinates.some(
+          (coordinate) => !coordinateValidation(coordinate)
+        )
+      ) {
         errorMessages.push(
           `One of the shapes in  the shape type "${shape.type}" has bad coordinates.`
         );
         result = false;
       }
-    }
-    else if (! coordinateValidation(shape.coordinates)) {
+    } else if (!coordinateValidation(shape.coordinates)) {
       errorMessages.push(`The shape type "${shape.type}" has bad coordinates.`);
       return false;
     }
@@ -185,63 +181,80 @@ class GeoShapeType extends BaseType {
    * @param {string[]} errorMessages
    * @returns {boolean}
    */
-  checkStructure (allowedShapes, shape, errorMessages) {
+  checkStructure(allowedShapes, shape, errorMessages) {
     let result = true;
 
-    if (! shape.type) {
-      errorMessages.push('The shape object has no type defined.');
+    if (!shape.type) {
+      errorMessages.push("The shape object has no type defined.");
       return false;
     }
 
-    if (! this.checkAllowedProperties(shape, allowedShapeProperties)) {
-      errorMessages.push('The shape object has a not allowed property.');
+    if (!this.checkAllowedProperties(shape, allowedShapeProperties)) {
+      errorMessages.push("The shape object has a not allowed property.");
       result = false;
     }
 
     if (allowedShapes.indexOf(shape.type) === -1) {
-      errorMessages.push('The provided shape type is not allowed.');
+      errorMessages.push("The provided shape type is not allowed.");
       result = false;
     }
 
-    if (shape.type === 'geometrycollection' && shape.coordinates) {
-      errorMessages.push('The coordinates property must not be provided for the "geometrycollection" shape type.');
+    if (shape.type === "geometrycollection" && shape.coordinates) {
+      errorMessages.push(
+        'The coordinates property must not be provided for the "geometrycollection" shape type.'
+      );
       result = false;
     }
 
-    if (shape.type !== 'geometrycollection'
-      && (! shape.coordinates || ! Array.isArray(shape.coordinates)
-      )) {
-      errorMessages.push(`The coordinates property must be provided for the "${shape.type}" shape type.`);
+    if (
+      shape.type !== "geometrycollection" &&
+      (!shape.coordinates || !Array.isArray(shape.coordinates))
+    ) {
+      errorMessages.push(
+        `The coordinates property must be provided for the "${shape.type}" shape type.`
+      );
       result = false;
     }
 
-    if (shape.type === 'circle' && ! shape.radius) {
-      errorMessages.push('The radius property is mandatory for the "circle" shape type.');
+    if (shape.type === "circle" && !shape.radius) {
+      errorMessages.push(
+        'The radius property is mandatory for the "circle" shape type.'
+      );
       result = false;
     }
 
-    if (shape.type !== 'circle' && shape.radius) {
-      errorMessages.push(`The radius property must not be provided for the "${shape.type}" shape type.`);
+    if (shape.type !== "circle" && shape.radius) {
+      errorMessages.push(
+        `The radius property must not be provided for the "${shape.type}" shape type.`
+      );
       result = false;
     }
 
-    if (shape.type !== 'polygon'
-      && shape.type !== 'multipolygon'
-      && shape.orientation
+    if (
+      shape.type !== "polygon" &&
+      shape.type !== "multipolygon" &&
+      shape.orientation
     ) {
-      errorMessages.push(`The orientation property must not be provided for the "${shape.type}" shape type.`);
+      errorMessages.push(
+        `The orientation property must not be provided for the "${shape.type}" shape type.`
+      );
       result = false;
     }
 
-    if (shape.type !== 'geometrycollection' && shape.geometries) {
-      errorMessages.push(`The geometries property must not be provided for the "${shape.type}" shape type.`);
+    if (shape.type !== "geometrycollection" && shape.geometries) {
+      errorMessages.push(
+        `The geometries property must not be provided for the "${shape.type}" shape type.`
+      );
       result = false;
     }
 
-    if (shape.type === 'geometrycollection'
-      && (! shape.geometries || ! Array.isArray(shape.geometries)
-      )) {
-      errorMessages.push('The geometries property must be provided for the "geometrycollection" shape type.');
+    if (
+      shape.type === "geometrycollection" &&
+      (!shape.geometries || !Array.isArray(shape.geometries))
+    ) {
+      errorMessages.push(
+        'The geometries property must be provided for the "geometrycollection" shape type.'
+      );
       result = false;
     }
 
@@ -253,22 +266,29 @@ class GeoShapeType extends BaseType {
    * @returns {TypeOptions}
    * @throws {PreconditionError}
    */
-  validateFieldSpecification (typeOptions) {
-    if (Object.prototype.hasOwnProperty.call(typeOptions, 'shapeTypes')) {
-      if (! Array.isArray(typeOptions.shapeTypes)
-        || typeOptions.shapeTypes.length === 0
+  validateFieldSpecification(typeOptions) {
+    if (Object.prototype.hasOwnProperty.call(typeOptions, "shapeTypes")) {
+      if (
+        !Array.isArray(typeOptions.shapeTypes) ||
+        typeOptions.shapeTypes.length === 0
       ) {
-        throw kerror.get('validation', 'assert', 'invalid_type', 'shapeTypes', 'string[]');
+        throw kerror.get(
+          "validation",
+          "assert",
+          "invalid_type",
+          "shapeTypes",
+          "string[]"
+        );
       }
 
       const invalid = typeOptions.shapeTypes.filter(
-        shape => ! allowedShapeTypes.includes(shape));
+        (shape) => !allowedShapeTypes.includes(shape)
+      );
 
       if (invalid.length > 0) {
-        throw kerror.get('validation', 'types', 'invalid_geoshape', invalid);
+        throw kerror.get("validation", "types", "invalid_geoshape", invalid);
       }
-    }
-    else {
+    } else {
       typeOptions.shapeTypes = allowedShapeTypes;
     }
 
@@ -280,16 +300,17 @@ class GeoShapeType extends BaseType {
  * @param {GeoShapePointCoordinates} point
  * @returns {boolean}
  */
-function isPoint (point) {
-  if (! Array.isArray(point) || point.length !== 2) {
+function isPoint(point) {
+  if (!Array.isArray(point) || point.length !== 2) {
     return false;
   }
 
-  return ! (
-    point[0] < -180
-    || point[0] > 180
-    || point[1] < -90
-    || point[1] > 90);
+  return !(
+    point[0] < -180 ||
+    point[0] > 180 ||
+    point[1] < -90 ||
+    point[1] > 90
+  );
 }
 
 /**
@@ -297,7 +318,7 @@ function isPoint (point) {
  * @param {GeoShapePointCoordinates} pointB
  * @returns {boolean}
  */
-function isPointEqual (pointA, pointB) {
+function isPointEqual(pointA, pointB) {
   return pointA[0] === pointB[0] && pointA[1] === pointB[1];
 }
 
@@ -305,39 +326,41 @@ function isPointEqual (pointA, pointB) {
  * @param {GeoShapeLineCoordinates} line
  * @returns {boolean}
  */
-function isLine (line) {
-  if (! Array.isArray(line) || line.length < 2) {
+function isLine(line) {
+  if (!Array.isArray(line) || line.length < 2) {
     return false;
   }
 
-  return line.every(point => isPoint(point));
+  return line.every((point) => isPoint(point));
 }
 
 /**
  * @param {GeoShapePolygonPart} polygonPart
  * @returns {boolean}
  */
-function isPolygonPart (polygonPart) {
-  return Array.isArray(polygonPart)
-    && polygonPart.length >= 4
-    && isLine(polygonPart)
-    && isPointEqual(polygonPart[0], polygonPart[polygonPart.length - 1]);
+function isPolygonPart(polygonPart) {
+  return (
+    Array.isArray(polygonPart) &&
+    polygonPart.length >= 4 &&
+    isLine(polygonPart) &&
+    isPointEqual(polygonPart[0], polygonPart[polygonPart.length - 1])
+  );
 }
 
 /**
  * @param {GeoShapePolygon} polygon
  * @returns {boolean}
  */
-function isPolygon (polygon) {
-  if (! Array.isArray(polygon)) {
+function isPolygon(polygon) {
+  if (!Array.isArray(polygon)) {
     return false;
   }
 
-  return polygon.every(polygonPart => isPolygonPart(polygonPart));
+  return polygon.every((polygonPart) => isPolygonPart(polygonPart));
 }
 
-function isEnvelope (envelope) {
-  if (! Array.isArray(envelope) || envelope.length !== 2) {
+function isEnvelope(envelope) {
+  if (!Array.isArray(envelope) || envelope.length !== 2) {
     return false;
   }