kuzzle 2.56.0 → 2.57.0-beta.2

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,195 +19,245 @@
  * 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),
+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 moment_1 = __importDefault(require("moment"));
+const kerror = __importStar(require("../../../kerror"));
+const safeObject_1 = require("../../../util/safeObject");
+const baseType_1 = __importDefault(require("../baseType"));
+const formatMap = {
+    basic_date: (date) => moment_1.default.utc(date, "YYYYMMDD", true),
+    basic_date_time: (date) => moment_1.default.utc(date, String.raw `YYYYMMDD\THHmmss.SSSZ`, true),
+    basic_date_time_no_millis: (date) => moment_1.default.utc(date, String.raw `YYYYMMDD\THHmmssZ`, true),
+    basic_ordinal_date: (date) => moment_1.default.utc(date, "YYYYDDD", true),
+    basic_ordinal_date_time: (date) => moment_1.default.utc(date, String.raw `YYYYDDD\THHmmss.SSSZ`, true),
+    basic_ordinal_date_time_no_millis: (date) => moment_1.default.utc(date, String.raw `YYYYDDD\THHmmssZ`, true),
+    basic_t_time: (date) => moment_1.default.utc(date, String.raw `\THHmmss.SSSZ`, true),
+    basic_t_time_no_millis: (date) => moment_1.default.utc(date, String.raw `\THHmmssZ`, true),
+    basic_time: (date) => moment_1.default.utc(date, "HHmmss.SSSZ", true),
+    basic_time_no_millis: (date) => moment_1.default.utc(date, "HHmmssZ", true),
+    basic_week_date: (date) => moment_1.default.utc(date, String.raw `gggg\Wwwe`, false),
+    basic_week_date_time: (date) => moment_1.default.utc(date, String.raw `gggg\Wwwe\THHmmss.SSSZ`, false),
+    basic_week_date_time_no_millis: (date) => moment_1.default.utc(date, String.raw `gggg\Wwwe\THHmmssZ`, false),
+    date: (date) => moment_1.default.utc(date, "YYYY-MM-DD", false),
+    date_hour: (date) => moment_1.default.utc(date, String.raw `YYYY-MM-DD\THH`, false),
+    date_hour_minute: (date) => moment_1.default.utc(date, String.raw `YYYY-MM-DD\THH:mm`, false),
+    date_hour_minute_second: (date) => moment_1.default.utc(date, String.raw `YYYY-MM-DD\THH:mm:ss`, false),
+    date_hour_minute_second_fraction: (date) => moment_1.default.utc(date, String.raw `YYYY-MM-DD\THH:mm:ss.SSS`, false),
+    date_hour_minute_second_millis: (date) => moment_1.default.utc(date, String.raw `YYYY-MM-DD\THH:mm:ss.SSS`, false),
+    date_time: (date) => moment_1.default.utc(date, String.raw `YYYY-MM-DD\THH:mm:ss.SSSZZ`, false),
+    date_time_no_millis: (date) => moment_1.default.utc(date, String.raw `YYYY-MM-DD\THH:mm:ssZZ`, false),
+    epoch_millis: (date) => typeof date === "number" ? moment_1.default.utc(date) : moment_1.default.invalid(),
+    epoch_second: (date) => typeof date === "number" ? moment_1.default.utc(moment_1.default.unix(date)) : moment_1.default.invalid(),
+    hour: (date) => moment_1.default.utc(date, "HH", false),
+    hour_minute: (date) => moment_1.default.utc(date, "HH:mm", false),
+    hour_minute_second: (date) => moment_1.default.utc(date, "HH:mm:ss", false),
+    hour_minute_second_fraction: (date) => moment_1.default.utc(date, "HH:mm:ss.SSS", false),
+    hour_minute_second_millis: (date) => moment_1.default.utc(date, "HH:mm:ss.SSS", false),
+    ordinal_date: (date) => moment_1.default.utc(date, "YYYY-DDD", false),
+    ordinal_date_time: (date) => moment_1.default.utc(date, String.raw `YYYY-DDD\THH:mm:ss.SSSZZ`, false),
+    ordinal_date_time_no_millis: (date) => moment_1.default.utc(date, String.raw `YYYY-DDD\THH:mm:ssZZ`, false),
+    strict_basic_week_date: (date) => moment_1.default.utc(date, String.raw `gggg\Wwwe`, true),
+    strict_basic_week_date_time: (date) => moment_1.default.utc(date, String.raw `gggg\Wwwe\THHmmss.SSSZ`, true),
+    strict_basic_week_date_time_no_millis: (date) => moment_1.default.utc(date, String.raw `gggg\Wwwe\THHmmssZ`, true),
+    strict_date: (date) => moment_1.default.utc(date, "YYYY-MM-DD", true),
+    strict_date_hour: (date) => moment_1.default.utc(date, String.raw `YYYY-MM-DD\THH`, true),
+    strict_date_hour_minute: (date) => moment_1.default.utc(date, String.raw `YYYY-MM-DD\THH:mm`, true),
+    strict_date_hour_minute_second: (date) => moment_1.default.utc(date, String.raw `YYYY-MM-DD\THH:mm:ss`, true),
+    strict_date_hour_minute_second_fraction: (date) => moment_1.default.utc(date, String.raw `YYYY-MM-DD\THH:mm:ss.SSS`, true),
+    strict_date_hour_minute_second_millis: (date) => moment_1.default.utc(date, String.raw `YYYY-MM-DD\THH:mm:ss.SSS`, true),
+    strict_date_optional_time: (date) => moment_1.default.utc(date, moment_1.default.ISO_8601, true),
+    strict_date_time: (date) => moment_1.default.utc(date, String.raw `YYYY-MM-DD\THH:mm:ss.SSSZZ`, true),
+    strict_date_time_no_millis: (date) => moment_1.default.utc(date, String.raw `YYYY-MM-DD\THH:mm:ssZZ`, true),
+    strict_hour: (date) => moment_1.default.utc(date, "HH", true),
+    strict_hour_minute: (date) => moment_1.default.utc(date, "HH:mm", true),
+    strict_hour_minute_second: (date) => moment_1.default.utc(date, "HH:mm:ss", true),
+    strict_hour_minute_second_fraction: (date) => moment_1.default.utc(date, "HH:mm:ss.SSS", true),
+    strict_hour_minute_second_millis: (date) => moment_1.default.utc(date, "HH:mm:ss.SSS", true),
+    strict_ordinal_date: (date) => moment_1.default.utc(date, "YYYY-DDD", true),
+    strict_ordinal_date_time: (date) => moment_1.default.utc(date, String.raw `YYYY-DDD\THH:mm:ss.SSSZZ`, true),
+    strict_ordinal_date_time_no_millis: (date) => moment_1.default.utc(date, String.raw `YYYY-DDD\THH:mm:ssZZ`, true),
+    strict_t_time: (date) => moment_1.default.utc(date, String.raw `\THH:mm:ss.SSSZZ`, true),
+    strict_t_time_no_millis: (date) => moment_1.default.utc(date, String.raw `\THH:mm:ssZZ`, true),
+    strict_time: (date) => moment_1.default.utc(date, "HH:mm:ss.SSSZZ", true),
+    strict_time_no_millis: (date) => moment_1.default.utc(date, "HH:mm:ssZZ", true),
+    strict_week_date: (date) => moment_1.default.utc(date, String.raw `gggg-\Www-e`, true),
+    strict_week_date_time: (date) => moment_1.default.utc(date, String.raw `gggg-\Www-e\THH:mm:ss.SSSZZ`, true),
+    strict_week_date_time_no_millis: (date) => moment_1.default.utc(date, String.raw `gggg-\Www-e\THH:mm:ssZZ`, true),
+    strict_weekyear: (date) => moment_1.default.utc(date, "gggg", true),
+    strict_weekyear_week: (date) => moment_1.default.utc(date, "ggggww", true),
+    strict_weekyear_week_day: (date) => moment_1.default.utc(date, "ggggwwe", true),
+    strict_year: (date) => moment_1.default.utc(date, "YYYY", true),
+    strict_year_month: (date) => moment_1.default.utc(date, "YYYYMM", true),
+    strict_year_month_day: (date) => moment_1.default.utc(date, "YYYYMMDD", true),
+    t_time: (date) => moment_1.default.utc(date, String.raw `\THH:mm:ss.SSSZZ`, false),
+    t_time_no_millis: (date) => moment_1.default.utc(date, String.raw `\THH:mm:ssZZ`, false),
+    time: (date) => moment_1.default.utc(date, "HH:mm:ss.SSSZZ", false),
+    time_no_millis: (date) => moment_1.default.utc(date, "HH:mm:ssZZ", false),
+    week_date: (date) => moment_1.default.utc(date, String.raw `gggg-\Www-e`, false),
+    week_date_time: (date) => moment_1.default.utc(date, String.raw `gggg-\Www-e\THH:mm:ss.SSSZZ`, false),
+    week_date_time_no_millis: (date) => moment_1.default.utc(date, String.raw `gggg-\Www-e\THH:mm:ssZZ`, false),
+    weekyear: (date) => moment_1.default.utc(date, "gggg", false),
+    weekyear_week: (date) => moment_1.default.utc(date, "ggggww", false),
+    weekyear_week_day: (date) => moment_1.default.utc(date, "ggggwwe", false),
+    year: (date) => moment_1.default.utc(date, "YYYY", false),
+    year_month: (date) => moment_1.default.utc(date, "YYYYMM", false),
+    year_month_day: (date) => moment_1.default.utc(date, "YYYYMMDD", false),
 };
 const assertionError = kerror.wrap("validation", "assert"), typeError = kerror.wrap("validation", "types");
