kuzzle 2.56.0 → 2.57.0-beta.2

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,24 +19,21 @@
  * 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 {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const isIP_1 = __importDefault(require("validator/lib/isIP"));
+const kerror_1 = require("../../../kerror");
+const safeObject_1 = require("../../../util/safeObject");
+const baseType_1 = __importDefault(require("../baseType"));
+const kerror = (0, kerror_1.wrap)("validation", "assert");
+class IpAddressType extends baseType_1.default {
     constructor() {
-        super();
+        super(...arguments);
         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.");
@@ -48,19 +46,17 @@ class IpAddressType extends BaseType {
             }
             return true;
         }
-        if (!validator.isIP(fieldValue)) {
+        if (!(0, isIP_1.default)(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")) {
+        if (!(0, safeObject_1.has)(typeOptions, "notEmpty")) {
             typeOptions.notEmpty = false;
         }
         else if (typeof typeOptions.notEmpty !== "boolean") {

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

@@ -1,17 +1,13 @@
-export = NumericType;
-/**
- * @class NumericType
- */
-declare class NumericType extends BaseType {
+import BaseType from "../baseType";
+import type { NumericTypeOptions } from "../typeOptions";
+declare class NumericType extends BaseType<NumericTypeOptions> {
     typeName: string;
     allowChildren: boolean;
     allowedTypeOptions: string[];
+    validate(typeOptions: NumericTypeOptions, 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: NumericTypeOptions): NumericTypeOptions;
 }
-import BaseType = require("../baseType");
+export = NumericType;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,62 +19,54 @@
  * 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 {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const kerror_1 = require("../../../kerror");
+const safeObject_1 = require("../../../util/safeObject");
+const baseType_1 = __importDefault(require("../baseType"));
+const kerror = (0, kerror_1.wrap)("validation", "assert");
+class NumericType extends baseType_1.default {
     constructor() {
-        super();
+        super(...arguments);
         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})`);
+        const { range } = typeOptions;
+        if (range) {
+            if (range.min !== undefined && fieldValue < range.min) {
+                errorMessages.push(`Value ${fieldValue} is lesser than the allowed minimum (${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})`);
+            if (range.max !== undefined && fieldValue > range.max) {
+                errorMessages.push(`Value ${fieldValue} is greater than the allowed maximum (${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"])) {
+        if ((0, safeObject_1.has)(typeOptions, "range")) {
+            const { range } = typeOptions;
+            if (!this.checkAllowedProperties(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") {
+                if ((0, safeObject_1.has)(range, prop) && typeof 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) {
+            const { min, max } = range;
+            if (min !== undefined && max !== undefined && max < min) {
                 throw kerror.get("invalid_range", "range", "min", "max");
             }
         }

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

@@ -1,24 +1,17 @@
-export = ObjectType;
-/**
- * @class ObjectType
- */
-declare class ObjectType extends BaseType {
+import BaseType from "../baseType";
+import type { ObjectTypeOptions } from "../typeOptions";
+declare class ObjectType extends BaseType<ObjectTypeOptions> {
     typeName: string;
     allowChildren: boolean;
     allowedTypeOptions: string[];
+    validate(typeOptions: ObjectTypeOptions, 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: ObjectTypeOptions): ObjectTypeOptions;
     /**
-     * @param {TypeOptions} typeOptions
-     * @param {boolean} parentStrictness
-     * @returns {boolean|TypeOptions}
      * @throws KuzzleInternalError
      */
-    getStrictness(typeOptions: TypeOptions, parentStrictness: boolean): boolean | TypeOptions;
+    getStrictness(typeOptions: ObjectTypeOptions, parentStrictness: boolean): boolean;
 }
-import BaseType = require("../baseType");
+export = ObjectType;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,24 +19,20 @@
  * 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 {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const kerror_1 = require("../../../kerror");
+const safeObject_1 = require("../../../util/safeObject");
+const baseType_1 = __importDefault(require("../baseType"));
+const kerror = (0, kerror_1.wrap)("validation", "assert");
+class ObjectType extends baseType_1.default {
     constructor() {
-        super();
+        super(...arguments);
         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" ||
@@ -46,25 +43,19 @@ class ObjectType extends BaseType {
         return true;
     }
     /**
-     * @param {TypeOptions} typeOptions
-     * @returns {TypeOptions}
      * @throws {PreconditionError}
      */
     validateFieldSpecification(typeOptions) {
-        if (Object.prototype.hasOwnProperty.call(typeOptions, "strict") &&
-            typeof typeOptions.strict !== "boolean") {
+        if ((0, safeObject_1.has)(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")) {
+        if (typeOptions.strict === undefined) {
             return parentStrictness;
         }
         return typeOptions.strict;

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

@@ -1,17 +1,13 @@
-export = StringType;
-/**
- * @class StringType
- */
-declare class StringType extends BaseType {
+import BaseType from "../baseType";
+import type { StringTypeOptions } from "../typeOptions";
+declare class StringType extends BaseType<StringTypeOptions> {
     typeName: string;
     allowChildren: boolean;
     allowedTypeOptions: string[];
+    validate(typeOptions: StringTypeOptions, 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: StringTypeOptions): StringTypeOptions;
 }
-import BaseType = require("../baseType");
+export = StringType;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,63 +19,55 @@
  * 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 {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const kerror_1 = require("../../../kerror");
+const safeObject_1 = require("../../../util/safeObject");
+const baseType_1 = __importDefault(require("../baseType"));
+const kerror = (0, kerror_1.wrap)("validation", "assert");
+class StringType extends baseType_1.default {
     constructor() {
-        super();
+        super(...arguments);
         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) {
+        const { length } = typeOptions;
+        if (!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}")`);
+        if (length.min !== undefined && fieldValue.length < length.min) {
+            errorMessages.push(`Invalid string length. Expected min: ${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}")`);
+        if (length.max !== undefined && fieldValue.length > length.max) {
+            errorMessages.push(`Invalid string length. Expected max: ${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"])) {
+        if ((0, safeObject_1.has)(typeOptions, "length")) {
+            const { length } = typeOptions;
+            if (!this.checkAllowedProperties(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") {
+                if ((0, safeObject_1.has)(length, prop) && typeof 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) {
+            const { min, max } = length;
+            if (min !== undefined && max !== undefined && min > max) {
                 throw kerror.get("invalid_range", "length", "min", "max");
             }
         }

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

@@ -1,17 +1,13 @@
-export = UrlType;
-/**
- * @class UrlType
- */
-declare class UrlType extends BaseType {
+import BaseType from "../baseType";
+import type { NotEmptyTypeOptions } from "../typeOptions";
+declare class UrlType 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 = UrlType;

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,24 +19,21 @@
  * 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 {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const isURL_1 = __importDefault(require("validator/lib/isURL"));
+const kerror_1 = require("../../../kerror");
+const safeObject_1 = require("../../../util/safeObject");
+const baseType_1 = __importDefault(require("../baseType"));
+const kerror = (0, kerror_1.wrap)("validation", "assert");
+class UrlType extends baseType_1.default {
     constructor() {
-        super();
+        super(...arguments);
         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.");
@@ -48,19 +46,17 @@ class UrlType extends BaseType {
             }
             return true;
         }
-        if (!validator.isURL(fieldValue)) {
+        if (!(0, isURL_1.default)(fieldValue)) {
             errorMessages.push("The string must be a valid URL.");
             return false;
         }
         return true;
     }
     /**
-     * @param {TypeOptions} typeOptions
-     * @returns {TypeOptions}
-     * @throws PreconditionError
+     * @throws {PreconditionError}
      */
     validateFieldSpecification(typeOptions) {
-        if (!Object.prototype.hasOwnProperty.call(typeOptions, "notEmpty")) {
+        if (!(0, safeObject_1.has)(typeOptions, "notEmpty")) {
             typeOptions.notEmpty = false;
         }
         else if (typeof typeOptions.notEmpty !== "boolean") {