@decaf-ts/decorator-validation 1.5.2 → 1.5.5

package/lib/validation/Validators/index.cjs

@@ -0,0 +1,71 @@
+"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 });
+exports.Validators = void 0;
+const DateValidator_1 = require("./DateValidator.cjs");
+const TypeValidator_1 = require("./TypeValidator.cjs");
+const PasswordValidator_1 = require("./PasswordValidator.cjs");
+const StepValidator_1 = require("./StepValidator.cjs");
+const URLValidator_1 = require("./URLValidator.cjs");
+const PatternValidator_1 = require("./PatternValidator.cjs");
+const MinValidator_1 = require("./MinValidator.cjs");
+const MinLengthValidator_1 = require("./MinLengthValidator.cjs");
+const MaxValidator_1 = require("./MaxValidator.cjs");
+const MaxLengthValidator_1 = require("./MaxLengthValidator.cjs");
+const RequiredValidator_1 = require("./RequiredValidator.cjs");
+const EmailValidator_1 = require("./EmailValidator.cjs");
+const ListValidator_1 = require("./ListValidator.cjs");
+__exportStar(require("./constants.cjs"), exports);
+__exportStar(require("./DateValidator.cjs"), exports);
+__exportStar(require("./decorators.cjs"), exports);
+__exportStar(require("./EmailValidator.cjs"), exports);
+__exportStar(require("./ListValidator.cjs"), exports);
+__exportStar(require("./MaxLengthValidator.cjs"), exports);
+__exportStar(require("./MaxValidator.cjs"), exports);
+__exportStar(require("./MinLengthValidator.cjs"), exports);
+__exportStar(require("./MinValidator.cjs"), exports);
+__exportStar(require("./PasswordValidator.cjs"), exports);
+__exportStar(require("./PatternValidator.cjs"), exports);
+__exportStar(require("./RequiredValidator.cjs"), exports);
+__exportStar(require("./StepValidator.cjs"), exports);
+__exportStar(require("./types.cjs"), exports);
+__exportStar(require("./TypeValidator.cjs"), exports);
+__exportStar(require("./URLValidator.cjs"), exports);
+__exportStar(require("./Validator.cjs"), exports);
+__exportStar(require("./ValidatorRegistry.cjs"), exports);
+/**
+ * @summary constant holding all {@link Validator}s
+ * @constant Validators
+ * @memberOf module:decorator-validation.Validation.Validators
+ * @category Validation
+ */
+exports.Validators = {
+    DateValidator: DateValidator_1.DateValidator,
+    EmailValidator: EmailValidator_1.EmailValidator,
+    ListValidator: ListValidator_1.ListValidator,
+    MaxLengthValidator: MaxLengthValidator_1.MaxLengthValidator,
+    MaxValidator: MaxValidator_1.MaxValidator,
+    MinLengthValidator: MinLengthValidator_1.MinLengthValidator,
+    MinValidator: MinValidator_1.MinValidator,
+    PasswordValidator: PasswordValidator_1.PasswordValidator,
+    PatternValidator: PatternValidator_1.PatternValidator,
+    RequiredValidator: RequiredValidator_1.RequiredValidator,
+    StepValidator: StepValidator_1.StepValidator,
+    TypeValidator: TypeValidator_1.TypeValidator,
+    URLValidator: URLValidator_1.URLValidator,
+};
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/validation/Validators/index.d.ts