-/**
- * @class DateType
- */
-class DateType extends BaseType {
+class DateType extends baseType_1.default {
     constructor() {
-        super();
+        super(...arguments);
         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()) {
+        const momentDate = parseDate(typeOptions.formats ?? [], fieldValue);
+        if (!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;
-                }
-            }
+        const { range } = typeOptions;
+        if (!(0, safeObject_1.isPlainObject)(range)) {
+            return true;
         }
-        return true;
+        return checkRange(momentDate, range, errorMessages);
+    }
+    /**
+     * Normalises the specification **in place**, as it always has — the caller's
+     * object is the one it answers — which is why the result is `Object.assign`ed
+     * onto it rather than built beside it.
+     *
+     * @throws {PreconditionError}
+     */
+    validateFieldSpecification(specification) {
+        const formats = validateFormats(specification);
+        const range = this.validateRange(specification);
+        return Object.assign(specification, range === undefined ? { formats } : { formats, range });
     }
     /**
-     * @param {TypeOptions} typeOptions
-     * @returns {TypeOptions}
+     * Converts `range`'s bounds, in place: each becomes a moment, except `NOW`,
+     * which is kept verbatim so that it resolves at validation time rather than
+     * at specification time.
+     *
      * @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(", "));
-            }
+    validateRange(specification) {
+        if (!(0, safeObject_1.has)(specification, "range")) {
+            return undefined;
+        }
+        const { range } = specification;
+        if (!this.checkAllowedProperties(range, ["min", "max"])) {
+            throw assertionError.get("unexpected_properties", "range", "min, max");
+        }
+        const bounds = {};
+        let min = null, max = null;
+        if ((0, safeObject_1.has)(range, "min")) {
+            min = convertRangeValue(range.min);
+            bounds.min = range.min === "NOW" ? "NOW" : min;
+        }
+        if ((0, safeObject_1.has)(range, "max")) {
+            max = convertRangeValue(range.max);
+            bounds.max = range.max === "NOW" ? "NOW" : max;
+        }
+        if (min && max?.isBefore(min)) {
+            throw assertionError.get("invalid_range", "range", "min", "max");
         }
-        else {
-            typeOptions.formats = ["epoch_millis"];
+        return Object.assign(range, bounds);
+    }
+}
+/**
+ * Parses `fieldValue` with the first of `formats` that accepts it.
+ */
+function parseDate(formats, fieldValue) {
+    let momentDate = null;
+    for (const formatOpt of formats) {
+        const parse = formatMap[formatOpt];
+        // unreachable: validateFieldSpecification rejects unknown formats
+        if (!parse) {
+            continue;
+        }
+        // `moment` is the one telling an unparseable value apart from a date
+        momentDate = parse(fieldValue);
+        if (momentDate.isValid()) {
+            break;
+        }
+    }
+    return momentDate;
+}
+function checkRange(momentDate, range, errorMessages) {
+    if (range.min) {
+        const min = range.min === "NOW" ? moment_1.default.utc() : range.min;
+        if (momentDate.isBefore(min)) {
+            errorMessages.push("The provided date is before the defined minimum.");
+            return false;
         }
-        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;
-            }
+    }
+    if (range.max) {
+        const max = range.max === "NOW" ? moment_1.default.utc() : range.max;
+        if (max.isBefore(momentDate)) {
+            errorMessages.push("The provided date is after the defined maximum.");
+            return false;
         }
-        return typeOptions;
     }
+    return true;
+}
+/**
+ * Checks `formats`, defaulting it to `epoch_millis` when absent.
+ *
+ * @throws {PreconditionError}
+ */
+function validateFormats(typeOptions) {
+    if (!(0, safeObject_1.has)(typeOptions, "formats")) {
+        typeOptions.formats = ["epoch_millis"];
+        return typeOptions.formats;
+    }
+    const { formats } = typeOptions;
+    if (!Array.isArray(formats) || formats.length === 0) {
+        throw assertionError.get("invalid_type", "formats", "non-empty array");
+    }
+    const unrecognized = formats.filter((f) => !formatMap[f]);
+    if (unrecognized.length > 0) {
+        throw typeError.get("invalid_date_format", unrecognized.join(", "));
+    }
+    return formats;
 }
