@decaf-ts/decorator-validation 1.5.5 → 1.5.7

package/lib/utils/index.js

@@ -0,0 +1,23 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./dates"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./hashing"), exports);
+__exportStar(require("./registry"), exports);
+__exportStar(require("./serialization"), exports);
+__exportStar(require("./strings"), exports);

package/lib/utils/registry.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/serialization.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Serialization = exports.DefaultSerializationMethod = exports.JSONSerializer = void 0;
+const Model_1 = require("../model/Model");
+const constants_1 = require("./constants");
+/**
+ * @summary Concrete implementation of a {@link Serializer} in JSON format
+ * @description JS's native JSON.stringify (used here) is not deterministic
+ * and therefore should not be used for hashing purposes
+ *
+ * To keep dependencies low, we will not implement this, but we recommend
+ * implementing a similar {@link JSONSerializer} using 'deterministic-json' libraries
+ *
+ * @class JSONSerializer
+ * @implements Serializer
+ *
+ * @category Serialization
+ */
+class JSONSerializer {
+    /**
+     * @summary prepares the model for serialization
+     * @description returns a shallow copy of the object, containing an enumerable {@link ModelKeys#ANCHOR} property
+     * so the object can be recognized upon deserialization
+     *
+     * @param {T} model
+     * @protected
+     */
+    preSerialize(model) {
+        // TODO: nested preserialization (so increase performance when deserializing)
+        const toSerialize = Object.assign({}, model);
+        const metadata = Model_1.Model.getMetadata(model);
+        toSerialize[constants_1.ModelKeys.ANCHOR] = metadata || model.constructor.name;
+        return toSerialize;
+    }
+    /**
+     * @summary Rebuilds a model from a serialization
+     * @param {string} str
+     *
+     * @throws {Error} If it fails to parse the string, or to build the model
+     */
+    deserialize(str) {
+        const deserialization = JSON.parse(str);
+        const className = deserialization[constants_1.ModelKeys.ANCHOR];
+        if (!className)
+            throw new Error("Could not find class reference in serialized model");
+        const model = Model_1.Model.build(deserialization, className);
+        return model;
+    }
+    /**
+     * @summary Serializes a model
+     * @param {T} model
+     *
+     * @throws {Error} if fails to serialize
+     */
+    serialize(model) {
+        return JSON.stringify(this.preSerialize(model));
+    }
+}
+exports.JSONSerializer = JSONSerializer;
+exports.DefaultSerializationMethod = "json";
+class Serialization {
+    static { this.current = exports.DefaultSerializationMethod; }
+    static { this.cache = {
+        json: new JSONSerializer(),
+    }; }
+    constructor() { }
+    static get(key) {
+        if (key in this.cache)
+            return this.cache[key];
+        throw new Error(`No serialization method registered under ${key}`);
+    }
+    static register(key, func, setDefault = false) {
+        if (key in this.cache)
+            throw new Error(`Serialization method ${key} already registered`);
+        this.cache[key] = new func();
+        if (setDefault)
+            this.current = key;
+    }
+    static serialize(obj, method, ...args) {
+        if (!method)
+            return this.get(this.current).serialize(obj, ...args);
+        return this.get(method).serialize(obj, ...args);
+    }
+    static deserialize(obj, method, ...args) {
+        if (!method)
+            return this.get(this.current).deserialize(obj, ...args);
+        return this.get(method).deserialize(obj, ...args);
+    }
+    static setDefault(method) {
+        this.current = this.get(method);
+    }
+}
+exports.Serialization = Serialization;

