@decaf-ts/decorator-validation 1.5.2 → 1.5.5

package/lib/esm/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/esm/validation/Validators/types.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/validation/decorators.d.ts

@@ -0,0 +1,178 @@
+import "reflect-metadata";
+import { ModelConstructor } from "../model/types";
+/**
+ * @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
+ */
+export declare function required(message?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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
+ */
+export declare function min(value: number | Date | string, message?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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
+ */
+export declare function max(value: number | Date | string, message?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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
+ */
+export declare function step(value: number, message?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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
+ */
+export declare function minlength(value: number, message?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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
+ */
+export declare function maxlength(value: number, message?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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
+ */
+export declare function pattern(value: RegExp | string, message?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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
+ */
+export declare function email(message?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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
+ */
+export declare function url(message?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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
+ */
+export declare function type(types: string[] | string, message?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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
+ */
+export declare function date(format?: string, message?: string): (target: Record<string, any>, propertyKey?: any) => any;
+/**
+ * @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
+ */
+export declare function password(pattern?: RegExp, message?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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
+ */
+export declare function list(clazz: ModelConstructor<any> | ModelConstructor<any>[], collection?: "Array" | "Set", message?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @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
+ */
+export declare function set(clazz: ModelConstructor<any>, message?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;

package/lib/esm/validation/decorators.js

@@ -0,0 +1,290 @@
+import "reflect-metadata";
+import { DEFAULT_ERROR_MESSAGES, DEFAULT_PATTERNS, ValidationKeys, } from "./Validators/constants";
+import { sf } from "../utils/strings";
+import { parseDate } from "../utils/dates";
+import { propMetadata } from "../utils/decorators";
+import { Validation } from "./Validation";
+/**
+ * @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
+ */
+export function required(message = DEFAULT_ERROR_MESSAGES.REQUIRED) {
+    return propMetadata(Validation.key(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
+ */
+export function min(value, message = DEFAULT_ERROR_MESSAGES.MIN) {
+    return propMetadata(Validation.key(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
+ */
+export function max(value, message = DEFAULT_ERROR_MESSAGES.MAX) {
+    return propMetadata(Validation.key(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
+ */
+export function step(value, message = DEFAULT_ERROR_MESSAGES.STEP) {
+    return propMetadata(Validation.key(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
+ */
+export function minlength(value, message = DEFAULT_ERROR_MESSAGES.MIN_LENGTH) {
+    return propMetadata(Validation.key(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
+ */
+export function maxlength(value, message = DEFAULT_ERROR_MESSAGES.MAX_LENGTH) {
+    return propMetadata(Validation.key(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
+ */
+export function pattern(value, message = DEFAULT_ERROR_MESSAGES.PATTERN) {
+    return propMetadata(Validation.key(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
+ */
+export function email(message = DEFAULT_ERROR_MESSAGES.EMAIL) {
+    return propMetadata(Validation.key(ValidationKeys.EMAIL), {
+        pattern: 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
+ */
+export function url(message = DEFAULT_ERROR_MESSAGES.URL) {
+    return propMetadata(Validation.key(ValidationKeys.URL), {
+        pattern: 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
+ */
+export function type(types, message = DEFAULT_ERROR_MESSAGES.TYPE) {
+    return propMetadata(Validation.key(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
+ */
+export function date(format = "dd/MM/yyyy", message = DEFAULT_ERROR_MESSAGES.DATE) {
+    return (target, propertyKey) => {
+        propMetadata(Validation.key(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 = parseDate(format, newValue);
+                                values.set(this, val);
+                            }
+                            catch (e) {
+                                console.error(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
+ */
+export function password(pattern = DEFAULT_PATTERNS.PASSWORD.CHAR8_ONE_OF_EACH, message = DEFAULT_ERROR_MESSAGES.PASSWORD) {
+    return propMetadata(Validation.key(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
+ */
+export function list(clazz, collection = "Array", message = DEFAULT_ERROR_MESSAGES.LIST) {
+    return propMetadata(Validation.key(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
+ */
+export function set(clazz, message = 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"]}

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

@@ -0,0 +1,4 @@
+export * from "./Validators";
+export * from "./decorators";
+export * from "./types";
+export * from "./Validation";

package/lib/esm/validation/index.js

@@ -0,0 +1,6 @@
+export * from "./Validators";
+export * from "./decorators";
+export * from "./types";
+export * from "./Validation";
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy92YWxpZGF0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsY0FBYyxDQUFDIiwiZmlsZSI6InZhbGlkYXRpb24vaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9WYWxpZGF0b3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vVmFsaWRhdGlvblwiO1xuIl19

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

@@ -0,0 +1,46 @@
+import { DecoratorMetadata } from "@decaf-ts/reflection";
+/**
+ * @summary Type for validation decorator metadata
+ * @memberOf module:decorator-validation.Reflection
+ * @category Reflection
+ */
+export type ValidationMetadata = {
+    [indexer: string]: any;
+    args?: any[];
+    message: string;
+    types?: string[];
+};
+/**
+ * @summary Type for a validator property decorator definition
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export type ValidationPropertyDecoratorDefinition = {
+    prop: string | symbol;
+    decorators: ValidationDecoratorDefinition[];
+};
+/**
+ * @summary Type for a validator decorator definition
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export type ValidationDecoratorDefinition = DecoratorMetadata & {
+    props: ValidationElementDefinition;
+};
+/**
+ * @summary Type for a validator element metadata
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export type ValidationElementDefinition = {
+    [indexer: string]: any;
+    value?: string | number;
+    message: string;
+    types?: string[];
+};
+/**
+ * @summary Type for a model errors
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export type ModelErrors = Record<string, Record<string, string | undefined>>;