@decaf-ts/decorator-validation 1.7.7 → 1.7.9

package/lib/model/validation.cjs

@@ -1,152 +1,361 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValidationDecorators = getValidationDecorators;
+exports.getValidatableProperties = getValidatableProperties;
+exports.validateDecorator = validateDecorator;
+exports.validateDecorators = validateDecorators;
 exports.validate = validate;
 const ModelErrorDefinition_1 = require("./ModelErrorDefinition.cjs");
-const reflection_1 = require("@decaf-ts/reflection");
 const constants_1 = require("./../utils/constants.cjs");
-const constants_2 = require("./constants.cjs");
-const constants_3 = require("./../constants/index.cjs");
 const Model_1 = require("./Model.cjs");
 const Validation_1 = require("./../validation/Validation.cjs");
-const constants_4 = require("./../validation/Validators/constants.cjs");
+const constants_2 = require("./../validation/Validators/constants.cjs");
 const PathProxy_1 = require("./../utils/PathProxy.cjs");
+const constants_3 = require("./../constants/index.cjs");
+const reflection_1 = require("@decaf-ts/reflection");
+const utils_1 = require("./utils.cjs");
+/**
+ * Retrieves the validation metadata decorators associated with a specific property of a model,
+ * using the reflective metadata key.
+ *
+ * @param model - The model instance or class containing the decorated property.
+ * @param {string} prop - The name of the property whose decorators should be retrieved.
+ * @param {string} reflectKey - The metadata key used to retrieve the decorators.
+ *                     Defaults to `ValidationKeys.REFLECT`.
+ *
+ * @returns The validation decorators applied to the property
+ */
+function getValidationDecorators(model, prop, reflectKey = constants_2.ValidationKeys.REFLECT) {
+    return reflection_1.Reflection.getPropertyDecorators(reflectKey, model, prop);
+}
+/**
+ * @description
+ * Retrieves all validatable property decorators from a given model, excluding specified properties.
+ *
+ * @summary
+ * Iterates through the own enumerable properties of a model instance, filtering out any properties
+ * listed in the `propsToIgnore` array. For each remaining property, it checks whether validation
+ * decorators are present using `getValidationDecorators`, and if so, collects them in the result array.
+ *
+ * @template M - A generic parameter extending the `Model` class, representing the model type being inspected.
+ *
+ * @param {M} model - An instance of a class extending `Model` from which validatable properties will be extracted.
+ * @param {string[]} propsToIgnore - An array of property names that should be excluded from validation inspection.
+ *
+ * @return {ValidationPropertyDecoratorDefinition[]} An array of validation decorator definitions
+ * associated with the model's properties, excluding those listed in `propsToIgnore`.
+ *
+ * @function getValidatableProperties
+ */
+function getValidatableProperties(model, propsToIgnore) {
+    const decoratedProperties = [];
+    for (const prop in model) {
+        if (Object.prototype.hasOwnProperty.call(model, prop) &&
+            !propsToIgnore.includes(prop)) {
+            const dec = getValidationDecorators(model, prop);
+            if (dec)
+                decoratedProperties.push(dec);
+        }
+    }
+    return decoratedProperties;
+}
+/**
+ * Safely sets temporary metadata on an object
+ */
+function setTemporaryContext(target, key, value) {
+    if (!Object.hasOwnProperty.call(target, key))
+        target[key] = value;
+}
+/**
+ * Safely removes temporary metadata from an object
+ */
+function cleanupTemporaryContext(target, key) {
+    if (Object.hasOwnProperty.call(target, key))
+        delete target[key];
+}
+/**
+ * Executes validation with temporary context and returns the validation result
+ *
+ * @param nestedModel - The instance to validate
+ * @param parentModel - Reference to a parent object for nested validation
+ * @param isAsync - Whether to perform async validation
+ * @returns Validation result from hasErrors()
+ */
+function getNestedValidationErrors(nestedModel, parentModel, isAsync) {
+    // Set temporary context for nested models
+    if (parentModel) {
+        setTemporaryContext(nestedModel, constants_3.VALIDATION_PARENT_KEY, parentModel);
+    }
+    setTemporaryContext(nestedModel, constants_3.ASYNC_META_KEY, !!isAsync);
+    const errs = nestedModel.hasErrors();
+    cleanupTemporaryContext(nestedModel, constants_3.VALIDATION_PARENT_KEY);
+    cleanupTemporaryContext(nestedModel, constants_3.ASYNC_META_KEY);
+    return errs;
+}
+function validateDecorator(model, value, decorator, async) {
+    const validator = Validation_1.Validation.get(decorator.key);
+    if (!validator) {
+        throw new Error(`Missing validator for ${decorator.key}`);
+    }
+    // skip async decorators if validateDecorators is called synchronously (async = false)
+    if (!async && decorator.props.async)
+        return undefined;
+    const decoratorProps = decorator.key === constants_1.ModelKeys.TYPE
+        ? [decorator.props]
+        : decorator.props || {};
+    const context = PathProxy_1.PathProxyEngine.create(model, {
+        ignoreUndefined: true,
+        ignoreNull: true,
+    });
+    const maybeAsyncErrors = validator.hasErrors(value, decoratorProps, context);
+    return (0, utils_1.toConditionalPromise)(maybeAsyncErrors, async);
+}
 /**
- * @summary Analyses the decorations of the properties and validates the obj according to them
+ * @description
+ * Executes validation logic for a set of decorators applied to a model's property, handling both
+ * synchronous and asynchronous validations, including support for nested validations and lists.
+ *
+ * @summary
+ * Iterates over an array of decorator metadata objects and applies each validation rule to the
+ * provided value. For list decorators (`ValidationKeys.LIST`), it performs element-wise validation,
+ * supporting nested model validation and type checks. If the `async` flag is set, asynchronous
+ * validation is supported using `Promise.all`. The result is a record mapping validation keys to
+ * error messages, or `undefined` if no errors are found.
+ *
+ * @template M - A type parameter extending `Model`, representing the model type being validated.
+ * @template Async - A boolean indicating whether validation should be performed asynchronously.
+ *
+ * @param {M} model - The model instance that the validation is associated with.
+ * @param {any} value - The value to be validated against the provided decorators.
+ * @param {DecoratorMetadataAsync[]} decorators - An array of metadata objects representing validation decorators.
+ * @param {Async} [async] - Optional flag indicating whether validation should be performed asynchronously.
  *
- * @typedef M extends Model
- * @prop {M} obj Model object to validate
- * @prop {string[]} [propsToIgnore] object properties to ignore in the validation
+ * @return {ConditionalAsync<Async, Record<string, string>> | undefined}
+ * Returns either a record of validation errors (keyed by the decorator key) or `undefined` if no errors are found.
+ * If `async` is true, the return value is a Promise resolving to the same structure.
  *
+ * @function validateDecorators
+ */
+function validateDecorators(model, value, decorators, async) {
+    const result = {};
+    for (const decorator of decorators) {
+        // skip async decorators if validateDecorators is called synchronously (async = false)
+        if (!async && decorator.props.async)
+            continue;
+        let validationErrors = validateDecorator(model, value, decorator, async);
+        /*
+        If the decorator is a list, each element must be checked.
+        When 'async' is true, the 'err' will always be a pending promise initially,
+        so the '!err' check will evaluate to false (even if the promise later resolves with no errors)
+        */
+        if (decorator.key === constants_2.ValidationKeys.LIST && (!validationErrors || async)) {
+            const values = value instanceof Set ? [...value] : value;
+            if (values && values.length > 0) {
+                const types = decorator.props.class ||
+                    decorator.props.clazz ||
+                    decorator.props.customTypes;
+                const allowedTypes = [types].flat().map((t) => String(t).toLowerCase());
+                // const reserved = Object.values(ReservedModels).map((v) => v.toLowerCase()) as string[];
+                const errs = values.map((childValue) => {
+                    // if (Model.isModel(v) && !reserved.includes(v) {
+                    if (Model_1.Model.isModel(childValue)) {
+                        return getNestedValidationErrors(childValue, model, async);
+                    }
+                    return allowedTypes.includes(typeof childValue)
+                        ? undefined
+                        : "Value has no validatable type";
+                });
+                if (async) {
+                    validationErrors = Promise.all(errs).then((result) => {
+                        const allEmpty = result.every((r) => !r);
+                        return allEmpty ? undefined : result;
+                    });
+                }
+                else {
+                    const allEmpty = errs.every((r) => !r);
+                    validationErrors = errs.length > 0 && !allEmpty ? errs : undefined;
+                }
+            }
+        }
+        if (validationErrors)
+            result[decorator.key] = validationErrors;
+    }
+    if (!async)
+        return Object.keys(result).length > 0
+            ? result
+            : undefined;
+    const keys = Object.keys(result);
+    const promises = Object.values(result);
+    return Promise.all(promises).then((resolvedValues) => {
+        const res = {};
+        for (let i = 0; i < resolvedValues.length; i++) {
+            const val = resolvedValues[i];
+            if (val !== undefined) {
+                res[keys[i]] = val;
+            }
+        }
+        return Object.keys(res).length > 0 ? res : undefined;
+    });
+}
+/**
  * @function validate
+ * @template M
+ * @template Async
  * @memberOf module:decorator-validation
  * @category Model
+ *
+ * @description
+ * Validates the properties of a {@link Model} instance using registered decorators.
+ * Supports both synchronous and asynchronous validation flows, depending on the `async` flag.
+ *
+ * @summary
+ * This function inspects a given model object, identifies decorated properties that require validation,
+ * and applies the corresponding validation rules. It also supports nested model validation and gracefully
+ * merges any validation errors. For collections (Array/Set), it enforces the presence of the `@list` decorator
+ * and checks the type of elements. If a property is a nested model, it will call `hasErrors` on it and flatten
+ * the nested error keys using dot notation.
+ *
+ * @param {M} model - The model instance to be validated. Must extend from {@link Model}.
+ * @param {Async} [async] - A flag indicating whether validation should be asynchronous.
+ * @param {...string} propsToIgnore - A variadic list of property names that should be skipped during validation.
+ *
+ * @returns {ConditionalAsync<Async, ModelErrorDefinition | undefined>}
+ * Returns either a {@link ModelErrorDefinition} containing validation errors,
+ * or `undefined` if no errors are found. When `async` is `true`, returns a Promise.
+ *
+ * @see {@link Model}
+ * @see {@link ModelErrorDefinition}
+ * @see {@link validateDecorators}
+ * @see {@link getValidatableProperties}
+ *
+ * @mermaid
+ * sequenceDiagram
+ *     participant Caller
+ *     participant validate
+ *     participant getValidatableProperties
+ *     participant validateDecorators
+ *     participant ModelInstance
+ *     Caller->>validate: call with obj, async, propsToIgnore
+ *     validate->>getValidatableProperties: retrieve decorated props
+ *     loop for each property
+ *         validate->>validateDecorators: validate using decorators
+ *         alt is nested model
+ *             validate->>ModelInstance: call hasErrors()
+ *         end
+ *     end
+ *     alt async
+ *         validate->>validate: Promise.allSettled for errors
+ *     end
+ *     validate-->>Caller: return ModelErrorDefinition | undefined
  */
