kuzzle 2.49.1 → 2.50.0-beta.4

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

@@ -0,0 +1,84 @@
+/*
+ * 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");
+/**
+ * @class NumericType
+ */
+class NumericType extends BaseType {
+    constructor() {
+        super();
+        this.typeName = "numeric";
+        this.allowChildren = false;
+        this.allowedTypeOptions = ["range"];
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {*} fieldValue
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    validate(typeOptions, fieldValue, errorMessages) {
+        if (typeof fieldValue !== "number") {
+            errorMessages.push("The field must be a number.");
+            return false;
+        }
+        if (Object.prototype.hasOwnProperty.call(typeOptions, "range")) {
+            if (Object.prototype.hasOwnProperty.call(typeOptions.range, "min") &&
+                fieldValue < typeOptions.range.min) {
+                errorMessages.push(`Value ${fieldValue} is lesser than the allowed minimum (${typeOptions.range.min})`);
+                return false;
+            }
+            if (Object.prototype.hasOwnProperty.call(typeOptions.range, "max") &&
+                fieldValue > typeOptions.range.max) {
+                errorMessages.push(`Value ${fieldValue} is greater than the allowed maximum (${typeOptions.range.max})`);
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @returns {TypeOptions}
+     * @throws {PreconditionError}
+     */
+    validateFieldSpecification(typeOptions) {
+        if (Object.prototype.hasOwnProperty.call(typeOptions, "range")) {
+            if (!this.checkAllowedProperties(typeOptions.range, ["min", "max"])) {
+                throw kerror.get("unexpected_properties", "range", "min, max");
+            }
+            for (const prop of ["min", "max"]) {
+                if (Object.prototype.hasOwnProperty.call(typeOptions.range, prop) &&
+                    typeof typeOptions.range[prop] !== "number") {
+                    throw kerror.get("invalid_type", `range.${prop}`, "number");
+                }
+            }
+            if (Object.prototype.hasOwnProperty.call(typeOptions.range, "min") &&
+                Object.prototype.hasOwnProperty.call(typeOptions.range, "max") &&
+                typeOptions.range.max < typeOptions.range.min) {
+                throw kerror.get("invalid_range", "range", "min", "max");
+            }
+        }
+        return typeOptions;
+    }
+}
+module.exports = NumericType;
+//# sourceMappingURL=numeric.js.map

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

@@ -0,0 +1,24 @@
+export = ObjectType;
+/**
+ * @class ObjectType
+ */
+declare class ObjectType 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;
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {boolean} parentStrictness
+     * @returns {boolean|TypeOptions}
+     * @throws KuzzleInternalError
+     */
+    getStrictness(typeOptions: TypeOptions, parentStrictness: boolean): boolean | TypeOptions;
+}
+import BaseType = require("../baseType");

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

@@ -0,0 +1,74 @@
+/*
+ * 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");
+/**
+ * @class ObjectType
+ */
+class ObjectType extends BaseType {
+    constructor() {
+        super();
+        this.typeName = "object";
+        this.allowChildren = true;
+        this.allowedTypeOptions = ["strict"];
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {*} fieldValue
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    validate(typeOptions, fieldValue, errorMessages) {
+        if (fieldValue === null ||
+            typeof fieldValue !== "object" ||
+            Array.isArray(fieldValue)) {
+            errorMessages.push("The value must be an object.");
+            return false;
+        }
+        return true;
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @returns {TypeOptions}
+     * @throws {PreconditionError}
+     */
+    validateFieldSpecification(typeOptions) {
+        if (Object.prototype.hasOwnProperty.call(typeOptions, "strict") &&
+            typeof typeOptions.strict !== "boolean") {
+            throw kerror.get("invalid_type", "strict", "boolean");
+        }
+        return typeOptions;
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {boolean} parentStrictness
+     * @returns {boolean|TypeOptions}
+     * @throws KuzzleInternalError
+     */
+    getStrictness(typeOptions, parentStrictness) {
+        if (!Object.prototype.hasOwnProperty.call(typeOptions, "strict")) {
+            return parentStrictness;
+        }
+        return typeOptions.strict;
+    }
+}
+module.exports = ObjectType;
+//# sourceMappingURL=object.js.map

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

@@ -0,0 +1,17 @@
+export = StringType;
+/**
+ * @class StringType
+ */
+declare class StringType 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/string.js

@@ -0,0 +1,85 @@
+/*
+ * 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");
+/**
+ * @class StringType
+ */
+class StringType extends BaseType {
+    constructor() {
+        super();
+        this.typeName = "string";
+        this.allowChildren = false;
+        this.allowedTypeOptions = ["length"];
+    }
+    /**
+     * @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.length) {
+            return true;
+        }
+        if (Object.prototype.hasOwnProperty.call(typeOptions.length, "min") &&
+            fieldValue.length < typeOptions.length.min) {
+            errorMessages.push(`Invalid string length. Expected min: ${typeOptions.length.min}. Received: ${fieldValue.length} ("${fieldValue}")`);
+            return false;
+        }
+        if (Object.prototype.hasOwnProperty.call(typeOptions.length, "max") &&
+            fieldValue.length > typeOptions.length.max) {
+            errorMessages.push(`Invalid string length. Expected max: ${typeOptions.length.max}. Received: ${fieldValue.length} ("${fieldValue}")`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @returns {TypeOptions}
+     * @throws {PreconditionError}
+     */
+    validateFieldSpecification(typeOptions) {
+        if (Object.prototype.hasOwnProperty.call(typeOptions, "length")) {
+            if (!this.checkAllowedProperties(typeOptions.length, ["min", "max"])) {
+                throw kerror.get("unexpected_properties", "length", "min, max");
+            }
+            for (const prop of ["min", "max"]) {
+                if (Object.prototype.hasOwnProperty.call(typeOptions.length, prop) &&
+                    typeof typeOptions.length[prop] !== "number") {
+                    throw kerror.get("invalid_type", `length.${prop}`, "number");
+                }
+            }
+            if (Object.prototype.hasOwnProperty.call(typeOptions.length, "min") &&
+                Object.prototype.hasOwnProperty.call(typeOptions.length, "max") &&
+                typeOptions.length.min > typeOptions.length.max) {
+                throw kerror.get("invalid_range", "length", "min", "max");
+            }
+        }
+        return typeOptions;
+    }
+}
+module.exports = StringType;
+//# sourceMappingURL=string.js.map

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

@@ -0,0 +1,17 @@
+export = UrlType;
+/**
+ * @class UrlType
+ */
+declare class UrlType 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/url.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 UrlType
+ */
+class UrlType extends BaseType {
+    constructor() {
+        super();
+        this.typeName = "url";
+        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.isURL(fieldValue)) {
+            errorMessages.push("The string must be a valid URL.");
+            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 = UrlType;
+//# sourceMappingURL=url.js.map

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

@@ -0,0 +1,113 @@
+export = Validation;
+/**
+ * @class Validation
+ */
+declare class Validation {
+    /** @type {...ValidationType} */
+    types: ValidationType;
+    /** @type {string[]} */
+    typeAllowsChildren: string[];
+    /** @type {DocumentSpecification} */
+    specification: DocumentSpecification;
+    /** @type {Koncorde} */
+    koncorde: Koncorde;
+    rawConfiguration: {};
+    logger: import("../../kuzzle/Logger").Logger;
+    /**
+     * Walks through all types in "defaultTypesFiles" initializes all types
+     */
+    init(): void;
+    /**
+     * Validates a document against its collection specifications
+     *
+     * @param {Request} request
+     * @param {boolean} [verbose]
+     * @returns {Promise.<{documentBody: *, errorMessages:string[], valid: boolean}|KuzzleRequest>}
+     */
+    validate(request: Request, verbose?: boolean): Promise<{
+        documentBody: any;
+        errorMessages: string[];
+        valid: boolean;
+    } | KuzzleRequest>;
+    /**
+     * @param {boolean} isUpdate
+     * @param {*} documentSubset
+     * @param {...StructuredFieldSpecification} collectionSpecSubset
+     */
+    recurseApplyDefault(isUpdate: boolean, documentSubset: any, collectionSpecSubset: StructuredFieldSpecification): any;
+    /**
+     * @param {*} documentSubset
+     * @param {StructuredFieldSpecification} collectionSpecSubset
+     * @param {boolean} strictness
+     * @param {string[]} errorMessages
+     * @param {boolean} verbose
+     */
+    recurseFieldValidation(documentSubset: any, collectionSpecSubset: StructuredFieldSpecification, strictness: boolean, errorMessages: string[], verbose: boolean): boolean;
+    /**
+     * @param {string} fieldName
+     * @param {*} documentSubset
+     * @param {StructuredFieldSpecification} collectionSpecSubset
+     * @param {boolean} strictness
+     * @param {string[]} errorMessages
+     * @param {boolean} verbose
+     * @returns {boolean}
+     */
+    isValidField(fieldName: string, documentSubset: any, collectionSpecSubset: StructuredFieldSpecification, strictness: boolean, errorMessages: string[], verbose: boolean): boolean;
+    /**
+     * @returns {Promise.<T>}
+     */
+    curateSpecification(): Promise<T>;
+    /**
+     * @param {string} indexName
+     * @param {string} collectionName
+     * @param {CollectionSpecification} collectionSpec
+     * @param {boolean} [verboseErrors]
+     * @returns {Promise<object>}
+     */
+    validateFormat(indexName: string, collectionName: string, collectionSpec: CollectionSpecification, verboseErrors?: boolean): Promise<object>;
+    /**
+     * @param {string} index
+     * @param {string} collection
+     * @param {CollectionSpecification} spec
+     * @param {boolean} [dryRun]
+     * @param {boolean} [verbose]
+     * @returns {Promise<CollectionSpecification>}
+     * @rejects PreconditionError
+     */
+    curateCollectionSpecification(index: string, collection: string, spec: CollectionSpecification, dryRun?: boolean, verbose?: boolean): Promise<CollectionSpecification>;
+    structureCollectionValidation(collectionSpec: any, indexName: any, collectionName: any, verboseErrors?: boolean): any;
+    /**
+     * @param {FieldSpecification} fieldSpec
+     * @param {string} indexName
+     * @param {string} collectionName
+     * @param {string} fieldName
+     * @param {boolean} [verboseErrors]
+     * @returns {object}
+     * @throws PreconditionError
+     */
+    curateFieldSpecification(fieldSpec: FieldSpecification, indexName: string, collectionName: string, fieldName: string, verboseErrors?: boolean): object;
+    /**
+     * @param {FieldSpecification} fieldSpec
+     * @param {string} indexName
+     * @param {string} collectionName
+     * @param {string} fieldName
+     * @param {boolean} [verboseErrors]
+     * @returns {object}
+     * @throws PreconditionError
+     */
+    curateFieldSpecificationFormat(fieldSpec: FieldSpecification, indexName: string, collectionName: string, fieldName: string, verboseErrors?: boolean): object;
+    /**
+     * @param {string} indexName
+     * @param {string} collectionName
+     * @param {*} validatorFilter
+     * @param {boolean} dryRun
+     * @returns {string}
+     */
+    curateValidatorFilter(indexName: string, collectionName: string, validatorFilter: any, dryRun: boolean): string;
+    /**
+     * @param {ValidationType} validationType
+     * @throws {PluginImplementationError}
+     */
+    addType(validationType: ValidationType): void;
+}
+import { Koncorde } from "koncorde";