@@ -0,0 +1,52 @@
+import { DateValidator } from "./DateValidator";
+import { TypeValidator } from "./TypeValidator";
+import { PasswordValidator } from "./PasswordValidator";
+import { StepValidator } from "./StepValidator";
+import { URLValidator } from "./URLValidator";
+import { PatternValidator } from "./PatternValidator";
+import { MinValidator } from "./MinValidator";
+import { MinLengthValidator } from "./MinLengthValidator";
+import { MaxValidator } from "./MaxValidator";
+import { MaxLengthValidator } from "./MaxLengthValidator";
+import { RequiredValidator } from "./RequiredValidator";
+import { EmailValidator } from "./EmailValidator";
+import { ListValidator } from "./ListValidator";
+export * from "./constants";
+export * from "./DateValidator";
+export * from "./decorators";
+export * from "./EmailValidator";
+export * from "./ListValidator";
+export * from "./MaxLengthValidator";
+export * from "./MaxValidator";
+export * from "./MinLengthValidator";
+export * from "./MinValidator";
+export * from "./PasswordValidator";
+export * from "./PatternValidator";
+export * from "./RequiredValidator";
+export * from "./StepValidator";
+export * from "./types";
+export * from "./TypeValidator";
+export * from "./URLValidator";
+export * from "./Validator";
+export * from "./ValidatorRegistry";
+/**
+ * @summary constant holding all {@link Validator}s
+ * @constant Validators
+ * @memberOf module:decorator-validation.Validation.Validators
+ * @category Validation
+ */
+export declare const Validators: {
+    DateValidator: typeof DateValidator;
+    EmailValidator: typeof EmailValidator;
+    ListValidator: typeof ListValidator;
+    MaxLengthValidator: typeof MaxLengthValidator;
+    MaxValidator: typeof MaxValidator;
+    MinLengthValidator: typeof MinLengthValidator;
+    MinValidator: typeof MinValidator;
+    PasswordValidator: typeof PasswordValidator;
+    PatternValidator: typeof PatternValidator;
+    RequiredValidator: typeof RequiredValidator;
+    StepValidator: typeof StepValidator;
+    TypeValidator: typeof TypeValidator;
+    URLValidator: typeof URLValidator;
+};

package/lib/validation/Validators/types.d.ts

@@ -0,0 +1,88 @@
+import { Validator } from "./Validator";
+import { IRegistry } from "../../utils/registry";
+import { Constructor } from "../../model/types";
+/**
+ * @summary Util type for {@link Validator} configuration
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export type ValidatorDefinition = {
+    validator: Constructor<Validator>;
+    validationKey: string;
+    save: boolean;
+};
+/**
+ * @summary Base API for a {@link Validator} registry
+ *
+ * @interface ValidatorRegistry
+ * @extends IRegistry
+ *
+ * @category Validation
+ */
+export interface IValidatorRegistry<T extends Validator> extends IRegistry<T> {
+    /**
+     * @summary retrieves the custom keys
+     * @method
+     */
+    getCustomKeys(): Record<string, string>;
+    /**
+     * @summary Retrieves the Registered validator keys
+     * @return {string[]} the registered validators keys
+     * @method
+     */
+    getKeys(): string[];
+    /**
+     * @summary Registers the provided validators onto the registry
+     *
+     * @typedef T extends Validator
+     * @param {T[] | ValidatorDefinition[]} validator
+     * @method
+     */
+    register<T extends Validator>(...validator: (T | ValidatorDefinition)[]): void;
+    /**
+     * @summary Retrieves the Validator constructor if registered
+     *
+     * @typedef T extends Validator
+     * @param {string} key one of the {@link ValidationKeys}
+     * @return {Validator | undefined} the registered Validator or undefined if there is nono matching the provided key
+     * @method
+     */
+    get<T extends Validator>(key: string): T | undefined;
+}
+export type ValidatorOptions = {
+    message?: string;
+};
+export interface URLValidatorOptions extends ValidatorOptions {
+    types: string | string[] | {
+        name: string;
+    };
+}
+export interface TypeValidatorOptions extends ValidatorOptions {
+    types: string | string[] | {
+        name: string;
+    };
+}
+export interface StepValidatorOptions extends ValidatorOptions {
+    step: number | string;
+}
+export interface PatternValidatorOptions extends ValidatorOptions {
+    pattern?: RegExp | string;
+}
+export interface MinValidatorOptions extends ValidatorOptions {
+    min: number | Date | string;
+}
+export interface MinLengthValidatorOptions extends ValidatorOptions {
+    minLength: number;
+}
+export interface MaxValidatorOptions extends ValidatorOptions {
+    max: number | Date | string;
+}
+export interface MaxLengthValidatorOptions extends ValidatorOptions {
+    maxLength: number;
+}
+export interface ListValidatorOptions extends ValidatorOptions {
+    clazz: string[];
+}
+export interface DateValidatorOptions extends ValidatorOptions {
+    format?: string;
+}