-function validate(obj, ...propsToIgnore) {
-    const decoratedProperties = [];
-    for (const prop in obj)
-        if (Object.prototype.hasOwnProperty.call(obj, prop) &&
-            propsToIgnore.indexOf(prop) === -1) {
-            decoratedProperties.push(
-            // @ts-ignore
-            reflection_1.Reflection.getPropertyDecorators(constants_4.ValidationKeys.REFLECT, obj, prop));
-        }
-    let result = undefined;
-    for (const decoratedProperty of decoratedProperties) {
-        const { prop, decorators } = decoratedProperty;
-        if (!decorators || !decorators.length)
+function validate(model, async, ...propsToIgnore) {
+    const decoratedProperties = getValidatableProperties(model, propsToIgnore);
+    const result = {};
+    const nestedErrors = {};
+    for (const { prop, decorators } of decoratedProperties) {
+        const propKey = String(prop);
+        let propValue = model[prop];
+        if (!decorators?.length)
+            continue;
+        // Get the default type validator
+        const designTypeDec = decorators.find((d) => {
+            return [constants_1.ModelKeys.TYPE, constants_2.ValidationKeys.TYPE].includes(d.key);
+        });
+        if (!designTypeDec)
             continue;
-        const defaultTypeDecorator = decorators[0];
-        // tries to find any type decorators or other decorators that already enforce type (the ones with the allowed types property defined). if so, skip the default type verification
-        if (decorators.find((d) => {
-            if (d.key === constants_4.ValidationKeys.TYPE)
-                return true;
-            return !!d.props.types?.find((t) => t === defaultTypeDecorator.props.name);
-        })) {
-            decorators.shift(); // remove the design:type decorator, since the type will already be checked
+        const designType = designTypeDec.props.name;
+        // Handle array or Set types and enforce the presence of @list decorator
+        if ([Array.name, Set.name].includes(designType)) {
+            if (!decorators.some((d) => d.key === constants_2.ValidationKeys.LIST)) {
+                result[propKey] = {
+                    [constants_2.ValidationKeys.TYPE]: `Array or Set property '${propKey}' requires a @list decorator`,
+                };
+                continue;
+            }
+            if (propValue &&
+                !(Array.isArray(propValue) || propValue instanceof Set)) {
+                result[propKey] = {
+                    [constants_2.ValidationKeys.TYPE]: `Property '${String(prop)}' must be either an Array or a Set`,
+                };
+                continue;
+            }
+            // Remove design:type decorator, since @list decorator already ensures type
+            for (let i = decorators.length - 1; i >= 0; i--) {
+                if (decorators[i].key === constants_1.ModelKeys.TYPE) {
+                    decorators.splice(i, 1);
+                }
+            }
+            propValue = propValue instanceof Set ? [...propValue] : propValue;
         }
-        let errs = undefined;
-        for (const decorator of decorators) {
-            const validator = Validation_1.Validation.get(decorator.key);
-            if (!validator) {
-                throw new Error(`Missing validator for ${decorator.key}`);
+        const propErrors = validateDecorators(model, propValue, decorators, async) || {};
+        // Check for nested properties.
+        // To prevent unnecessary processing, "propValue" must be defined and validatable
+        // let nestedErrors: Record<string, any> = {};
+        const isConstr = Model_1.Model.isPropertyModel(model, propKey);
+        // if propValue !== undefined, null
+        if (propValue && isConstr) {
+            const instance = propValue;
+            const isInvalidModel = typeof instance !== "object" ||
+                !instance.hasErrors ||
+                typeof instance.hasErrors !== "function";
+            if (isInvalidModel) {
+                // propErrors[ValidationKeys.TYPE] = "Model should be validatable but it's not.";
+                console.warn("Model should be validatable but it's not.");
             }
-            const decoratorProps = decorator.key === constants_1.ModelKeys.TYPE
-                ? [decorator.props]
-                : decorator.props || {};
-            const err = validator.hasErrors(obj[prop.toString()], decoratorProps, PathProxy_1.PathProxyEngine.create(obj, { ignoreUndefined: true, ignoreNull: true }));
-            if (err) {
-                errs = errs || {};
-                errs[decorator.key] = err;
+            else {
+                nestedErrors[propKey] = getNestedValidationErrors(instance, model, async);
             }
         }
-        if (errs) {
-            result = result || {};
-            result[decoratedProperty.prop.toString()] = errs;
+        // Add to the result if we have any errors
+        // Async mode returns a Promise that resolves to undefined when no errors exist
+        if (Object.keys(propErrors).length > 0 || async)
+            result[propKey] = propErrors;
+        // Then merge any nested errors
+        if (!async) {
+            Object.entries(nestedErrors[propKey] || {}).forEach(([key, error]) => {
+                if (error !== undefined) {
+                    result[`${propKey}.${key}`] = error;
+                }
+            });
         }
     }
-    // tests nested classes
-    for (const prop of Object.keys(obj).filter((k) => !result || !result[k])) {
-        let err;
-        // if a nested Model
-        const allDecorators = reflection_1.Reflection.getPropertyDecorators(constants_4.ValidationKeys.REFLECT, obj, prop).decorators;
-        const decorators = reflection_1.Reflection.getPropertyDecorators(constants_4.ValidationKeys.REFLECT, obj, prop).decorators.filter((d) => [constants_1.ModelKeys.TYPE, constants_4.ValidationKeys.TYPE].indexOf(d.key) !== -1);
-        if (!decorators || !decorators.length)
-            continue;
-        const dec = decorators.pop();
-        const clazz = dec.props.name
-            ? [dec.props.name]
-            : Array.isArray(dec.props.customTypes)
-                ? dec.props.customTypes
-                : [dec.props.customTypes];
-        const reserved = Object.values(constants_2.ReservedModels).map((v) => v.toLowerCase());
-        for (const c of clazz) {
-            if (reserved.indexOf(c.toLowerCase()) === -1) {
-                const typeDecoratorKey = Array.isArray(obj[prop])
-                    ? constants_4.ValidationKeys.LIST
-                    : constants_4.ValidationKeys.TYPE;
-                const types = allDecorators.find((d) => d.key === typeDecoratorKey) || {};
-                let allowedTypes = [];
-                if (types && types.props) {
-                    const customTypes = Array.isArray(obj[prop])
-                        ? types.props.class
-                        : types.props.customTypes;
-                    if (customTypes)
-                        allowedTypes = Array.isArray(customTypes)
-                            ? customTypes.map((t) => `${t}`.toLowerCase())
-                            : [customTypes.toLowerCase()];
-                }
-                const validate = (prop, value) => {
-                    if (typeof value !== "object" && typeof value !== "function")
-                        return undefined;
-                    try {
-                        if (value && !value[constants_3.VALIDATION_PARENT_KEY])
-                            value[constants_3.VALIDATION_PARENT_KEY] = obj; // TODO: freeze?
-                        return Model_1.Model.isModel(value)
-                            ? value.hasErrors()
-                            : allowedTypes.includes(typeof value)
-                                ? undefined
-                                : "Value has no validatable type";
-                    }
-                    finally {
-                        if (value && value[constants_3.VALIDATION_PARENT_KEY])
-                            delete value[constants_3.VALIDATION_PARENT_KEY];
+    // Synchronous return
+    if (!async) {
+        return (Object.keys(result).length > 0
+            ? new ModelErrorDefinition_1.ModelErrorDefinition(result)
+            : undefined);
+    }
+    const merged = result; // TODO: apply filtering
+    const keys = Object.keys(merged);
+    const promises = Object.values(merged);
+    return Promise.allSettled(promises).then(async (results) => {
+        const result = {};
+        for (const [parentProp, nestedErrPromise] of Object.entries(nestedErrors)) {
+            const nestedPropDecErrors = (await nestedErrPromise);
+            if (nestedPropDecErrors)
+                Object.entries(nestedPropDecErrors).forEach(([nestedProp, nestedPropDecError]) => {
+                    if (nestedPropDecError !== undefined) {
+                        const nestedKey = [parentProp, nestedProp].join(".");
+                        result[nestedKey] = nestedPropDecError;
                     }
-                };
-                switch (c) {
-                    case Array.name:
-                    case Set.name:
-                        if (allDecorators.length) {
-                            const listDec = allDecorators.find((d) => d.key === constants_4.ValidationKeys.LIST);
-                            if (listDec) {
-                                err = (c === Array.name
-                                    ? obj[prop]
-                                    : // If it's a Set
-                                        obj[prop].values())
-                                    .map((v) => validate(prop, v))
-                                    .filter((e) => !!e);
-                                if (!err?.length) {
-                                    // if the result is an empty list...
-                                    err = undefined;
-                                }
-                            }
-                        }
-                        break;
-                    default:
-                        try {
-                            if (obj[prop])
-                                err = validate(prop, obj[prop]);
-                        }
-                        catch (e) {
-                            console.warn(`Model should be validatable but its not: ${e}`);
-                        }
-                }
+                });
+        }
+        for (let i = 0; i < results.length; i++) {
+            const key = keys[i];
+            const res = results[i];
+            if (res.status === "fulfilled" && res.value !== undefined) {
+                result[key] = res.value;
             }
-            if (err) {
-                result = result || {};
-                result[prop] = err;
+            else if (res.status === "rejected") {
+                result[key] =
+                    res.reason instanceof Error
+                        ? res.reason.message
+                        : String(res.reason || "Validation failed");
             }
         }
-    }
-    return result ? new ModelErrorDefinition_1.ModelErrorDefinition(result) : undefined;
+        return Object.keys(result).length > 0
+            ? new ModelErrorDefinition_1.ModelErrorDefinition(result)
+            : undefined;
+    });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validation.js","sourceRoot":"","sources":["../../src/model/validation.ts"],"names":[],"mappings":"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","sourcesContent":["import { ModelErrorDefinition } from \"./ModelErrorDefinition\";\nimport {\n  DecoratorMetadata,\n  Reflection,\n  FullPropertyDecoratorList,\n} from \"@decaf-ts/reflection\";\nimport { ModelKeys } from \"../utils/constants\";\nimport { ReservedModels } from \"./constants\";\nimport { VALIDATION_PARENT_KEY } from \"../constants\";\nimport { Validatable } from \"./types\";\nimport { Model } from \"./Model\";\nimport { Validation } from \"../validation/Validation\";\nimport { ValidationKeys } from \"../validation/Validators/constants\";\nimport {\n  ModelErrors,\n  ValidationPropertyDecoratorDefinition,\n  ValidatorOptions,\n} from \"../validation/types\";\nimport { PathProxyEngine } from \"../utils/PathProxy\";\n\n/**\n * @summary Analyses the decorations of the properties and validates the obj according to them\n *\n * @typedef M extends Model\n * @prop {M} obj Model object to validate\n * @prop {string[]} [propsToIgnore] object properties to ignore in the validation\n *\n * @function validate\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function validate<M extends Model>(\n  obj: M,\n  ...propsToIgnore: string[]\n): ModelErrorDefinition | undefined {\n  const decoratedProperties: ValidationPropertyDecoratorDefinition[] = [];\n  for (const prop in obj)\n    if (\n      Object.prototype.hasOwnProperty.call(obj, prop) &&\n      propsToIgnore.indexOf(prop) === -1\n    ) {\n      decoratedProperties.push(\n        // @ts-ignore\n        Reflection.getPropertyDecorators(\n          ValidationKeys.REFLECT,\n          obj,\n          prop\n        ) as FullPropertyDecoratorList\n      );\n    }\n\n  let result: ModelErrors | undefined = undefined;\n\n  for (const decoratedProperty of decoratedProperties) {\n    const { prop, decorators } = decoratedProperty;\n\n    if (!decorators || !decorators.length) continue;\n\n    const defaultTypeDecorator: DecoratorMetadata = decorators[0];\n\n    // tries to find any type decorators or other decorators that already enforce type (the ones with the allowed types property defined). if so, skip the default type verification\n    if (\n      decorators.find((d) => {\n        if (d.key === ValidationKeys.TYPE) return true;\n        return !!d.props.types?.find(\n          (t) => t === defaultTypeDecorator.props.name\n        );\n      })\n    ) {\n      decorators.shift(); // remove the design:type decorator, since the type will already be checked\n    }\n\n    let errs: Record<string, string | undefined> | undefined = undefined;\n\n    for (const decorator of decorators) {\n      const validator = Validation.get(decorator.key);\n      if (!validator) {\n        throw new Error(`Missing validator for ${decorator.key}`);\n      }\n\n      const decoratorProps =\n        decorator.key === ModelKeys.TYPE\n          ? [decorator.props]\n          : decorator.props || {};\n\n      const err: string | undefined = validator.hasErrors(\n        (obj as any)[prop.toString()],\n        decoratorProps as ValidatorOptions,\n        PathProxyEngine.create(obj, { ignoreUndefined: true, ignoreNull: true })\n      );\n\n      if (err) {\n        errs = errs || {};\n        errs[decorator.key] = err;\n      }\n    }\n\n    if (errs) {\n      result = result || {};\n      result[decoratedProperty.prop.toString()] = errs;\n    }\n  }\n\n  // tests nested classes\n  for (const prop of Object.keys(obj).filter((k) => !result || !result[k])) {\n    let err: string | undefined;\n    // if a nested Model\n    const allDecorators = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      obj,\n      prop\n    ).decorators;\n    const decorators = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      obj,\n      prop\n    ).decorators.filter(\n      (d: { key: string }) =>\n        [ModelKeys.TYPE, ValidationKeys.TYPE as string].indexOf(d.key) !== -1\n    );\n    if (!decorators || !decorators.length) continue;\n    const dec = decorators.pop() as DecoratorMetadata;\n    const clazz = dec.props.name\n      ? [dec.props.name]\n      : Array.isArray(dec.props.customTypes)\n        ? dec.props.customTypes\n        : [dec.props.customTypes];\n    const reserved = Object.values(ReservedModels).map((v) =>\n      v.toLowerCase()\n    ) as string[];\n\n    for (const c of clazz) {\n      if (reserved.indexOf(c.toLowerCase()) === -1) {\n        const typeDecoratorKey = Array.isArray((obj as any)[prop])\n          ? ValidationKeys.LIST\n          : ValidationKeys.TYPE;\n        const types: any =\n          allDecorators.find(\n            (d: { key: string }) => d.key === typeDecoratorKey\n          ) || {};\n        let allowedTypes: string[] = [];\n        if (types && types.props) {\n          const customTypes = Array.isArray((obj as any)[prop])\n            ? types.props.class\n            : types.props.customTypes;\n          if (customTypes)\n            allowedTypes = Array.isArray(customTypes)\n              ? customTypes.map((t) => `${t}`.toLowerCase())\n              : [customTypes.toLowerCase()];\n        }\n\n        const validate = (prop: string, value: any): any => {\n          if (typeof value !== \"object\" && typeof value !== \"function\")\n            return undefined;\n\n          try {\n            if (value && !value[VALIDATION_PARENT_KEY])\n              value[VALIDATION_PARENT_KEY] = obj; // TODO: freeze?\n\n            return Model.isModel(value)\n              ? value.hasErrors()\n              : allowedTypes.includes(typeof value)\n                ? undefined\n                : \"Value has no validatable type\";\n          } finally {\n            if (value && value[VALIDATION_PARENT_KEY])\n              delete value[VALIDATION_PARENT_KEY];\n          }\n        };\n\n        switch (c) {\n          case Array.name:\n          case Set.name:\n            if (allDecorators.length) {\n              const listDec = allDecorators.find(\n                (d: { key: string }) => d.key === ValidationKeys.LIST\n              );\n              if (listDec) {\n                err = (\n                  c === Array.name\n                    ? (obj as Record<string, any>)[prop]\n                    : // If it's a Set\n                      (obj as Record<string, any>)[prop].values()\n                )\n                  .map((v: Validatable) => validate(prop, v))\n                  .filter((e: any) => !!e) as any;\n                if (!err?.length) {\n                  // if the result is an empty list...\n                  err = undefined;\n                }\n              }\n            }\n            break;\n          default:\n            try {\n              if ((obj as Record<string, any>)[prop])\n                err = validate(prop, (obj as any)[prop]);\n            } catch (e: unknown) {\n              console.warn(`Model should be validatable but its not: ${e}`);\n            }\n        }\n      }\n      if (err) {\n        result = result || {};\n        result[prop] = err as any;\n      }\n    }\n  }\n\n  return result ? new ModelErrorDefinition(result) : undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validation.js","sourceRoot":"","sources":["../../src/model/validation.ts"],"names":[],"mappings":"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","sourcesContent":["import { ModelErrorDefinition } from \"./ModelErrorDefinition\";\nimport { ModelKeys } from \"../utils/constants\";\nimport { Model } from \"./Model\";\nimport { Validation } from \"../validation/Validation\";\nimport { ValidationKeys } from \"../validation/Validators/constants\";\nimport {\n  ModelErrors,\n  ValidationPropertyDecoratorDefinition,\n  ValidatorOptions,\n} from \"../validation\";\nimport { PathProxyEngine } from \"../utils/PathProxy\";\nimport { ASYNC_META_KEY, VALIDATION_PARENT_KEY } from \"../constants\";\nimport { ConditionalAsync, DecoratorMetadataAsync } from \"../types\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { toConditionalPromise } from \"./utils\";\n\n/**\n * Retrieves the validation metadata decorators associated with a specific property of a model,\n * using the reflective metadata key.\n *\n * @param model - The model instance or class containing the decorated property.\n * @param {string} prop - The name of the property whose decorators should be retrieved.\n * @param {string} reflectKey - The metadata key used to retrieve the decorators.\n *                     Defaults to `ValidationKeys.REFLECT`.\n *\n * @returns The validation decorators applied to the property\n */\nexport function getValidationDecorators(\n  model: Record<string, any>,\n  prop: string,\n  reflectKey: string = ValidationKeys.REFLECT\n): ValidationPropertyDecoratorDefinition {\n  return Reflection.getPropertyDecorators(\n    reflectKey,\n    model,\n    prop\n  ) as unknown as ValidationPropertyDecoratorDefinition;\n}\n\n/**\n * @description\n * Retrieves all validatable property decorators from a given model, excluding specified properties.\n *\n * @summary\n * Iterates through the own enumerable properties of a model instance, filtering out any properties\n * listed in the `propsToIgnore` array. For each remaining property, it checks whether validation\n * decorators are present using `getValidationDecorators`, and if so, collects them in the result array.\n *\n * @template M - A generic parameter extending the `Model` class, representing the model type being inspected.\n *\n * @param {M} model - An instance of a class extending `Model` from which validatable properties will be extracted.\n * @param {string[]} propsToIgnore - An array of property names that should be excluded from validation inspection.\n *\n * @return {ValidationPropertyDecoratorDefinition[]} An array of validation decorator definitions\n * associated with the model's properties, excluding those listed in `propsToIgnore`.\n *\n * @function getValidatableProperties\n */\nexport function getValidatableProperties<M extends Model>(\n  model: M,\n  propsToIgnore: string[]\n): ValidationPropertyDecoratorDefinition[] {\n  const decoratedProperties: ValidationPropertyDecoratorDefinition[] = [];\n\n  for (const prop in model) {\n    if (\n      Object.prototype.hasOwnProperty.call(model, prop) &&\n      !propsToIgnore.includes(prop)\n    ) {\n      const dec = getValidationDecorators(model, prop);\n      if (dec) decoratedProperties.push(dec);\n    }\n  }\n\n  return decoratedProperties;\n}\n\n/**\n * Safely sets temporary metadata on an object\n */\nfunction setTemporaryContext(\n  target: any,\n  key: symbol | string,\n  value: unknown\n): void {\n  if (!Object.hasOwnProperty.call(target, key)) target[key] = value;\n}\n\n/**\n * Safely removes temporary metadata from an object\n */\nfunction cleanupTemporaryContext(target: any, key: symbol | string): void {\n  if (Object.hasOwnProperty.call(target, key)) delete target[key];\n}\n\n/**\n * Executes validation with temporary context and returns the validation result\n *\n * @param nestedModel - The instance to validate\n * @param parentModel - Reference to a parent object for nested validation\n * @param isAsync - Whether to perform async validation\n * @returns Validation result from hasErrors()\n */\nfunction getNestedValidationErrors<\n  M extends Model,\n  Async extends boolean = false,\n>(\n  nestedModel: M,\n  parentModel?: M,\n  isAsync?: Async\n): ConditionalAsync<Async, ModelErrorDefinition | undefined> {\n  // Set temporary context for nested models\n  if (parentModel) {\n    setTemporaryContext(nestedModel, VALIDATION_PARENT_KEY, parentModel);\n  }\n  setTemporaryContext(nestedModel, ASYNC_META_KEY, !!isAsync);\n\n  const errs = nestedModel.hasErrors();\n  cleanupTemporaryContext(nestedModel, VALIDATION_PARENT_KEY);\n  cleanupTemporaryContext(nestedModel, ASYNC_META_KEY);\n  return errs as any;\n}\n\nexport function validateDecorator<\n  M extends Model,\n  Async extends boolean = false,\n>(\n  model: M,\n  value: any,\n  decorator: DecoratorMetadataAsync,\n  async?: Async\n): ConditionalAsync<Async, string | undefined> {\n  const validator = Validation.get(decorator.key);\n  if (!validator) {\n    throw new Error(`Missing validator for ${decorator.key}`);\n  }\n\n  // skip async decorators if validateDecorators is called synchronously (async = false)\n  if (!async && decorator.props.async) return undefined as any;\n\n  const decoratorProps =\n    decorator.key === ModelKeys.TYPE\n      ? [decorator.props]\n      : decorator.props || {};\n\n  const context = PathProxyEngine.create(model, {\n    ignoreUndefined: true,\n    ignoreNull: true,\n  });\n\n  const maybeAsyncErrors = validator.hasErrors(\n    value,\n    decoratorProps as ValidatorOptions,\n    context\n  );\n\n  return toConditionalPromise(maybeAsyncErrors, async);\n}\n\n/**\n * @description\n * Executes validation logic for a set of decorators applied to a model's property, handling both\n * synchronous and asynchronous validations, including support for nested validations and lists.\n *\n * @summary\n * Iterates over an array of decorator metadata objects and applies each validation rule to the\n * provided value. For list decorators (`ValidationKeys.LIST`), it performs element-wise validation,\n * supporting nested model validation and type checks. If the `async` flag is set, asynchronous\n * validation is supported using `Promise.all`. The result is a record mapping validation keys to\n * error messages, or `undefined` if no errors are found.\n *\n * @template M - A type parameter extending `Model`, representing the model type being validated.\n * @template Async - A boolean indicating whether validation should be performed asynchronously.\n *\n * @param {M} model - The model instance that the validation is associated with.\n * @param {any} value - The value to be validated against the provided decorators.\n * @param {DecoratorMetadataAsync[]} decorators - An array of metadata objects representing validation decorators.\n * @param {Async} [async] - Optional flag indicating whether validation should be performed asynchronously.\n *\n * @return {ConditionalAsync<Async, Record<string, string>> | undefined}\n * Returns either a record of validation errors (keyed by the decorator key) or `undefined` if no errors are found.\n * If `async` is true, the return value is a Promise resolving to the same structure.\n *\n * @function validateDecorators\n */\nexport function validateDecorators<\n  M extends Model,\n  Async extends boolean = false,\n>(\n  model: M,\n  value: any,\n  decorators: DecoratorMetadataAsync[],\n  async?: Async\n): ConditionalAsync<Async, Record<string, string> | undefined> {\n  const result: Record<string, string | Promise<string>> = {};\n\n  for (const decorator of decorators) {\n    // skip async decorators if validateDecorators is called synchronously (async = false)\n    if (!async && decorator.props.async) continue;\n\n    let validationErrors = validateDecorator(model, value, decorator, async);\n\n    /*\n    If the decorator is a list, each element must be checked.\n    When 'async' is true, the 'err' will always be a pending promise initially,\n    so the '!err' check will evaluate to false (even if the promise later resolves with no errors)\n    */\n    if (decorator.key === ValidationKeys.LIST && (!validationErrors || async)) {\n      const values = value instanceof Set ? [...value] : value;\n      if (values && values.length > 0) {\n        const types =\n          decorator.props.class ||\n          decorator.props.clazz ||\n          decorator.props.customTypes;\n\n        const allowedTypes = [types].flat().map((t) => String(t).toLowerCase());\n        // const reserved = Object.values(ReservedModels).map((v) => v.toLowerCase()) as string[];\n\n        const errs = values.map((childValue: any) => {\n          // if (Model.isModel(v) && !reserved.includes(v) {\n          if (Model.isModel(childValue)) {\n            return getNestedValidationErrors(childValue, model, async);\n          }\n\n          return allowedTypes.includes(typeof childValue)\n            ? undefined\n            : \"Value has no validatable type\";\n        });\n\n        if (async) {\n          validationErrors = Promise.all(errs).then((result) => {\n            const allEmpty = result.every((r) => !r);\n            return allEmpty ? undefined : result;\n          }) as any;\n        } else {\n          const allEmpty = errs.every((r: string | undefined) => !r);\n          validationErrors = errs.length > 0 && !allEmpty ? errs : undefined;\n        }\n      }\n    }\n\n    if (validationErrors) (result as any)[decorator.key] = validationErrors;\n  }\n\n  if (!async)\n    return Object.keys(result).length > 0\n      ? (result as any)\n      : (undefined as any);\n\n  const keys = Object.keys(result);\n  const promises = Object.values(result) as Promise<string | undefined>[];\n  return Promise.all(promises).then((resolvedValues) => {\n    const res: Record<string, string> = {};\n    for (let i = 0; i < resolvedValues.length; i++) {\n      const val = resolvedValues[i];\n      if (val !== undefined) {\n        res[keys[i]] = val;\n      }\n    }\n    return Object.keys(res).length > 0 ? res : undefined;\n  }) as any;\n}\n\n/**\n * @function validate\n * @template M\n * @template Async\n * @memberOf module:decorator-validation\n * @category Model\n *\n * @description\n * Validates the properties of a {@link Model} instance using registered decorators.\n * Supports both synchronous and asynchronous validation flows, depending on the `async` flag.\n *\n * @summary\n * This function inspects a given model object, identifies decorated properties that require validation,\n * and applies the corresponding validation rules. It also supports nested model validation and gracefully\n * merges any validation errors. For collections (Array/Set), it enforces the presence of the `@list` decorator\n * and checks the type of elements. If a property is a nested model, it will call `hasErrors` on it and flatten\n * the nested error keys using dot notation.\n *\n * @param {M} model - The model instance to be validated. Must extend from {@link Model}.\n * @param {Async} [async] - A flag indicating whether validation should be asynchronous.\n * @param {...string} propsToIgnore - A variadic list of property names that should be skipped during validation.\n *\n * @returns {ConditionalAsync<Async, ModelErrorDefinition | undefined>}\n * Returns either a {@link ModelErrorDefinition} containing validation errors,\n * or `undefined` if no errors are found. When `async` is `true`, returns a Promise.\n *\n * @see {@link Model}\n * @see {@link ModelErrorDefinition}\n * @see {@link validateDecorators}\n * @see {@link getValidatableProperties}\n *\n * @mermaid\n * sequenceDiagram\n *     participant Caller\n *     participant validate\n *     participant getValidatableProperties\n *     participant validateDecorators\n *     participant ModelInstance\n *     Caller->>validate: call with obj, async, propsToIgnore\n *     validate->>getValidatableProperties: retrieve decorated props\n *     loop for each property\n *         validate->>validateDecorators: validate using decorators\n *         alt is nested model\n *             validate->>ModelInstance: call hasErrors()\n *         end\n *     end\n *     alt async\n *         validate->>validate: Promise.allSettled for errors\n *     end\n *     validate-->>Caller: return ModelErrorDefinition | undefined\n */\nexport function validate<\n  M extends Model<boolean>,\n  Async extends boolean = false,\n>(\n  model: M,\n  async: Async,\n  ...propsToIgnore: string[]\n): ConditionalAsync<Async, ModelErrorDefinition | undefined> {\n  const decoratedProperties: ValidationPropertyDecoratorDefinition[] =\n    getValidatableProperties(model, propsToIgnore);\n\n  const result: Record<string, any> = {};\n  const nestedErrors: Record<string, any> = {};\n\n  for (const { prop, decorators } of decoratedProperties) {\n    const propKey = String(prop);\n    let propValue = (model as any)[prop];\n\n    if (!decorators?.length) continue;\n\n    // Get the default type validator\n    const designTypeDec = decorators.find((d) => {\n      return [ModelKeys.TYPE, ValidationKeys.TYPE].includes(d.key as any);\n    });\n\n    if (!designTypeDec) continue;\n\n    const designType = designTypeDec.props.name;\n\n    // Handle array or Set types and enforce the presence of @list decorator\n    if ([Array.name, Set.name].includes(designType)) {\n      if (!decorators.some((d) => d.key === ValidationKeys.LIST)) {\n        result[propKey] = {\n          [ValidationKeys.TYPE]: `Array or Set property '${propKey}' requires a @list decorator`,\n        };\n        continue;\n      }\n\n      if (\n        propValue &&\n        !(Array.isArray(propValue) || propValue instanceof Set)\n      ) {\n        result[propKey] = {\n          [ValidationKeys.TYPE]: `Property '${String(prop)}' must be either an Array or a Set`,\n        };\n        continue;\n      }\n\n      // Remove design:type decorator, since @list decorator already ensures type\n      for (let i = decorators.length - 1; i >= 0; i--) {\n        if (decorators[i].key === ModelKeys.TYPE) {\n          decorators.splice(i, 1);\n        }\n      }\n      propValue = propValue instanceof Set ? [...propValue] : propValue;\n    }\n\n    const propErrors: Record<string, any> =\n      validateDecorators(model, propValue, decorators, async) || {};\n\n    // Check for nested properties.\n    // To prevent unnecessary processing, \"propValue\" must be defined and validatable\n    // let nestedErrors: Record<string, any> = {};\n    const isConstr = Model.isPropertyModel(model, propKey);\n    // if propValue !== undefined, null\n    if (propValue && isConstr) {\n      const instance: Model = propValue;\n      const isInvalidModel =\n        typeof instance !== \"object\" ||\n        !instance.hasErrors ||\n        typeof instance.hasErrors !== \"function\";\n\n      if (isInvalidModel) {\n        // propErrors[ValidationKeys.TYPE] = \"Model should be validatable but it's not.\";\n        console.warn(\"Model should be validatable but it's not.\");\n      } else {\n        nestedErrors[propKey] = getNestedValidationErrors(\n          instance,\n          model,\n          async\n        );\n      }\n    }\n\n    // Add to the result if we have any errors\n    // Async mode returns a Promise that resolves to undefined when no errors exist\n    if (Object.keys(propErrors).length > 0 || async)\n      result[propKey] = propErrors;\n\n    // Then merge any nested errors\n    if (!async) {\n      Object.entries(nestedErrors[propKey] || {}).forEach(([key, error]) => {\n        if (error !== undefined) {\n          result[`${propKey}.${key}`] = error;\n        }\n      });\n    }\n  }\n\n  // Synchronous return\n  if (!async) {\n    return (\n      Object.keys(result).length > 0\n        ? new ModelErrorDefinition(result)\n        : undefined\n    ) as any;\n  }\n\n  const merged: any = result; // TODO: apply filtering\n\n  const keys = Object.keys(merged);\n  const promises = Object.values(merged);\n  return Promise.allSettled(promises).then(async (results) => {\n    const result: ModelErrors = {};\n\n    for (const [parentProp, nestedErrPromise] of Object.entries(nestedErrors)) {\n      const nestedPropDecErrors = (await nestedErrPromise) as Record<\n        string,\n        any\n      >;\n\n      if (nestedPropDecErrors)\n        Object.entries(nestedPropDecErrors).forEach(\n          ([nestedProp, nestedPropDecError]) => {\n            if (nestedPropDecError !== undefined) {\n              const nestedKey = [parentProp, nestedProp].join(\".\");\n              result[nestedKey] = nestedPropDecError;\n            }\n          }\n        );\n    }\n\n    for (let i = 0; i < results.length; i++) {\n      const key = keys[i];\n      const res = results[i];\n\n      if (res.status === \"fulfilled\" && res.value !== undefined) {\n        (result as any)[key] = res.value;\n      } else if (res.status === \"rejected\") {\n        (result as any)[key] =\n          res.reason instanceof Error\n            ? res.reason.message\n            : String(res.reason || \"Validation failed\");\n      }\n    }\n\n    return Object.keys(result).length > 0\n      ? new ModelErrorDefinition(result)\n      : undefined;\n  }) as any;\n}\n"]}