kuzzle 2.49.1 → 2.50.0-beta.4

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

@@ -0,0 +1,70 @@
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"use strict";
+const kerror = require("../../../kerror"), BaseType = require("../baseType");
+/**
+ * @class EnumType
+ */
+class EnumType extends BaseType {
+    constructor() {
+        super();
+        this.typeName = "enum";
+        this.allowChildren = false;
+        this.allowedTypeOptions = ["values"];
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {*} fieldValue
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    validate(typeOptions, fieldValue, errorMessages) {
+        if (typeof fieldValue !== "string") {
+            errorMessages.push("The field must be a string.");
+            return false;
+        }
+        if (!typeOptions.values.includes(fieldValue)) {
+            errorMessages.push(`The field only accepts following values: "${typeOptions.values.join(", ")}".`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @returns {TypeOptions}
+     * @throws {PreconditionError}
+     */
+    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[]");
+        }
+        const nonString = typeOptions.values.filter((value) => typeof value !== "string");
+        if (nonString.length > 0) {
+            throw kerror.get("validation", "assert", "invalid_type", "values", "string[]");
+        }
+        return typeOptions;
+    }
+}
+module.exports = EnumType;
+//# sourceMappingURL=enum.js.map

package/dist/lib/core/validation/types/geoPoint.d.ts

@@ -0,0 +1,17 @@
+export = GeoPointType;
+/**
+ * @class GeoPointType
+ */
+declare class GeoPointType extends BaseType {
+    typeName: string;
+    allowChildren: boolean;
+    allowedTypeOptions: any[];
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {*} fieldValue
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    validate(typeOptions: TypeOptions, fieldValue: any, errorMessages: string[]): boolean;
+}
+import BaseType = require("../baseType");

package/{lib → dist/lib}/core/validation/types/geoPoint.js

@@ -18,37 +18,32 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 const BaseType = require("../baseType");
 const { Koncorde } = require("../../shared/KoncordeWrapper");
-
 /**
  * @class GeoPointType
  */
 class GeoPointType extends BaseType {
-  constructor() {
-    super();
-    this.typeName = "geo_point";
-    this.allowChildren = false;
-    this.allowedTypeOptions = [];
-  }
-
-  /**
-   * @param {TypeOptions} typeOptions
-   * @param {*} fieldValue
-   * @param {string[]} errorMessages
-   * @returns {boolean}
-   */
-  validate(typeOptions, fieldValue, errorMessages) {
-    if (Koncorde.convertGeopoint(fieldValue) === null) {
-      errorMessages.push("Invalid GeoPoint format");
-      return false;
+    constructor() {
+        super();
+        this.typeName = "geo_point";
+        this.allowChildren = false;
+        this.allowedTypeOptions = [];
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {*} fieldValue
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    validate(typeOptions, fieldValue, errorMessages) {
+        if (Koncorde.convertGeopoint(fieldValue) === null) {
+            errorMessages.push("Invalid GeoPoint format");
+            return false;
+        }
+        return true;
     }
-
-    return true;
-  }
 }
-
 module.exports = GeoPointType;
+//# sourceMappingURL=geoPoint.js.map

package/dist/lib/core/validation/types/geoShape.d.ts

@@ -0,0 +1,31 @@
+export = GeoShapeType;
+/**
+ * @class GeoShapeType
+ */
+declare class GeoShapeType extends BaseType {
+    typeName: string;
+    allowChildren: boolean;
+    allowedTypeOptions: string[];
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {GeoShape} fieldValue
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    validate(typeOptions: TypeOptions, fieldValue: GeoShape, errorMessages: string[]): boolean;
+    /**
+     * @param {string[]} allowedShapes
+     * @param {GeoShape} shape
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    recursiveShapeValidation(allowedShapes: string[], shape: GeoShape, errorMessages: string[]): boolean;
+    /**
+     * @param {string[]} allowedShapes
+     * @param {GeoShape} shape
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    checkStructure(allowedShapes: string[], shape: GeoShape, errorMessages: string[]): boolean;
+}
+import BaseType = require("../baseType");

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

@@ -0,0 +1,280 @@
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"use strict";
+const { Koncorde } = require("koncorde");
+const kerror = require("../../../kerror");
+const BaseType = require("../baseType");
+const allowedShapeProperties = [
+    "type",
+    "coordinates",
+    "radius",
+    "orientation",
+    "geometries",
+], allowedOrientations = [
+    "right",
+    "ccw",
+    "counterclockwise",
+    "left",
+    "cw",
+    "clockwise",
+], multiTypes = ["multipoint", "multilinestring", "multipolygon"], allowedShapeTypes = [
+    "point",
+    "linestring",
+    "polygon",
+    "multipoint",
+    "multilinestring",
+    "multipolygon",
+    "geometrycollection",
+    "envelope",
+    "circle",
+];
+/**
+ * @class GeoShapeType
+ */
+class GeoShapeType extends BaseType {
+    constructor() {
+        super();
+        this.typeName = "geo_shape";
+        this.allowChildren = false;
+        this.allowedTypeOptions = ["shapeTypes"];
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {GeoShape} fieldValue
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    validate(typeOptions, fieldValue, errorMessages) {
+        return this.recursiveShapeValidation(typeOptions.shapeTypes, fieldValue, errorMessages);
+    }
+    /**
+     * @param {string[]} allowedShapes
+     * @param {GeoShape} shape
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    recursiveShapeValidation(allowedShapes, shape, errorMessages) {
+        if (!this.checkStructure(allowedShapes, shape, errorMessages)) {
+            return false;
+        }
+        const isMulti = multiTypes.indexOf(shape.type) !== -1;
+        let coordinateValidation, result = true;
+        switch (shape.type) {
+            case "point":
+            case "multipoint":
+                coordinateValidation = isPoint;
+                break;
+            case "linestring":
+            case "multilinestring":
+                coordinateValidation = isLine;
+                break;
+            case "polygon":
+            case "multipolygon":
+                coordinateValidation = isPolygon;
+                if (shape.orientation &&
+                    !allowedOrientations.includes(shape.orientation)) {
+                    errorMessages.push("The orientation property has not a valid value.");
+                    result = false;
+                }
+                break;
+            case "geometrycollection":
+                coordinateValidation = () => true;
+                for (let i = 0; i < shape.geometries.length; i++) {
+                    if (!this.recursiveShapeValidation(allowedShapes, shape.geometries[i], errorMessages)) {
+                        result = false;
+                    }
+                }
+                break;
+            case "envelope":
+                coordinateValidation = isEnvelope;
+                break;
+            case "circle":
+                coordinateValidation = isPoint;
+                if (typeof shape.radius === "string") {
+                    try {
+                        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.");
+                        result = false;
+                    }
+                }
+                else if (typeof shape.radius !== "number") {
+                    errorMessages.push("The radius property has not a valid format.");
+                    result = false;
+                }
+                break;
+            default:
+                // added to comply with sonarqube
+                // but it's currently not possible to get here
+                errorMessages.push(`Unrecognized shape: ${shape.type}`);
+                result = false;
+        }
+        if (isMulti) {
+            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)) {
+            errorMessages.push(`The shape type "${shape.type}" has bad coordinates.`);
+            return false;
+        }
+        return result;
+    }
+    /**
+     * @param {string[]} allowedShapes
+     * @param {GeoShape} shape
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    checkStructure(allowedShapes, shape, errorMessages) {
+        let result = true;
+        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.");
+            result = false;
+        }
+        if (allowedShapes.indexOf(shape.type) === -1) {
+            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.');
+            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.`);
+            result = false;
+        }
+        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.`);
+            result = false;
+        }
+        if (shape.type !== "polygon" &&
+            shape.type !== "multipolygon" &&
+            shape.orientation) {
+            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.`);
+            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.');
+            result = false;
+        }
+        return result;
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @returns {TypeOptions}
+     * @throws {PreconditionError}
+     */
+    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[]");
+            }
+            const invalid = typeOptions.shapeTypes.filter((shape) => !allowedShapeTypes.includes(shape));
+            if (invalid.length > 0) {
+                throw kerror.get("validation", "types", "invalid_geoshape", invalid);
+            }
+        }
+        else {
+            typeOptions.shapeTypes = allowedShapeTypes;
+        }
+        return typeOptions;
+    }
+}
+/**
+ * @param {GeoShapePointCoordinates} point
+ * @returns {boolean}
+ */
+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);
+}
+/**
+ * @param {GeoShapePointCoordinates} pointA
+ * @param {GeoShapePointCoordinates} pointB
+ * @returns {boolean}
+ */
+function isPointEqual(pointA, pointB) {
+    return pointA[0] === pointB[0] && pointA[1] === pointB[1];
+}
+/**
+ * @param {GeoShapeLineCoordinates} line
+ * @returns {boolean}
+ */
+function isLine(line) {
+    if (!Array.isArray(line) || line.length < 2) {
+        return false;
+    }
+    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]));
+}
+/**
+ * @param {GeoShapePolygon} polygon
+ * @returns {boolean}
+ */
+function isPolygon(polygon) {
+    if (!Array.isArray(polygon)) {
+        return false;
+    }
+    return polygon.every((polygonPart) => isPolygonPart(polygonPart));
+}
+function isEnvelope(envelope) {
+    if (!Array.isArray(envelope) || envelope.length !== 2) {
+        return false;
+    }
+    return isPoint(envelope[0]) && isPoint(envelope[1]);
+}
+module.exports = GeoShapeType;
+//# sourceMappingURL=geoShape.js.map