-function convertRangeValue(name, value) {
+function convertRangeValue(value) {
     let converted;
     if (typeof value === "string") {
         converted =
-            value === "NOW" ? moment.utc() : moment.utc(value, moment.ISO_8601);
+            value === "NOW" ? moment_1.default.utc() : moment_1.default.utc(value, moment_1.default.ISO_8601);
     }
     else if (typeof value === "number") {
         // epoch or epoch-millis
-        converted = moment.utc(value);
+        converted = moment_1.default.utc(value);
     }
-    if (!converted || !converted.isValid()) {
+    if (!converted?.isValid()) {
         throw typeError.get("invalid_date", value);
     }
     return converted;

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

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

package/dist/lib/core/validation/types/email.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 EmailType
- */
-class EmailType extends BaseType {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const isEmail_1 = __importDefault(require("validator/lib/isEmail"));
+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 EmailType extends baseType_1.default {
     constructor() {
-        super();
+        super(...arguments);
         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) {
@@ -55,19 +53,17 @@ class EmailType extends BaseType {
             }
             return true;
         }
-        if (!validator.isEmail(fieldValue)) {
+        if (!(0, isEmail_1.default)(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")) {
+        if (!(0, safeObject_1.has)(typeOptions, "notEmpty")) {
             typeOptions.notEmpty = false;
         }
         else if (typeof typeOptions.notEmpty !== "boolean") {

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

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

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

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Kuzzle, a backend software, self-hostable and ready to use
  * to power modern apps
@@ -18,48 +19,66 @@
  * 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 {
+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 kerror = __importStar(require("../../../kerror"));
+const safeObject_1 = require("../../../util/safeObject");
+const baseType_1 = __importDefault(require("../baseType"));
+class EnumType extends baseType_1.default {
     constructor() {
-        super();
+        super(...arguments);
         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(", ")}".`);
+        const values = typeOptions.values ?? [];
+        if (!values.includes(fieldValue)) {
+            errorMessages.push(`The field only accepts following values: "${values.join(", ")}".`);
             return false;
         }
         return true;
     }
     /**
-     * @param {TypeOptions} typeOptions
-     * @returns {TypeOptions}
      * @throws {PreconditionError}
      */
     validateFieldSpecification(typeOptions) {
-        if (!Object.prototype.hasOwnProperty.call(typeOptions, "values")) {
+        if (!(0, safeObject_1.has)(typeOptions, "values")) {
             throw kerror.get("validation", "types", "missing_enum_values");
         }
-        if (!Array.isArray(typeOptions.values) || typeOptions.values.length === 0) {
+        const { values } = typeOptions;
+        if (!Array.isArray(values) || values.length === 0) {
             throw kerror.get("validation", "assert", "invalid_type", "values", "string[]");
         }
-        const nonString = typeOptions.values.filter((value) => typeof value !== "string");
+        const nonString = values.filter((value) => typeof value !== "string");
         if (nonString.length > 0) {
             throw kerror.get("validation", "assert", "invalid_type", "values", "string[]");
         }