kuzzle 2.49.1 → 2.50.0-beta.4

package/dist/lib/core/storage/storageEngine.d.ts

@@ -0,0 +1,13 @@
+export = StorageEngine;
+declare class StorageEngine {
+    public: ClientAdapter;
+    private: ClientAdapter;
+    logger: import("../../kuzzle/Logger").Logger;
+    /**
+     * Initialize storage clients and perform integrity checks
+     *
+     * @returns {Promise}
+     */
+    init(): Promise<any>;
+}
+import ClientAdapter = require("./clientAdapter");

package/dist/lib/core/storage/storageEngine.js

@@ -0,0 +1,52 @@
+/*
+ * 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("services", "storage");
+const ClientAdapter = require("./clientAdapter");
+const { storeScopeEnum } = require("./storeScopeEnum");
+class StorageEngine {
+    constructor() {
+        // Storage client for public indexes only
+        this.public = new ClientAdapter(storeScopeEnum.PUBLIC);
+        // Storage client for private indexes only
+        this.private = new ClientAdapter(storeScopeEnum.PRIVATE);
+        this.logger = global.kuzzle.log.child("core:storage:storageEngine");
+        this.logger.info(`[ℹ] Elasticsearch configuration is set to major version : ${global.kuzzle.config.services.storageEngine.majorVersion}`);
+    }
+    /**
+     * Initialize storage clients and perform integrity checks
+     *
+     * @returns {Promise}
+     */
+    async init() {
+        await Promise.all([this.public.init(), this.private.init()]);
+        const privateIndexes = this.private.cache.listIndexes();
+        const publicIndexes = this.public.cache.listIndexes();
+        for (const publicIndex of publicIndexes) {
+            if (privateIndexes.includes(publicIndex)) {
+                throw kerror.get("index_already_exists", "public", publicIndex);
+            }
+        }
+        this.logger.info("[✔] Storage initialized");
+    }
+}
+module.exports = StorageEngine;
+//# sourceMappingURL=storageEngine.js.map

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

@@ -0,0 +1,35 @@
+export = BaseType;
+/**
+ * @class BaseType
+ */
+declare class BaseType {
+    /**
+     * Validate a document against a registered field type validator
+     *
+     * @param {TypeOptions} typeOptions
+     * @param {*} fieldValue
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    validate(): boolean;
+    /**
+     * Validate a field specification itself
+     *
+     * @param {TypeOptions} typeOptions
+     * @returns {TypeOptions}
+     * @throws {KuzzleError}
+     */
+    validateFieldSpecification(opts: any): TypeOptions;
+    /**
+     * @param {*} object
+     * @param {string[]} allowedProperties
+     * @returns {boolean}
+     */
+    checkAllowedProperties(object: any, allowedProperties: string[]): boolean;
+    /**
+     * @param {StructuredFieldSpecification} fieldSpec
+     * @param {boolean} parentStrictness
+     * @returns {boolean}
+     */
+    getStrictness(fieldSpec: StructuredFieldSpecification, parentStrictness: boolean): boolean;
+}

package/dist/lib/core/validation/baseType.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";
+/**
+ * @class BaseType
+ */
+class BaseType {
+    /**
+     * Validate a document against a registered field type validator
+     *
+     * @param {TypeOptions} typeOptions
+     * @param {*} fieldValue
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    validate() {
+        return true;
+    }
+    /**
+     * Validate a field specification itself
+     *
+     * @param {TypeOptions} typeOptions
+     * @returns {TypeOptions}
+     * @throws {KuzzleError}
+     */
+    validateFieldSpecification(opts) {
+        return opts;
+    }
+    /**
+     * @param {*} object
+     * @param {string[]} allowedProperties
+     * @returns {boolean}
+     */
+    checkAllowedProperties(object, allowedProperties) {
+        if (typeof object !== "object" ||
+            Array.isArray(object) ||
+            object === null) {
+            return false;
+        }
+        return !Object.keys(object).some((propertyName) => allowedProperties.indexOf(propertyName) === -1);
+    }
+    /**
+     * @param {StructuredFieldSpecification} fieldSpec
+     * @param {boolean} parentStrictness
+     * @returns {boolean}
+     */
+    getStrictness(fieldSpec, parentStrictness) {
+        return parentStrictness;
+    }
+}
+module.exports = BaseType;
+//# sourceMappingURL=baseType.js.map

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