package/lib/utils/strings.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sf = void 0;
+exports.stringFormat = stringFormat;
+/**
+ * @summary Util function to provide string format functionality similar to C#'s string.format
+ *
+ * @param {string} string
+ * @param {Array<string | number>} [args] replacements made by order of appearance (replacement0 wil replace {0} and so on)
+ * @return {string} formatted string
+ *
+ * @function stringFormat
+ * @memberOf module:decorator-validation.Utils.Format
+ * @category Format
+ */
+function stringFormat(string, ...args) {
+    return string.replace(/{(\d+)}/g, function (match, number) {
+        return typeof args[number] !== "undefined"
+            ? args[number].toString()
+            : "undefined";
+    });
+}
+/**
+ * @summary Util function to provide string format functionality similar to C#'s string.format
+ * @description alias for {@link stringFormat}
+ *
+ * @param {string} string
+ * @param {string} args replacements made by order of appearance (replacement0 wil replace {0} and so on)
+ * @return {string} formatted string
+ *
+ * @function sf
+ * @memberOf module:decorator-validation.Utils.Format
+ * @category Format
+ */
+exports.sf = stringFormat;

package/lib/validation/Validation.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validation = void 0;
+const ValidatorRegistry_1 = require("./Validators/ValidatorRegistry");
+const constants_1 = require("./Validators/constants");
+/**
+ * @summary Static class acting as a namespace for the Validation
+ *
+ * @class Validation
+ * @static
+ *
+ * @category Validation
+ */
+class Validation {
+    static { this.actingValidatorRegistry = undefined; }
+    constructor() { }
+    /**
+     * @summary Defines the acting ValidatorRegistry
+     *
+     * @param {IValidatorRegistry} validatorRegistry the new implementation of the validator Registry
+     * @param {function(Validator): Validator} [migrationHandler] the method to map the validator if required;
+     */
+    static setRegistry(validatorRegistry, migrationHandler) {
+        if (migrationHandler && Validation.actingValidatorRegistry)
+            Validation.actingValidatorRegistry.getKeys().forEach((k) => {
+                const validator = validatorRegistry.get(k);
+                if (validator)
+                    validatorRegistry.register(migrationHandler(validator));
+            });
+        Validation.actingValidatorRegistry = validatorRegistry;
+    }
+    /**
+     * @summary Returns the current ValidatorRegistry
+     *
+     * @return IValidatorRegistry, defaults to {@link ValidatorRegistry}
+     */
+    static getRegistry() {
+        if (!Validation.actingValidatorRegistry)
+            Validation.actingValidatorRegistry = new ValidatorRegistry_1.ValidatorRegistry();
+        return Validation.actingValidatorRegistry;
+    }
+    /**
+     * @summary Retrieves a validator
+     *
+     * @param {string} validatorKey one of the {@link ValidationKeys}
+     * @return {Validator | undefined} the registered Validator or undefined if there is nono matching the provided key
+     */
+    static get(validatorKey) {
+        return Validation.getRegistry().get(validatorKey);
+    }
+    /**
+     * @summary Registers the provided validators onto the registry
+     *
+     * @param {T[] | ValidatorDefinition[]} validator
+     */
+    static register(...validator) {
+        return Validation.getRegistry().register(...validator);
+    }
+    /**
+     * @summary Builds the key to store as Metadata under Reflections
+     * @description concatenates {@link ValidationKeys#REFLECT} with the provided key
+     *
+     * @param {string} key
+     */
+    static key(key) {
+        return constants_1.ValidationKeys.REFLECT + key;
+    }
+    /**
+     * @summary Returns all registered validation keys
+     */
+    static keys() {
+        return this.getRegistry().getKeys();
+    }
+}
+exports.Validation = Validation;

package/lib/validation/Validators/DateValidator.js