package/dist/lib/core/validation/types/integer.d.ts

@@ -0,0 +1,7 @@
+export = IntegerType;
+/**
+ * @class IntegerType
+ */
+declare class IntegerType extends Numeric {
+}
+import Numeric = require("./numeric");

package/{lib → dist/lib}/core/validation/types/integer.js

@@ -18,40 +18,34 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 const Numeric = require("./numeric");
-
 /**
  * @class IntegerType
  */
 class IntegerType extends Numeric {
-  constructor() {
-    super();
-    this.typeName = "integer";
-    this.allowChildren = false;
-    this.allowedTypeOptions = ["range"];
-  }
-
-  /**
-   * @param {TypeOptions} typeOptions
-   * @param {*} fieldValue
-   * @param {string[]} errorMessages
-   * @returns {boolean}
-   */
-  validate(typeOptions, fieldValue, errorMessages) {
-    if (!super.validate(typeOptions, fieldValue, errorMessages)) {
-      return false;
+    constructor() {
+        super();
+        this.typeName = "integer";
+        this.allowChildren = false;
+        this.allowedTypeOptions = ["range"];
     }
-
-    if (!Number.isInteger(fieldValue)) {
-      errorMessages.push("The field must be an integer.");
-      return false;
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {*} fieldValue
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    validate(typeOptions, fieldValue, errorMessages) {
+        if (!super.validate(typeOptions, fieldValue, errorMessages)) {
+            return false;
+        }
+        if (!Number.isInteger(fieldValue)) {
+            errorMessages.push("The field must be an integer.");
+            return false;
+        }
+        return true;
     }
-
-    return true;
-  }
 }
-
 module.exports = IntegerType;
+//# sourceMappingURL=integer.js.map

package/dist/lib/core/validation/types/ipAddress.d.ts

@@ -0,0 +1,17 @@
+export = IpAddressType;
+/**
+ * @class IpAddressType
+ */
+declare class IpAddressType extends BaseType {
+    typeName: string;
+    allowChildren: boolean;
+    allowedTypeOptions: string[];
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {*} fieldValue
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    validate(typeOptions: TypeOptions, fieldValue: any, errorMessages: string[]): boolean;
+}
+import BaseType = require("../baseType");

package/dist/lib/core/validation/types/ipAddress.js

@@ -0,0 +1,73 @@
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"use strict";
+const kerror = require("../../../kerror").wrap("validation", "assert"), BaseType = require("../baseType"), validator = require("validator");
+/**
+ * @class IpAddressType
+ */
+class IpAddressType extends BaseType {
+    constructor() {
+        super();
+        this.typeName = "ip_address";
+        this.allowChildren = false;
+        this.allowedTypeOptions = ["notEmpty"];
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {*} fieldValue
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    validate(typeOptions, fieldValue, errorMessages) {
+        if (typeof fieldValue !== "string") {
+            errorMessages.push("The field must be a string.");
+            return false;
+        }
+        if (fieldValue.length === 0) {
+            if (typeOptions.notEmpty) {
+                errorMessages.push("The string must not be empty.");
+                return false;
+            }
+            return true;
+        }
+        if (!validator.isIP(fieldValue)) {
+            errorMessages.push("The string must be a valid IP address.");
+            return false;
+        }
+        return true;
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @returns {TypeOptions}
+     * @throws {PreconditionError}
+     */
+    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");
+        }
+        return typeOptions;
+    }
+}
+module.exports = IpAddressType;
+//# sourceMappingURL=ipAddress.js.map

package/dist/lib/core/validation/types/numeric.d.ts

@@ -0,0 +1,17 @@
+export = NumericType;
+/**
+ * @class NumericType
+ */
+declare class NumericType extends BaseType {
+    typeName: string;
+    allowChildren: boolean;
+    allowedTypeOptions: string[];
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {*} fieldValue
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    validate(typeOptions: TypeOptions, fieldValue: any, errorMessages: string[]): boolean;
+}
+import BaseType = require("../baseType");