@@ -0,0 +1,10 @@
+export = AnythingType;
+/**
+ * @class AnythingType
+ */
+declare class AnythingType extends BaseType {
+    typeName: string;
+    allowChildren: boolean;
+    allowedTypeOptions: any[];
+}
+import BaseType = require("../baseType");

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

@@ -18,21 +18,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 const BaseType = require("../baseType");
-
 /**
  * @class AnythingType
  */
 class AnythingType extends BaseType {
-  constructor() {
-    super();
-    this.typeName = "anything";
-    this.allowChildren = false;
-    this.allowedTypeOptions = [];
-  }
+    constructor() {
+        super();
+        this.typeName = "anything";
+        this.allowChildren = false;
+        this.allowedTypeOptions = [];
+    }
 }
-
 module.exports = AnythingType;
+//# sourceMappingURL=anything.js.map

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

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

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

@@ -18,35 +18,30 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 "use strict";
-
 const BaseType = require("../baseType");
-
 /**
  * @class BooleanType
  */
 class BooleanType extends BaseType {
-  constructor() {
-    super();
-    this.typeName = "boolean";
-    this.allowChildren = false;
-    this.allowedTypeOptions = [];
-  }
-
-  /**
-   * @param {TypeOptions} typeOptions
-   * @param {*} fieldValue
-   * @param {string[]} errorMessages
-   */
-  validate(typeOptions, fieldValue, errorMessages) {
-    if (typeof fieldValue !== "boolean") {
-      errorMessages.push("The field must be of type boolean.");
-      return false;
+    constructor() {
+        super();
+        this.typeName = "boolean";
+        this.allowChildren = false;
+        this.allowedTypeOptions = [];
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {*} fieldValue
+     * @param {string[]} errorMessages
+     */
+    validate(typeOptions, fieldValue, errorMessages) {
+        if (typeof fieldValue !== "boolean") {
+            errorMessages.push("The field must be of type boolean.");
+            return false;
+        }
+        return true;
     }
-
-    return true;
-  }
 }
-
 module.exports = BooleanType;
+//# sourceMappingURL=boolean.js.map

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

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

@@ -0,0 +1,215 @@
+/*
+ * 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"), { has, isPlainObject } = require("../../../util/safeObject"), BaseType = require("../baseType"), moment = require("moment"), formatMap = {
+    basic_date: (date) => moment.utc(date, "YYYYMMDD", true),
+    basic_date_time: (date) => moment.utc(date, "YYYYMMDD\\THHmmss.SSSZ", true),
+    basic_date_time_no_millis: (date) => moment.utc(date, "YYYYMMDD\\THHmmssZ", true),
+    basic_ordinal_date: (date) => moment.utc(date, "YYYYDDD", true),
+    basic_ordinal_date_time: (date) => moment.utc(date, "YYYYDDD\\THHmmss.SSSZ", true),
+    basic_ordinal_date_time_no_millis: (date) => moment.utc(date, "YYYYDDD\\THHmmssZ", true),
+    basic_t_time: (date) => moment.utc(date, "\\THHmmss.SSSZ", true),
+    basic_t_time_no_millis: (date) => moment.utc(date, "\\THHmmssZ", true),
+    basic_time: (date) => moment.utc(date, "HHmmss.SSSZ", true),
+    basic_time_no_millis: (date) => moment.utc(date, "HHmmssZ", true),
+    basic_week_date: (date) => moment.utc(date, "gggg\\Wwwe", false),
+    basic_week_date_time: (date) => moment.utc(date, "gggg\\Wwwe\\THHmmss.SSSZ", false),
+    basic_week_date_time_no_millis: (date) => moment.utc(date, "gggg\\Wwwe\\THHmmssZ", false),
+    date: (date) => moment.utc(date, "YYYY-MM-DD", false),
+    date_hour: (date) => moment.utc(date, "YYYY-MM-DD\\THH", false),
+    date_hour_minute: (date) => moment.utc(date, "YYYY-MM-DD\\THH:mm", false),
+    date_hour_minute_second: (date) => moment.utc(date, "YYYY-MM-DD\\THH:mm:ss", false),
+    date_hour_minute_second_fraction: (date) => moment.utc(date, "YYYY-MM-DD\\THH:mm:ss.SSS", false),
+    date_hour_minute_second_millis: (date) => moment.utc(date, "YYYY-MM-DD\\THH:mm:ss.SSS", false),
+    date_time: (date) => moment.utc(date, "YYYY-MM-DD\\THH:mm:ss.SSSZZ", false),
+    date_time_no_millis: (date) => moment.utc(date, "YYYY-MM-DD\\THH:mm:ssZZ", false),
+    epoch_millis: (date) => typeof date === "number" ? moment.utc(date) : moment.invalid(),
+    epoch_second: (date) => typeof date === "number"
+        ? moment.utc(moment.unix(date))
+        : moment.invalid(),
+    hour: (date) => moment.utc(date, "HH", false),
+    hour_minute: (date) => moment.utc(date, "HH:mm", false),
+    hour_minute_second: (date) => moment.utc(date, "HH:mm:ss", false),
+    hour_minute_second_fraction: (date) => moment.utc(date, "HH:mm:ss.SSS", false),
+    hour_minute_second_millis: (date) => moment.utc(date, "HH:mm:ss.SSS", false),
+    ordinal_date: (date) => moment.utc(date, "YYYY-DDD", false),
+    ordinal_date_time: (date) => moment.utc(date, "YYYY-DDD\\THH:mm:ss.SSSZZ", false),
+    ordinal_date_time_no_millis: (date) => moment.utc(date, "YYYY-DDD\\THH:mm:ssZZ", false),
+    strict_basic_week_date: (date) => moment.utc(date, "gggg\\Wwwe", true),
+    strict_basic_week_date_time: (date) => moment.utc(date, "gggg\\Wwwe\\THHmmss.SSSZ", true),
+    strict_basic_week_date_time_no_millis: (date) => moment.utc(date, "gggg\\Wwwe\\THHmmssZ", true),
+    strict_date: (date) => moment.utc(date, "YYYY-MM-DD", true),
+    strict_date_hour: (date) => moment.utc(date, "YYYY-MM-DD\\THH", true),
+    strict_date_hour_minute: (date) => moment.utc(date, "YYYY-MM-DD\\THH:mm", true),
+    strict_date_hour_minute_second: (date) => moment.utc(date, "YYYY-MM-DD\\THH:mm:ss", true),
+    strict_date_hour_minute_second_fraction: (date) => moment.utc(date, "YYYY-MM-DD\\THH:mm:ss.SSS", true),
+    strict_date_hour_minute_second_millis: (date) => moment.utc(date, "YYYY-MM-DD\\THH:mm:ss.SSS", true),
+    strict_date_optional_time: (date) => moment.utc(date, moment.ISO_8601, true),
+    strict_date_time: (date) => moment.utc(date, "YYYY-MM-DD\\THH:mm:ss.SSSZZ", true),
+    strict_date_time_no_millis: (date) => moment.utc(date, "YYYY-MM-DD\\THH:mm:ssZZ", true),
+    strict_hour: (date) => moment.utc(date, "HH", true),
+    strict_hour_minute: (date) => moment.utc(date, "HH:mm", true),
+    strict_hour_minute_second: (date) => moment.utc(date, "HH:mm:ss", true),
+    strict_hour_minute_second_fraction: (date) => moment.utc(date, "HH:mm:ss.SSS", true),
+    strict_hour_minute_second_millis: (date) => moment.utc(date, "HH:mm:ss.SSS", true),
+    strict_ordinal_date: (date) => moment.utc(date, "YYYY-DDD", true),
+    strict_ordinal_date_time: (date) => moment.utc(date, "YYYY-DDD\\THH:mm:ss.SSSZZ", true),
+    strict_ordinal_date_time_no_millis: (date) => moment.utc(date, "YYYY-DDD\\THH:mm:ssZZ", true),
+    strict_t_time: (date) => moment.utc(date, "\\THH:mm:ss.SSSZZ", true),
+    strict_t_time_no_millis: (date) => moment.utc(date, "\\THH:mm:ssZZ", true),
+    strict_time: (date) => moment.utc(date, "HH:mm:ss.SSSZZ", true),
+    strict_time_no_millis: (date) => moment.utc(date, "HH:mm:ssZZ", true),
+    strict_week_date: (date) => moment.utc(date, "gggg-\\Www-e", true),
+    strict_week_date_time: (date) => moment.utc(date, "gggg-\\Www-e\\THH:mm:ss.SSSZZ", true),
+    strict_week_date_time_no_millis: (date) => moment.utc(date, "gggg-\\Www-e\\THH:mm:ssZZ", true),
+    strict_weekyear: (date) => moment.utc(date, "gggg", true),
+    strict_weekyear_week: (date) => moment.utc(date, "ggggww", true),
+    strict_weekyear_week_day: (date) => moment.utc(date, "ggggwwe", true),
+    strict_year: (date) => moment.utc(date, "YYYY", true),
+    strict_year_month: (date) => moment.utc(date, "YYYYMM", true),
+    strict_year_month_day: (date) => moment.utc(date, "YYYYMMDD", true),
+    t_time: (date) => moment.utc(date, "\\THH:mm:ss.SSSZZ", false),
+    t_time_no_millis: (date) => moment.utc(date, "\\THH:mm:ssZZ", false),
+    time: (date) => moment.utc(date, "HH:mm:ss.SSSZZ", false),
+    time_no_millis: (date) => moment.utc(date, "HH:mm:ssZZ", false),
+    week_date: (date) => moment.utc(date, "gggg-\\Www-e", false),
+    week_date_time: (date) => moment.utc(date, "gggg-\\Www-e\\THH:mm:ss.SSSZZ", false),
+    week_date_time_no_millis: (date) => moment.utc(date, "gggg-\\Www-e\\THH:mm:ssZZ", false),
+    weekyear: (date) => moment.utc(date, "gggg", false),
+    weekyear_week: (date) => moment.utc(date, "ggggww", false),
+    weekyear_week_day: (date) => moment.utc(date, "ggggwwe", false),
+    year: (date) => moment.utc(date, "YYYY", false),
+    year_month: (date) => moment.utc(date, "YYYYMM", false),
+    year_month_day: (date) => moment.utc(date, "YYYYMMDD", false),
+};
+const assertionError = kerror.wrap("validation", "assert"), typeError = kerror.wrap("validation", "types");
+/**
+ * @class DateType
+ */
+class DateType extends BaseType {
+    constructor() {
+        super();
+        this.typeName = "date";
+        this.allowChildren = false;
+        this.allowedTypeOptions = ["range", "formats"];
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {*} fieldValue
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    validate(typeOptions, fieldValue, errorMessages) {
+        let momentDate = null;
+        for (const formatOpt of typeOptions.formats) {
+            momentDate = formatMap[formatOpt](fieldValue);
+            if (momentDate.isValid()) {
+                break;
+            }
+        }
+        if (momentDate === null || !momentDate.isValid()) {
+            errorMessages.push("The date format is invalid.");
+            return false;
+        }
+        if (isPlainObject(typeOptions.range)) {
+            if (typeOptions.range.min) {
+                const min = typeOptions.range.min === "NOW"
+                    ? moment.utc()
+                    : typeOptions.range.min;
+                if (momentDate.isBefore(min)) {
+                    errorMessages.push("The provided date is before the defined minimum.");
+                    return false;
+                }
+            }
+            if (typeOptions.range.max) {
+                const max = typeOptions.range.max === "NOW"
+                    ? moment.utc()
+                    : typeOptions.range.max;
+                if (max.isBefore(momentDate)) {
+                    errorMessages.push("The provided date is after the defined maximum.");
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @returns {TypeOptions}
+     * @throws {PreconditionError}
+     */
+    validateFieldSpecification(typeOptions) {
+        if (has(typeOptions, "formats")) {
+            if (!Array.isArray(typeOptions.formats) ||
+                typeOptions.formats.length === 0) {
+                throw assertionError.get("invalid_type", "formats", "non-empty array");
+            }
+            const unrecognized = typeOptions.formats.filter((f) => !formatMap[f]);
+            if (unrecognized.length > 0) {
+                throw typeError.get("invalid_date_format", unrecognized.join(", "));
+            }
+        }
+        else {
+            typeOptions.formats = ["epoch_millis"];
+        }
+        if (has(typeOptions, "range")) {
+            let min = null, max = null;
+            if (!this.checkAllowedProperties(typeOptions.range, ["min", "max"])) {
+                throw assertionError.get("unexpected_properties", "range", "min, max");
+            }
+            if (has(typeOptions.range, "min")) {
+                min = convertRangeValue("min", typeOptions.range.min);
+            }
+            if (has(typeOptions.range, "max")) {
+                max = convertRangeValue("max", typeOptions.range.max);
+            }
+            if (min && max && max.isBefore(min)) {
+                throw assertionError.get("invalid_range", "range", "min", "max");
+            }
+            // We want to keep NOW as a special value, else we would keep the time
+            // of the launch
+            if (min && typeOptions.range.min !== "NOW") {
+                typeOptions.range.min = min;
+            }
+            if (max && typeOptions.range.max !== "NOW") {
+                typeOptions.range.max = max;
+            }
+        }
+        return typeOptions;
+    }
+}
+function convertRangeValue(name, value) {
+    let converted;
+    if (typeof value === "string") {
+        converted =
+            value === "NOW" ? moment.utc() : moment.utc(value, moment.ISO_8601);
+    }
+    else if (typeof value === "number") {
+        // epoch or epoch-millis
+        converted = moment.utc(value);
+    }
+    if (!converted || !converted.isValid()) {
+        throw typeError.get("invalid_date", value);
+    }
+    return converted;
+}
+module.exports = DateType;
+//# sourceMappingURL=date.js.map

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

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

@@ -0,0 +1,80 @@
+/*
+ * 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 EmailType
+ */
+class EmailType extends BaseType {
+    constructor() {
+        super();
+        this.typeName = "email";
+        this.allowChildren = false;
+        this.allowedTypeOptions = ["notEmpty"];
+    }
+    /**
+     * @param {TypeOptions} typeOptions
+     * @param {*} fieldValue
+     * @param {string[]} errorMessages
+     * @returns {boolean}
+     */
+    validate(typeOptions, fieldValue, errorMessages) {
+        if (fieldValue === undefined || fieldValue === null) {
+            if (typeOptions.notEmpty) {
+                errorMessages.push("Field cannot be undefined or null");
+                return false;
+            }
+            return true;
+        }
+        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.");
+                return false;
+            }
+            return true;
+        }
+        if (!validator.isEmail(fieldValue)) {
+            errorMessages.push("The string must be a valid email 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 = EmailType;
+//# sourceMappingURL=email.js.map

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

@@ -0,0 +1,17 @@
+export = EnumType;
+/**
+ * @class EnumType
+ */
+declare class EnumType 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");