@@ -0,0 +1,57 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateValidator = void 0;
+const Validator_1 = require("./Validator");
+const constants_1 = require("./constants");
+const decorators_1 = require("./decorators");
+/**
+ * @summary Date Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}
+ *
+ * @class DateValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+let DateValidator = class DateValidator extends Validator_1.Validator {
+    constructor(message = constants_1.DEFAULT_ERROR_MESSAGES.DATE) {
+        super(message, Number.name, Date.name, String.name);
+    }
+    /**
+     * @summary Validates a model
+     *
+     * @param {Date | string} value
+     * @param {DateValidatorOptions} [options]
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options = {}) {
+        if (value === undefined)
+            return;
+        if (typeof value === "string")
+            value = new Date(value);
+        if (Number.isNaN(value.getDate())) {
+            const { message = "" } = options;
+            return this.getMessage(message || this.message);
+        }
+    }
+};
+exports.DateValidator = DateValidator;
+exports.DateValidator = DateValidator = __decorate([
+    (0, decorators_1.validator)(constants_1.ValidationKeys.DATE),
+    __metadata("design:paramtypes", [String])
+], DateValidator);

package/lib/validation/Validators/EmailValidator.js

@@ -0,0 +1,53 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailValidator = void 0;
+const constants_1 = require("./constants");
+const PatternValidator_1 = require("./PatternValidator");
+const decorators_1 = require("./decorators");
+/**
+ * @summary Email Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}
+ *
+ * @class EmailValidator
+ * @extends PatternValidator
+ *
+ * @category Validators
+ */
+let EmailValidator = class EmailValidator extends PatternValidator_1.PatternValidator {
+    constructor(message = constants_1.DEFAULT_ERROR_MESSAGES.EMAIL) {
+        super(message);
+    }
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {PatternValidatorOptions} [options]
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options = {}) {
+        return super.hasErrors(value, {
+            ...options,
+            pattern: options?.pattern || constants_1.DEFAULT_PATTERNS.EMAIL,
+        });
+    }
+};
+exports.EmailValidator = EmailValidator;
+exports.EmailValidator = EmailValidator = __decorate([
+    (0, decorators_1.validator)(constants_1.ValidationKeys.EMAIL),
+    __metadata("design:paramtypes", [String])
+], EmailValidator);

package/lib/validation/Validators/ListValidator.js