package/lib/validation/decorators.cjs

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.required = required;
+exports.min = min;
+exports.max = max;
+exports.step = step;
+exports.minlength = minlength;
+exports.maxlength = maxlength;
+exports.pattern = pattern;
+exports.email = email;
+exports.url = url;
+exports.type = type;
+exports.date = date;
+exports.password = password;
+exports.list = list;
+exports.set = set;
+require("reflect-metadata");
+const constants_1 = require("./Validators/constants.cjs");
+const strings_1 = require("../utils/strings.cjs");
+const dates_1 = require("../utils/dates.cjs");
+const decorators_1 = require("../utils/decorators.cjs");
+const Validation_1 = require("./Validation.cjs");
+/**
+ * @summary Marks the property as required.
+ * @description Validators to validate a decorated property must use key {@link ValidationKeys#REQUIRED}
+ *
+ * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}
+ *
+ * @function required
+ *
+ * @category Decorators
+ */
+function required(message = constants_1.DEFAULT_ERROR_MESSAGES.REQUIRED) {
+    return (0, decorators_1.propMetadata)(Validation_1.Validation.key(constants_1.ValidationKeys.REQUIRED), {
+        message: message,
+    });
+}
+/**
+ * @summary Defines a minimum value for the property
+ * @description Validators to validate a decorated property must use key {@link ValidationKeys#MIN}
+ *
+ * @param {number | Date} value
+ * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}
+ *
+ * @function min
+ * @memberOf module:decorator-validation.Decorators.Validation
+ * @category Decorators
+ */
+function min(value, message = constants_1.DEFAULT_ERROR_MESSAGES.MIN) {
+    return (0, decorators_1.propMetadata)(Validation_1.Validation.key(constants_1.ValidationKeys.MIN), {
+        min: value,
+        message: message,
+        types: [Number.name, Date.name],
+    });
+}
+/**
+ * @summary Defines a maximum value for the property
+ * @description Validators to validate a decorated property must use key {@link ValidationKeys#MAX}
+ *
+ * @param {number | Date} value
+ * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MAX}
+ *
+ * @function max
+ * @memberOf module:decorator-validation.Decorators.Validation
+ * @category Decorators
+ */
+function max(value, message = constants_1.DEFAULT_ERROR_MESSAGES.MAX) {
+    return (0, decorators_1.propMetadata)(Validation_1.Validation.key(constants_1.ValidationKeys.MAX), {
+        max: value,
+        message: message,
+        types: [Number.name, Date.name],
+    });
+}
+/**
+ * @summary Defines a step value for the property
+ * @description Validators to validate a decorated property must use key {@link ValidationKeys#STEP}
+ *
+ * @param {number} value
+ * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#STEP}
+ *
+ * @function step
+ * @memberOf module:decorator-validation.Decorators.Validation
+ * @category Decorators
+ */
+function step(value, message = constants_1.DEFAULT_ERROR_MESSAGES.STEP) {
+    return (0, decorators_1.propMetadata)(Validation_1.Validation.key(constants_1.ValidationKeys.STEP), {
+        step: value,
+        message: message,
+        types: [Number.name],
+    });
+}
+/**
+ * @summary Defines a minimum length for the property
+ * @description Validators to validate a decorated property must use key {@link ValidationKeys#MIN_LENGTH}
+ *
+ * @param {string} value
+ * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MIN_LENGTH}
+ *
+ * @function minlength
+ * @memberOf module:decorator-validation.Decorators.Validation
+ * @category Decorators
+ */
+function minlength(value, message = constants_1.DEFAULT_ERROR_MESSAGES.MIN_LENGTH) {
+    return (0, decorators_1.propMetadata)(Validation_1.Validation.key(constants_1.ValidationKeys.MIN_LENGTH), {
+        minLength: value,
+        message: message,
+        types: [String.name, Array.name, Set.name],
+    });
+}
+/**
+ * @summary Defines a maximum length for the property
+ * @description Validators to validate a decorated property must use key {@link ValidationKeys#MAX_LENGTH}
+ *
+ * @param {string} value
+ * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MAX_LENGTH}
+ *
+ * @function maxlength
+ * @memberOf module:decorator-validation.Decorators.Validation
+ * @category Decorators
+ */
+function maxlength(value, message = constants_1.DEFAULT_ERROR_MESSAGES.MAX_LENGTH) {
+    return (0, decorators_1.propMetadata)(Validation_1.Validation.key(constants_1.ValidationKeys.MAX_LENGTH), {
+        maxLength: value,
+        message: message,
+        types: [String.name, Array.name, Set.name],
+    });
+}
+/**
+ * @summary Defines a RegExp pattern the property must respect
+ * @description Validators to validate a decorated property must use key {@link ValidationKeys#PATTERN}
+ *
+ * @param {string} value
+ * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}
+ *
+ * @function pattern
+ * @memberOf module:decorator-validation.Decorators.Validation
+ * @category Decorators
+ */
+function pattern(value, message = constants_1.DEFAULT_ERROR_MESSAGES.PATTERN) {
+    return (0, decorators_1.propMetadata)(Validation_1.Validation.key(constants_1.ValidationKeys.PATTERN), {
+        pattern: typeof value === "string" ? value : value.toString(),
+        message: message,
+        types: [String.name],
+    });
+}
+/**
+ * @summary Defines the property as an email
+ * @description Validators to validate a decorated property must use key {@link ValidationKeys#EMAIL}
+ *
+ * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}
+ *
+ * @function email
+ * @memberOf module:decorator-validation.Decorators.Validation
+ * @category Decorators
+ */
+function email(message = constants_1.DEFAULT_ERROR_MESSAGES.EMAIL) {
+    return (0, decorators_1.propMetadata)(Validation_1.Validation.key(constants_1.ValidationKeys.EMAIL), {
+        pattern: constants_1.DEFAULT_PATTERNS.EMAIL,
+        message: message,
+        types: [String.name],
+    });
+}
+/**
+ * @summary Defines the property as an URL
+ * @description Validators to validate a decorated property must use key {@link ValidationKeys#URL}
+ *
+ * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#URL}
+ *
+ * @function url
+ * @memberOf module:decorator-validation.Decorators.Validation
+ * @category Decorators
+ */
+function url(message = constants_1.DEFAULT_ERROR_MESSAGES.URL) {
+    return (0, decorators_1.propMetadata)(Validation_1.Validation.key(constants_1.ValidationKeys.URL), {
+        pattern: constants_1.DEFAULT_PATTERNS.URL,
+        message: message,
+        types: [String.name],
+    });
+}
+/**
+ * @summary Enforces type verification
+ * @description Validators to validate a decorated property must use key {@link ValidationKeys#TYPE}
+ *
+ * @param {string[] | string} types accepted types
+ * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#TYPE}
+ *
+ * @function type
+ * @memberOf module:decorator-validation.Decorators.Validation
+ * @category Decorators
+ */
+function type(types, message = constants_1.DEFAULT_ERROR_MESSAGES.TYPE) {
+    return (0, decorators_1.propMetadata)(Validation_1.Validation.key(constants_1.ValidationKeys.TYPE), {
+        customTypes: types,
+        message: message,
+    });
+}
+/**
+ * @summary Date Handler Decorator
+ * @description Validators to validate a decorated property must use key {@link ValidationKeys#DATE}
+ *
+ * Will enforce serialization according to the selected format
+ *
+ * @param {string} format accepted format according to {@link formatDate}
+ * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}
+ * @param {Constructor<Validator>} [validator] the Validator to be used. Defaults to {@link DateValidator}
+ *
+ * @function date
+ *
+ * @memberOf module:decorator-validation.Decorators.Validation
+ * @category Decorators
+ */
+function date(format = "dd/MM/yyyy", message = constants_1.DEFAULT_ERROR_MESSAGES.DATE) {
+    return (target, propertyKey) => {
+        (0, decorators_1.propMetadata)(Validation_1.Validation.key(constants_1.ValidationKeys.DATE), {
+            format: format,
+            message: message,
+            types: [Date.name],
+        })(target, propertyKey);
+        const values = new WeakMap();
+        Object.defineProperty(target, propertyKey, {
+            configurable: false,
+            set(newValue) {
+                const descriptor = Object.getOwnPropertyDescriptor(this, propertyKey);
+                if (!descriptor || descriptor.configurable)
+                    Object.defineProperty(this, propertyKey, {
+                        enumerable: true,
+                        configurable: false,
+                        get: () => values.get(this),
+                        set: (newValue) => {
+                            let val;
+                            try {
+                                val = (0, dates_1.parseDate)(format, newValue);
+                                values.set(this, val);
+                            }
+                            catch (e) {
+                                console.error((0, strings_1.sf)("Failed to parse date: {0}", e.message || e));
+                            }
+                        },
+                    });
+                this[propertyKey] = newValue;
+            },
+            get() {
+                console.log("here");
+            },
+        });
+    };
+}
+/**
+ * @summary Password Handler Decorator
+ * @description Validators to validate a decorated property must use key {@link ValidationKeys#PASSWORD}
+ *
+ * @param {RegExp} [pattern] defaults to {@link PasswordPatterns#CHAR8_ONE_OF_EACH}
+ * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#PASSWORD}
+ * @param {Constructor<Validator>} [validator] Defaults to {@link PasswordValidator}
+ *
+ * @function password
+ *
+ * @memberOf module:decorator-validation.Decorators.Validation
+ * @category Decorators
+ */
+function password(pattern = constants_1.DEFAULT_PATTERNS.PASSWORD.CHAR8_ONE_OF_EACH, message = constants_1.DEFAULT_ERROR_MESSAGES.PASSWORD) {
+    return (0, decorators_1.propMetadata)(Validation_1.Validation.key(constants_1.ValidationKeys.PASSWORD), {
+        pattern: pattern,
+        message: message,
+        types: [String.name],
+    });
+}
+/**
+ * @summary List Decorator
+ * @description Also sets the {@link type} to the provided collection
+ *
+ * @param {ModelConstructor} clazz
+ * @param {string} [collection] The collection being used. defaults to Array
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
+ * @param {Constructor<Validator>} [validator] defaults to {@link ListValidator}
+ *
+ * @function list
+ *
+ * @memberOf module:decorator-validation.Decorators.Validation
+ * @category Decorators
+ */
+function list(clazz, collection = "Array", message = constants_1.DEFAULT_ERROR_MESSAGES.LIST) {
+    return (0, decorators_1.propMetadata)(Validation_1.Validation.key(constants_1.ValidationKeys.LIST), {
+        clazz: Array.isArray(clazz) ? clazz.map((c) => c.name) : [clazz.name],
+        type: collection,
+        message: message,
+    });
+}
+/**
+ * @summary Set Decorator
+ * @description Wrapper for {@link list} with the 'Set' Collection
+ *
+ * @param {ModelConstructor} clazz
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
+ * @param {Constructor<Validator>} [validator]
+ *
+ * @function set
+ *
+ * @memberOf module:decorator-validation.Decorators.Validation
+ * @category Decorators
+ */
+function set(clazz, message = constants_1.DEFAULT_ERROR_MESSAGES.LIST) {
+    return list(clazz, "Set", message);
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/validation/decorators.ts"],"names":[],"mappings":"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","file":"validation/decorators.js","sourcesContent":["import \"reflect-metadata\";\nimport { ValidationMetadata } from \"./types\";\nimport {\n  DEFAULT_ERROR_MESSAGES,\n  DEFAULT_PATTERNS,\n  ValidationKeys,\n} from \"./Validators/constants\";\nimport { sf } from \"../utils/strings\";\nimport { ModelConstructor } from \"../model/types\";\nimport { parseDate } from \"../utils/dates\";\nimport { propMetadata } from \"../utils/decorators\";\nimport { Validation } from \"./Validation\";\n\n/**\n * @summary Marks the property as required.\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#REQUIRED}\n *\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}\n *\n * @function required\n *\n * @category Decorators\n */\nexport function required(message: string = DEFAULT_ERROR_MESSAGES.REQUIRED) {\n  return propMetadata<ValidationMetadata>(\n    Validation.key(ValidationKeys.REQUIRED),\n    {\n      message: message,\n    }\n  );\n}\n\n/**\n * @summary Defines a minimum value for the property\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#MIN}\n *\n * @param {number | Date} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}\n *\n * @function min\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function min(\n  value: number | Date | string,\n  message: string = DEFAULT_ERROR_MESSAGES.MIN\n) {\n  return propMetadata<ValidationMetadata>(Validation.key(ValidationKeys.MIN), {\n    min: value,\n    message: message,\n    types: [Number.name, Date.name],\n  });\n}\n\n/**\n * @summary Defines a maximum value for the property\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#MAX}\n *\n * @param {number | Date} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MAX}\n *\n * @function max\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function max(\n  value: number | Date | string,\n  message: string = DEFAULT_ERROR_MESSAGES.MAX\n) {\n  return propMetadata<ValidationMetadata>(Validation.key(ValidationKeys.MAX), {\n    max: value,\n    message: message,\n    types: [Number.name, Date.name],\n  });\n}\n\n/**\n * @summary Defines a step value for the property\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#STEP}\n *\n * @param {number} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#STEP}\n *\n * @function step\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function step(\n  value: number,\n  message: string = DEFAULT_ERROR_MESSAGES.STEP\n) {\n  return propMetadata<ValidationMetadata>(Validation.key(ValidationKeys.STEP), {\n    step: value,\n    message: message,\n    types: [Number.name],\n  });\n}\n\n/**\n * @summary Defines a minimum length for the property\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#MIN_LENGTH}\n *\n * @param {string} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MIN_LENGTH}\n *\n * @function minlength\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function minlength(\n  value: number,\n  message: string = DEFAULT_ERROR_MESSAGES.MIN_LENGTH\n) {\n  return propMetadata<ValidationMetadata>(\n    Validation.key(ValidationKeys.MIN_LENGTH),\n    {\n      minLength: value,\n      message: message,\n      types: [String.name, Array.name, Set.name],\n    }\n  );\n}\n\n/**\n * @summary Defines a maximum length for the property\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#MAX_LENGTH}\n *\n * @param {string} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MAX_LENGTH}\n *\n * @function maxlength\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function maxlength(\n  value: number,\n  message: string = DEFAULT_ERROR_MESSAGES.MAX_LENGTH\n) {\n  return propMetadata<ValidationMetadata>(\n    Validation.key(ValidationKeys.MAX_LENGTH),\n    {\n      maxLength: value,\n      message: message,\n      types: [String.name, Array.name, Set.name],\n    }\n  );\n}\n\n/**\n * @summary Defines a RegExp pattern the property must respect\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#PATTERN}\n *\n * @param {string} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}\n *\n * @function pattern\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function pattern(\n  value: RegExp | string,\n  message: string = DEFAULT_ERROR_MESSAGES.PATTERN\n) {\n  return propMetadata<ValidationMetadata>(\n    Validation.key(ValidationKeys.PATTERN),\n    {\n      pattern: typeof value === \"string\" ? value : value.toString(),\n      message: message,\n      types: [String.name],\n    }\n  );\n}\n\n/**\n * @summary Defines the property as an email\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#EMAIL}\n *\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}\n *\n * @function email\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function email(message: string = DEFAULT_ERROR_MESSAGES.EMAIL) {\n  return propMetadata<ValidationMetadata>(\n    Validation.key(ValidationKeys.EMAIL),\n    {\n      pattern: DEFAULT_PATTERNS.EMAIL,\n      message: message,\n      types: [String.name],\n    }\n  );\n}\n\n/**\n * @summary Defines the property as an URL\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#URL}\n *\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#URL}\n *\n * @function url\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function url(message: string = DEFAULT_ERROR_MESSAGES.URL) {\n  return propMetadata<ValidationMetadata>(Validation.key(ValidationKeys.URL), {\n    pattern: DEFAULT_PATTERNS.URL,\n    message: message,\n    types: [String.name],\n  });\n}\n\n/**\n * @summary Enforces type verification\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#TYPE}\n *\n * @param {string[] | string} types accepted types\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#TYPE}\n *\n * @function type\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function type(\n  types: string[] | string,\n  message: string = DEFAULT_ERROR_MESSAGES.TYPE\n) {\n  return propMetadata<ValidationMetadata>(Validation.key(ValidationKeys.TYPE), {\n    customTypes: types,\n    message: message,\n  });\n}\n\n/**\n * @summary Date Handler Decorator\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#DATE}\n *\n * Will enforce serialization according to the selected format\n *\n * @param {string} format accepted format according to {@link formatDate}\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}\n * @param {Constructor<Validator>} [validator] the Validator to be used. Defaults to {@link DateValidator}\n *\n * @function date\n *\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function date(\n  format: string = \"dd/MM/yyyy\",\n  message: string = DEFAULT_ERROR_MESSAGES.DATE\n) {\n  return (target: Record<string, any>, propertyKey?: any): any => {\n    propMetadata(Validation.key(ValidationKeys.DATE), {\n      format: format,\n      message: message,\n      types: [Date.name],\n    })(target, propertyKey);\n\n    const values = new WeakMap();\n\n    Object.defineProperty(target, propertyKey, {\n      configurable: false,\n      set(this: any, newValue: string | Date) {\n        const descriptor = Object.getOwnPropertyDescriptor(this, propertyKey);\n        if (!descriptor || descriptor.configurable)\n          Object.defineProperty(this, propertyKey, {\n            enumerable: true,\n            configurable: false,\n            get: () => values.get(this),\n            set: (newValue: string | Date | number) => {\n              let val: Date | undefined;\n              try {\n                val = parseDate(format, newValue);\n                values.set(this, val);\n              } catch (e: any) {\n                console.error(sf(\"Failed to parse date: {0}\", e.message || e));\n              }\n            },\n          });\n        this[propertyKey] = newValue;\n      },\n      get() {\n        console.log(\"here\");\n      },\n    });\n  };\n}\n\n/**\n * @summary Password Handler Decorator\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#PASSWORD}\n *\n * @param {RegExp} [pattern] defaults to {@link PasswordPatterns#CHAR8_ONE_OF_EACH}\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#PASSWORD}\n * @param {Constructor<Validator>} [validator] Defaults to {@link PasswordValidator}\n *\n * @function password\n *\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function password(\n  pattern: RegExp = DEFAULT_PATTERNS.PASSWORD.CHAR8_ONE_OF_EACH,\n  message: string = DEFAULT_ERROR_MESSAGES.PASSWORD\n) {\n  return propMetadata(Validation.key(ValidationKeys.PASSWORD), {\n    pattern: pattern,\n    message: message,\n    types: [String.name],\n  });\n}\n\n/**\n * @summary List Decorator\n * @description Also sets the {@link type} to the provided collection\n *\n * @param {ModelConstructor} clazz\n * @param {string} [collection] The collection being used. defaults to Array\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}\n * @param {Constructor<Validator>} [validator] defaults to {@link ListValidator}\n *\n * @function list\n *\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function list(\n  clazz: ModelConstructor<any> | ModelConstructor<any>[],\n  collection: \"Array\" | \"Set\" = \"Array\",\n  message: string = DEFAULT_ERROR_MESSAGES.LIST\n) {\n  return propMetadata(Validation.key(ValidationKeys.LIST), {\n    clazz: Array.isArray(clazz) ? clazz.map((c) => c.name) : [clazz.name],\n    type: collection,\n    message: message,\n  });\n}\n\n/**\n * @summary Set Decorator\n * @description Wrapper for {@link list} with the 'Set' Collection\n *\n * @param {ModelConstructor} clazz\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}\n * @param {Constructor<Validator>} [validator]\n *\n * @function set\n *\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function set(\n  clazz: ModelConstructor<any>,\n  message: string = DEFAULT_ERROR_MESSAGES.LIST\n) {\n  return list(clazz, \"Set\", message);\n}\n"]}