kuzzle 2.56.0 → 2.57.0-beta.2

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

@@ -1,17 +1,9 @@
-export = GeoPointType;
-/**
- * @class GeoPointType
- */
+import BaseType from "../baseType";
+import type { TypeOptions } from "../typeOptions";
 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;
+    allowedTypeOptions: string[];
+    validate(typeOptions: TypeOptions, fieldValue: unknown, errorMessages: string[]): boolean;
 }
-import BaseType = require("../baseType");
+export = GeoPointType;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,27 +19,21 @@
  * 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 {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const KoncordeWrapper_1 = require("../../shared/KoncordeWrapper");
+const baseType_1 = __importDefault(require("../baseType"));
+class GeoPointType extends baseType_1.default {
     constructor() {
-        super();
+        super(...arguments);
         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) {
+        // `convertGeopoint` is the one telling a geopoint apart from anything else
+        if (KoncordeWrapper_1.Koncorde.convertGeopoint(fieldValue) === null) {
             errorMessages.push("Invalid GeoPoint format");
             return false;
         }

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

@@ -1,31 +1,32 @@
-export = GeoShapeType;
+import BaseType from "../baseType";
+import type { GeoShapeTypeOptions } from "../typeOptions";
 /**
- * @class GeoShapeType
+ * A GeoJSON-like shape, as the user submits it: nothing but `type` can be
+ * assumed to be there, which is what `checkStructure` is for.
  */
-declare class GeoShapeType extends BaseType {
+interface GeoShape {
+    type?: string;
+    coordinates?: unknown[];
+    radius?: string | number;
+    orientation?: string;
+    geometries?: GeoShape[];
+}
+declare class GeoShapeType extends BaseType<GeoShapeTypeOptions> {
     typeName: string;
     allowChildren: boolean;
     allowedTypeOptions: string[];
+    validate(typeOptions: GeoShapeTypeOptions, fieldValue: GeoShape, errorMessages: string[]): boolean;
+    recursiveShapeValidation(allowedShapes: string[], shape: GeoShape, errorMessages: string[]): boolean;
+    private checkGeometries;
+    checkStructure(allowedShapes: string[], shape: GeoShape, errorMessages: string[]): boolean;
+    private checkShapeType;
     /**
-     * @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}
+     * Checks the properties each shape type does and does not accept.
      */
-    recursiveShapeValidation(allowedShapes: string[], shape: GeoShape, errorMessages: string[]): boolean;
+    private checkShapeProperties;
     /**
-     * @param {string[]} allowedShapes
-     * @param {GeoShape} shape
-     * @param {string[]} errorMessages
-     * @returns {boolean}
+     * @throws {PreconditionError}
      */
-    checkStructure(allowedShapes: string[], shape: GeoShape, errorMessages: string[]): boolean;
+    validateFieldSpecification(typeOptions: GeoShapeTypeOptions): GeoShapeTypeOptions;
 }
-import BaseType = require("../baseType");
+export = GeoShapeType;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,24 +19,51 @@
  * 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");
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const koncorde_1 = require("koncorde");
+const kerror = __importStar(require("../../../kerror"));
+const safeObject_1 = require("../../../util/safeObject");
+const baseType_1 = __importDefault(require("../baseType"));
+const geoShapeUtils_1 = require("./geoShapeUtils");
 const allowedShapeProperties = [
     "type",
     "coordinates",
     "radius",
     "orientation",
     "geometries",
-], allowedOrientations = [
+], allowedOrientations = new Set([
     "right",
     "ccw",
     "counterclockwise",
     "left",
     "cw",
     "clockwise",
-], multiTypes = ["multipoint", "multilinestring", "multipolygon"], allowedShapeTypes = [
+]), multiTypes = new Set(["multipoint", "multilinestring", "multipolygon"]), allowedShapeTypes = [
     "point",
     "linestring",
     "polygon",
@@ -46,123 +74,98 @@ const allowedShapeProperties = [
     "envelope",
     "circle",
 ];
-/**
- * @class GeoShapeType
- */
-class GeoShapeType extends BaseType {
+class GeoShapeType extends baseType_1.default {
     constructor() {
-        super();
+        super(...arguments);
         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);
+        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) {
+        // checkStructure has just proven these three are there; the defaults only
+        // exist to keep the destructuring total.
+        const { type = "", coordinates = [], geometries = [] } = shape;
+        const isMulti = multiTypes.has(type);
+        // the default also covers "geometrycollection", which holds no coordinates
+        // of its own, and the unreachable `default:` branch below
+        let coordinateValidation = () => true, result = true;
+        switch (type) {
             case "point":
             case "multipoint":
-                coordinateValidation = isPoint;
+                coordinateValidation = geoShapeUtils_1.isPoint;
                 break;
             case "linestring":
             case "multilinestring":
-                coordinateValidation = isLine;
+                coordinateValidation = geoShapeUtils_1.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;
-                }
+                coordinateValidation = geoShapeUtils_1.isPolygon;
+                result = checkOrientation(shape, errorMessages);
                 break;
             case "geometrycollection":
-                coordinateValidation = () => true;
-                for (let i = 0; i < shape.geometries.length; i++) {
-                    if (!this.recursiveShapeValidation(allowedShapes, shape.geometries[i], errorMessages)) {
-                        result = false;
-                    }
-                }
+                result = this.checkGeometries(allowedShapes, geometries, errorMessages);
                 break;
             case "envelope":
-                coordinateValidation = isEnvelope;
+                coordinateValidation = geoShapeUtils_1.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;
-                }
+                coordinateValidation = geoShapeUtils_1.isPoint;
+                result = checkRadius(shape, errorMessages);
                 break;
             default:
                 // added to comply with sonarqube
                 // but it's currently not possible to get here
-                errorMessages.push(`Unrecognized shape: ${shape.type}`);
+                errorMessages.push(`Unrecognized 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.`);
+        // evaluated before the `&&` so that its error message is pushed even when
+        // the switch has already invalidated the shape
+        const coordinatesOk = checkCoordinates(type, isMulti, coordinates, coordinateValidation, errorMessages);
+        return result && coordinatesOk;
+    }
+    checkGeometries(allowedShapes, geometries, errorMessages) {
+        let result = true;
+        for (const geometry of geometries) {
+            if (!this.recursiveShapeValidation(allowedShapes, geometry, errorMessages)) {
                 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;
         }
+        // every check pushes its own message, so none of them may be short-circuited
+        const typeOk = this.checkShapeType(allowedShapes, shape, shape.type, errorMessages);
+        const propertiesOk = this.checkShapeProperties(shape, errorMessages);
+        return typeOk && propertiesOk;
+    }
+    checkShapeType(allowedShapes, shape, type, errorMessages) {
+        let result = true;
         if (!this.checkAllowedProperties(shape, allowedShapeProperties)) {
             errorMessages.push("The shape object has a not allowed property.");
             result = false;
         }
-        if (allowedShapes.indexOf(shape.type) === -1) {
+        if (!allowedShapes.includes(type)) {
             errorMessages.push("The provided shape type is not allowed.");
             result = false;
         }
+        return result;
+    }
+    /**
+     * Checks the properties each shape type does and does not accept.
+     */
+    checkShapeProperties(shape, errorMessages) {
+        let result = true;
         if (shape.type === "geometrycollection" && shape.coordinates) {
             errorMessages.push('The coordinates property must not be provided for the "geometrycollection" shape type.');
             result = false;
@@ -198,17 +201,15 @@ class GeoShapeType extends BaseType {
         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) {
+        if ((0, safeObject_1.has)(typeOptions, "shapeTypes")) {
+            const { shapeTypes } = typeOptions;
+            if (!Array.isArray(shapeTypes) || shapeTypes.length === 0) {
                 throw kerror.get("validation", "assert", "invalid_type", "shapeTypes", "string[]");
             }
-            const invalid = typeOptions.shapeTypes.filter((shape) => !allowedShapeTypes.includes(shape));
+            const invalid = shapeTypes.filter((shape) => !allowedShapeTypes.includes(shape));
             if (invalid.length > 0) {
                 throw kerror.get("validation", "types", "invalid_geoshape", invalid);
             }
@@ -219,62 +220,45 @@ class GeoShapeType extends BaseType {
         return typeOptions;
     }
 }
-/**
- * @param {GeoShapePointCoordinates} point
- * @returns {boolean}
- */
-function isPoint(point) {
-    if (!Array.isArray(point) || point.length !== 2) {
+function checkOrientation(shape, errorMessages) {
+    if (shape.orientation && !allowedOrientations.has(shape.orientation)) {
+        errorMessages.push("The orientation property has not a valid value.");
         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];
+    return true;
 }
-/**
- * @param {GeoShapeLineCoordinates} line
- * @returns {boolean}
- */
-function isLine(line) {
-    if (!Array.isArray(line) || line.length < 2) {
-        return false;
+function checkRadius(shape, errorMessages) {
+    let valid;
+    if (typeof shape.radius === "string") {
+        try {
+            valid = typeof koncorde_1.Koncorde.convertDistance(shape.radius) === "number";
+        }
+        catch {
+            // an unparseable distance is an invalid radius, like any other
+            valid = 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;
+    else {
+        valid = typeof shape.radius === "number";
     }
-    return polygon.every((polygonPart) => isPolygonPart(polygonPart));
+    if (!valid) {
+        errorMessages.push("The radius property has not a valid format.");
+    }
+    return valid;
 }
-function isEnvelope(envelope) {
-    if (!Array.isArray(envelope) || envelope.length !== 2) {
+function checkCoordinates(type, isMulti, coordinates, coordinateValidation, errorMessages) {
+    if (isMulti) {
+        if (coordinates.some((coordinate) => !coordinateValidation(coordinate))) {
+            errorMessages.push(`One of the shapes in  the shape type "${type}" has bad coordinates.`);
+            return false;
+        }
+        return true;
+    }
+    if (!coordinateValidation(coordinates)) {
+        errorMessages.push(`The shape type "${type}" has bad coordinates.`);
         return false;
     }
-    return isPoint(envelope[0]) && isPoint(envelope[1]);
+    return true;
 }
 module.exports = GeoShapeType;
 //# sourceMappingURL=geoShape.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * The coordinate predicates a GeoJSON-like shape is checked against.
+ *
+ * They are pure functions of a coordinate array, and they are the unit worth
+ * testing directly: `geoShape.ts` uses `export =`, which cannot carry named
+ * exports beside it, so the only way a spec could address them was `rewire`'s
+ * `__get__` — and, from there, `__set__` to replace them in the module that
+ * calls them (ADR-0001, step 13 L6g).
+ */
+export declare function isPoint(point: unknown): boolean;
+export declare function isPointEqual(pointA: unknown[], pointB: unknown[]): boolean;
+export declare function isLine(line: unknown): boolean;
+export declare function isPolygonPart(polygonPart: unknown): boolean;
+export declare function isPolygon(polygon: unknown): boolean;
+export declare function isEnvelope(envelope: unknown): boolean;

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

@@ -0,0 +1,75 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnvelope = exports.isPolygon = exports.isPolygonPart = exports.isLine = exports.isPointEqual = exports.isPoint = void 0;
+/**
+ * The coordinate predicates a GeoJSON-like shape is checked against.
+ *
+ * They are pure functions of a coordinate array, and they are the unit worth
+ * testing directly: `geoShape.ts` uses `export =`, which cannot carry named
+ * exports beside it, so the only way a spec could address them was `rewire`'s
+ * `__get__` — and, from there, `__set__` to replace them in the module that
+ * calls them (ADR-0001, step 13 L6g).
+ */
+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);
+}
+exports.isPoint = isPoint;
+function isPointEqual(pointA, pointB) {
+    return pointA[0] === pointB[0] && pointA[1] === pointB[1];
+}
+exports.isPointEqual = isPointEqual;
+function isLine(line) {
+    if (!Array.isArray(line) || line.length < 2) {
+        return false;
+    }
+    return line.every((point) => isPoint(point));
+}
+exports.isLine = isLine;
+function isPolygonPart(polygonPart) {
+    return (Array.isArray(polygonPart) &&
+        polygonPart.length >= 4 &&
+        isLine(polygonPart) &&
+        isPointEqual(polygonPart[0], polygonPart.at(-1)));
+}
+exports.isPolygonPart = isPolygonPart;
+function isPolygon(polygon) {
+    if (!Array.isArray(polygon)) {
+        return false;
+    }
+    return polygon.every((polygonPart) => isPolygonPart(polygonPart));
+}
+exports.isPolygon = isPolygon;
+function isEnvelope(envelope) {
+    if (!Array.isArray(envelope) || envelope.length !== 2) {
+        return false;
+    }
+    return isPoint(envelope[0]) && isPoint(envelope[1]);
+}
+exports.isEnvelope = isEnvelope;
+//# sourceMappingURL=geoShapeUtils.js.map

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

@@ -1,7 +1,9 @@
-export = IntegerType;
-/**
- * @class IntegerType
- */
+import type { NumericTypeOptions } from "../typeOptions";
+import Numeric from "./numeric";
 declare class IntegerType extends Numeric {
+    typeName: string;
+    allowChildren: boolean;
+    allowedTypeOptions: string[];
+    validate(typeOptions: NumericTypeOptions, fieldValue: unknown, errorMessages: string[]): boolean;
 }
-import Numeric = require("./numeric");
+export = IntegerType;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,24 +19,17 @@
  * 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 {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const numeric_1 = __importDefault(require("./numeric"));
+class IntegerType extends numeric_1.default {
     constructor() {
-        super();
+        super(...arguments);
         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;

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

@@ -1,17 +1,13 @@
-export = IpAddressType;
-/**
- * @class IpAddressType
- */
-declare class IpAddressType extends BaseType {
+import BaseType from "../baseType";
+import type { NotEmptyTypeOptions } from "../typeOptions";
+declare class IpAddressType extends BaseType<NotEmptyTypeOptions> {
     typeName: string;
     allowChildren: boolean;
     allowedTypeOptions: string[];
+    validate(typeOptions: NotEmptyTypeOptions, fieldValue: unknown, errorMessages: string[]): boolean;
     /**
-     * @param {TypeOptions} typeOptions
-     * @param {*} fieldValue
-     * @param {string[]} errorMessages
-     * @returns {boolean}
+     * @throws {PreconditionError}
      */
-    validate(typeOptions: TypeOptions, fieldValue: any, errorMessages: string[]): boolean;
+    validateFieldSpecification(typeOptions: NotEmptyTypeOptions): NotEmptyTypeOptions;
 }
-import BaseType = require("../baseType");
+export = IpAddressType;