@@ -0,0 +1,70 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListValidator = void 0;
+const Validator_1 = require("./Validator");
+const constants_1 = require("./constants");
+const decorators_1 = require("./decorators");
+/**
+ * @summary List Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
+ *
+ * @class ListValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+let ListValidator = class ListValidator extends Validator_1.Validator {
+    constructor(message = constants_1.DEFAULT_ERROR_MESSAGES.LIST) {
+        super(message, Array.name, Set.name);
+    }
+    /**
+     * @summary Validates a model
+     *
+     * @param {any[] | Set<any>} value
+     * @param {ListValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options) {
+        if (!value || (Array.isArray(value) ? !value.length : !value.size))
+            return;
+        const clazz = Array.isArray(options.clazz)
+            ? options.clazz
+            : [options.clazz];
+        let val, isValid = true;
+        for (let i = 0; i < (Array.isArray(value) ? value.length : value.size); i++) {
+            val = value[i];
+            switch (typeof val) {
+                case "object":
+                case "function":
+                    isValid = clazz.includes(val.constructor?.name);
+                    break;
+                default:
+                    isValid = clazz.some((c) => typeof val === c.toLowerCase());
+                    break;
+            }
+        }
+        return isValid
+            ? undefined
+            : this.getMessage(options.message || this.message, clazz);
+    }
+};
+exports.ListValidator = ListValidator;
+exports.ListValidator = ListValidator = __decorate([
+    (0, decorators_1.validator)(constants_1.ValidationKeys.LIST),
+    __metadata("design:paramtypes", [String])
+], ListValidator);

package/lib/validation/Validators/MaxLengthValidator.js

@@ -0,0 +1,55 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxLengthValidator = void 0;
+const Validator_1 = require("./Validator");
+const constants_1 = require("./constants");
+const decorators_1 = require("./decorators");
+/**
+ * @summary Maximum Length Validator
+ * @description Validates strings and Arrays on their maximum length
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MAX_LENGTH}
+ *
+ * @class MinLengthValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+let MaxLengthValidator = class MaxLengthValidator extends Validator_1.Validator {
+    constructor(message = constants_1.DEFAULT_ERROR_MESSAGES.MAX_LENGTH) {
+        super(message, String.name, Array.name);
+    }
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {MaxLengthValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options) {
+        if (typeof value === "undefined")
+            return;
+        return value.length > options.maxLength
+            ? this.getMessage(options.message || this.message, options.maxLength)
+            : undefined;
+    }
+};
+exports.MaxLengthValidator = MaxLengthValidator;
+exports.MaxLengthValidator = MaxLengthValidator = __decorate([
+    (0, decorators_1.validator)(constants_1.ValidationKeys.MAX_LENGTH),
+    __metadata("design:paramtypes", [String])
+], MaxLengthValidator);

package/lib/validation/Validators/MaxValidator.js

@@ -0,0 +1,60 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxValidator = void 0;
+const Validator_1 = require("./Validator");
+const constants_1 = require("./constants");
+const decorators_1 = require("./decorators");
+/**
+ * @summary Max Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MAX}
+ *
+ * @class MaxValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+let MaxValidator = class MaxValidator extends Validator_1.Validator {
+    constructor(message = constants_1.DEFAULT_ERROR_MESSAGES.MAX) {
+        super(message, "number", "Date", "string");
+    }
+    /**
+     * @summary Validates a Model
+     *
+     * @param {string} value
+     * @param {MaxValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options) {
+        if (typeof value === "undefined")
+            return;
+        let { max } = options;
+        if (value instanceof Date && !(max instanceof Date)) {
+            max = new Date(max);
+            if (Number.isNaN(max.getDate()))
+                throw new Error("Invalid Max param defined");
+        }
+        return value > max
+            ? this.getMessage(options.message || this.message, max)
+            : undefined;
+    }
+};
+exports.MaxValidator = MaxValidator;
+exports.MaxValidator = MaxValidator = __decorate([
+    (0, decorators_1.validator)(constants_1.ValidationKeys.MAX),
+    __metadata("design:paramtypes", [String])
+], MaxValidator);

package/lib/validation/Validators/MinLengthValidator.js

@@ -0,0 +1,55 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinLengthValidator = void 0;
+const Validator_1 = require("./Validator");
+const constants_1 = require("./constants");
+const decorators_1 = require("./decorators");
+/**
+ * @summary Minimum Length Validator
+ * @description Validates strings and Arrays on their minimum length
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MIN_LENGTH}
+ *
+ * @class MinLengthValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+let MinLengthValidator = class MinLengthValidator extends Validator_1.Validator {
+    constructor(message = constants_1.DEFAULT_ERROR_MESSAGES.MIN_LENGTH) {
+        super(message, String.name, Array.name);
+    }
+    /**
+     *
+     * @param {string | Array} value
+     * @param {MinLengthValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @memberOf MinLengthValidator
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options) {
+        if (typeof value === "undefined")
+            return;
+        return value.length < options.minLength
+            ? this.getMessage(options.message || this.message, options.minLength)
+            : undefined;
+    }
+};
+exports.MinLengthValidator = MinLengthValidator;
+exports.MinLengthValidator = MinLengthValidator = __decorate([
+    (0, decorators_1.validator)(constants_1.ValidationKeys.MIN_LENGTH),
+    __metadata("design:paramtypes", [String])
+], MinLengthValidator);

package/lib/validation/Validators/MinValidator.js

@@ -0,0 +1,60 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinValidator = void 0;
+const Validator_1 = require("./Validator");
+const constants_1 = require("./constants");
+const decorators_1 = require("./decorators");
+/**
+ * @summary Min Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}
+ *
+ * @class MinValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+let MinValidator = class MinValidator extends Validator_1.Validator {
+    constructor(message = constants_1.DEFAULT_ERROR_MESSAGES.MIN) {
+        super(message, "number", "Date", "string");
+    }
+    /**
+     * @summary Validates Model
+     *
+     * @param {string} value
+     * @param {MaxValidatorOptions} options
+     *
+     * @return {string | undefined}
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value, options) {
+        if (typeof value === "undefined")
+            return;
+        let { min } = options;
+        if (value instanceof Date && !(min instanceof Date)) {
+            min = new Date(min);
+            if (Number.isNaN(min.getDate()))
+                throw new Error("Invalid Min param defined");
+        }
+        return value < min
+            ? this.getMessage(options.message || this.message, min)
+            : undefined;
+    }
+};
+exports.MinValidator = MinValidator;
+exports.MinValidator = MinValidator = __decorate([
+    (0, decorators_1.validator)(constants_1.ValidationKeys.MIN),
+    __metadata("design:paramtypes", [String])
+], MinValidator);