@decaf-ts/db-decorators 0.6.2 → 0.6.3

package/lib/esm/index.d.ts

@@ -15,4 +15,4 @@ export * from "./validation";
  * @const VERSION
  * @memberOf module:db-decorators
  */
-export declare const VERSION = "0.6.2";
+export declare const VERSION = "0.6.3";

package/lib/esm/index.js

@@ -15,5 +15,5 @@ export * from "./validation/index.js";
  * @const VERSION
  * @memberOf module:db-decorators
  */
-export const VERSION = "0.6.2";
+export const VERSION = "0.6.3";
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0NBQTJCO0FBQzNCLHNDQUE2QjtBQUM3QixpQ0FBd0I7QUFDeEIsc0NBQTZCO0FBQzdCLHNDQUE2QjtBQUM3QixzQ0FBNkI7QUFFN0I7Ozs7R0FJRztBQUdIOzs7OztHQUtHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2lkZW50aXR5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9pbnRlcmZhY2VzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9tb2RlbFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vb3BlcmF0aW9uc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcmVwb3NpdG9yeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdmFsaWRhdGlvblwiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBEYXRhYmFzZSBkZWNvcmF0b3JzIGZvciBUeXBlU2NyaXB0IGFwcGxpY2F0aW9uc1xuICogQHN1bW1hcnkgQSBjb21wcmVoZW5zaXZlIGxpYnJhcnkgcHJvdmlkaW5nIGRlY29yYXRvcnMgYW5kIHV0aWxpdGllcyBmb3IgZGF0YWJhc2Ugb3BlcmF0aW9ucywgbW9kZWwgZGVmaW5pdGlvbnMsIHZhbGlkYXRpb24sIGFuZCByZXBvc2l0b3J5IHBhdHRlcm5zIGluIFR5cGVTY3JpcHQgYXBwbGljYXRpb25zXG4gKiBAbW9kdWxlIGRiLWRlY29yYXRvcnNcbiAqL1xuXG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEN1cnJlbnQgdmVyc2lvbiBvZiB0aGUgcmVmbGVjdGlvbiBwYWNrYWdlXG4gKiBAc3VtbWFyeSBTdG9yZXMgdGhlIHNlbWFudGljIHZlcnNpb24gbnVtYmVyIG9mIHRoZSBwYWNrYWdlXG4gKiBAY29uc3QgVkVSU0lPTlxuICogQG1lbWJlck9mIG1vZHVsZTpkYi1kZWNvcmF0b3JzXG4gKi9cbmV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIjI1ZFUlNJT04jI1wiO1xuIl19

package/lib/esm/model/overrides.js

@@ -1,4 +1,5 @@
 import { Model, validate, } from "@decaf-ts/decorator-validation";
+import { validateCompare } from "./validation.js";
 /**
  * @description Validates the model and checks for errors
  * @summary Validates the current model state and optionally compares with a previous version
@@ -9,15 +10,25 @@ import { Model, validate, } from "@decaf-ts/decorator-validation";
  * @function hasErrors
  * @memberOf module:db-decorators
  */
-import { validateCompare } from "./validation.js";
+// @ts-expect-error Overriding Model prototype method with dynamic conditional return type.
 Model.prototype.hasErrors = function (previousVersion, ...exclusions) {
     if (previousVersion && !(previousVersion instanceof Model)) {
         exclusions.unshift(previousVersion);
         previousVersion = undefined;
     }
-    const errs = validate(this, ...exclusions);
+    const async = this.isAsync();
+    const errs = validate(this, async, ...exclusions);
+    if (async) {
+        return Promise.resolve(errs).then((resolvedErrs) => {
+            if (resolvedErrs || !previousVersion) {
+                return resolvedErrs;
+            }
+            return validateCompare(previousVersion, this, async, ...exclusions);
+        });
+    }
     if (errs || !previousVersion)
         return errs;
-    return validateCompare(previousVersion, this, ...exclusions);
+    // @ts-expect-error Overriding Model prototype method with dynamic conditional return type.
+    return validateCompare(previousVersion, this, async, ...exclusions);
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcnJpZGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21vZGVsL292ZXJyaWRlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsS0FBSyxFQUVMLFFBQVEsR0FDVCxNQUFNLGdDQUFnQyxDQUFDO0FBQ3hDLE9BQU8sRUFBRSxlQUFlLEVBQUUsd0JBQXFCO0FBRS9DOzs7Ozs7Ozs7R0FTRztBQUNILDJGQUEyRjtBQUMzRixLQUFLLENBQUMsU0FBUyxDQUFDLFNBQVMsR0FBRyxVQUUxQixlQUF5QixFQUN6QixHQUFHLFVBQWlCO0lBRXBCLElBQUksZUFBZSxJQUFJLENBQUMsQ0FBQyxlQUFlLFlBQVksS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUMzRCxVQUFVLENBQUMsT0FBTyxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBQ3BDLGVBQWUsR0FBRyxTQUFTLENBQUM7SUFDOUIsQ0FBQztJQUVELE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUM3QixNQUFNLElBQUksR0FBRyxRQUFRLENBQUMsSUFBSSxFQUFFLEtBQUssRUFBRSxHQUFHLFVBQVUsQ0FBQyxDQUFDO0lBRWxELElBQUksS0FBSyxFQUFFLENBQUM7UUFDVixPQUFPLE9BQU8sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsWUFBWSxFQUFFLEVBQUU7WUFDakQsSUFBSSxZQUFZLElBQUksQ0FBQyxlQUFlLEVBQUUsQ0FBQztnQkFDckMsT0FBTyxZQUFZLENBQUM7WUFDdEIsQ0FBQztZQUNELE9BQU8sZUFBZSxDQUFDLGVBQWUsRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLEdBQUcsVUFBVSxDQUFDLENBQUM7UUFDdEUsQ0FBQyxDQUFRLENBQUM7SUFDWixDQUFDO0lBRUQsSUFBSSxJQUFJLElBQUksQ0FBQyxlQUFlO1FBQUUsT0FBTyxJQUFXLENBQUM7SUFFakQsMkZBQTJGO0lBQzNGLE9BQU8sZUFBZSxDQUFDLGVBQWUsRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLEdBQUcsVUFBVSxDQUFDLENBQUM7QUFDdEUsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgTW9kZWwsXG4gIE1vZGVsQ29uZGl0aW9uYWxBc3luYyxcbiAgdmFsaWRhdGUsXG59IGZyb20gXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIjtcbmltcG9ydCB7IHZhbGlkYXRlQ29tcGFyZSB9IGZyb20gXCIuL3ZhbGlkYXRpb25cIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gVmFsaWRhdGVzIHRoZSBtb2RlbCBhbmQgY2hlY2tzIGZvciBlcnJvcnNcbiAqIEBzdW1tYXJ5IFZhbGlkYXRlcyB0aGUgY3VycmVudCBtb2RlbCBzdGF0ZSBhbmQgb3B0aW9uYWxseSBjb21wYXJlcyB3aXRoIGEgcHJldmlvdXMgdmVyc2lvblxuICogQHRlbXBsYXRlIE0gLSBUeXBlIGV4dGVuZGluZyBNb2RlbFxuICogQHBhcmFtIHtNfGFueX0gW3ByZXZpb3VzVmVyc2lvbl0gLSBPcHRpb25hbCBwcmV2aW91cyB2ZXJzaW9uIG9mIHRoZSBtb2RlbCBmb3IgY29tcGFyaXNvblxuICogQHBhcmFtIHsuLi5hbnlbXX0gZXhjbHVzaW9ucyAtIFByb3BlcnRpZXMgdG8gZXhjbHVkZSBmcm9tIHZhbGlkYXRpb25cbiAqIEByZXR1cm4ge01vZGVsRXJyb3JEZWZpbml0aW9ufHVuZGVmaW5lZH0gRXJyb3IgZGVmaW5pdGlvbiBpZiB2YWxpZGF0aW9uIGZhaWxzLCB1bmRlZmluZWQgb3RoZXJ3aXNlXG4gKiBAZnVuY3Rpb24gaGFzRXJyb3JzXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmRiLWRlY29yYXRvcnNcbiAqL1xuLy8gQHRzLWV4cGVjdC1lcnJvciBPdmVycmlkaW5nIE1vZGVsIHByb3RvdHlwZSBtZXRob2Qgd2l0aCBkeW5hbWljIGNvbmRpdGlvbmFsIHJldHVybiB0eXBlLlxuTW9kZWwucHJvdG90eXBlLmhhc0Vycm9ycyA9IGZ1bmN0aW9uIDxNIGV4dGVuZHMgTW9kZWw8Ym9vbGVhbj4+KFxuICB0aGlzOiBNLFxuICBwcmV2aW91c1ZlcnNpb24/OiBNIHwgYW55LFxuICAuLi5leGNsdXNpb25zOiBhbnlbXVxuKTogTW9kZWxDb25kaXRpb25hbEFzeW5jPE0+IHtcbiAgaWYgKHByZXZpb3VzVmVyc2lvbiAmJiAhKHByZXZpb3VzVmVyc2lvbiBpbnN0YW5jZW9mIE1vZGVsKSkge1xuICAgIGV4Y2x1c2lvbnMudW5zaGlmdChwcmV2aW91c1ZlcnNpb24pO1xuICAgIHByZXZpb3VzVmVyc2lvbiA9IHVuZGVmaW5lZDtcbiAgfVxuXG4gIGNvbnN0IGFzeW5jID0gdGhpcy5pc0FzeW5jKCk7XG4gIGNvbnN0IGVycnMgPSB2YWxpZGF0ZSh0aGlzLCBhc3luYywgLi4uZXhjbHVzaW9ucyk7XG5cbiAgaWYgKGFzeW5jKSB7XG4gICAgcmV0dXJuIFByb21pc2UucmVzb2x2ZShlcnJzKS50aGVuKChyZXNvbHZlZEVycnMpID0+IHtcbiAgICAgIGlmIChyZXNvbHZlZEVycnMgfHwgIXByZXZpb3VzVmVyc2lvbikge1xuICAgICAgICByZXR1cm4gcmVzb2x2ZWRFcnJzO1xuICAgICAgfVxuICAgICAgcmV0dXJuIHZhbGlkYXRlQ29tcGFyZShwcmV2aW91c1ZlcnNpb24sIHRoaXMsIGFzeW5jLCAuLi5leGNsdXNpb25zKTtcbiAgICB9KSBhcyBhbnk7XG4gIH1cblxuICBpZiAoZXJycyB8fCAhcHJldmlvdXNWZXJzaW9uKSByZXR1cm4gZXJycyBhcyBhbnk7XG5cbiAgLy8gQHRzLWV4cGVjdC1lcnJvciBPdmVycmlkaW5nIE1vZGVsIHByb3RvdHlwZSBtZXRob2Qgd2l0aCBkeW5hbWljIGNvbmRpdGlvbmFsIHJldHVybiB0eXBlLlxuICByZXR1cm4gdmFsaWRhdGVDb21wYXJlKHByZXZpb3VzVmVyc2lvbiwgdGhpcywgYXN5bmMsIC4uLmV4Y2x1c2lvbnMpO1xufTtcbiJdfQ==

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

@@ -1,10 +1,35 @@
-import { Model, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
+import { ConditionalAsync, DecoratorMetadataAsync, Model, ModelConditionalAsync, ValidationPropertyDecoratorDefinition } from "@decaf-ts/decorator-validation";
+/**
+ * @description
+ * Retrieves validation decorator definitions from a model for update operations, including
+ * support for special handling of list decorators.
+ *
+ * @summary
+ * Iterates over the model's own enumerable properties and filters out those specified in the
+ * `propsToIgnore` array. For each remaining property, retrieves validation decorators specific
+ * to update operations using the `UpdateValidationKeys.REFLECT` key. Additionally, it explicitly
+ * checks for and appends any `LIST` type decorators to ensure proper validation of collection types.
+ *
+ * @template M - A generic parameter extending the `Model` class, representing the model type being inspected.
+ *
+ * @param {M} model - The model instance whose properties are being inspected for update-related validations.
+ * @param {string[]} propsToIgnore - A list of property names to exclude from the validation decorator retrieval process.
+ *
+ * @return {ValidationPropertyDecoratorDefinition[]} An array of validation decorator definitions, including both
+ * update-specific and list-type decorators, excluding those for ignored properties.
+ *
+ * @function getValidatableUpdateProps
+ */
+export declare function getValidatableUpdateProps<M extends Model>(model: M, propsToIgnore: string[]): ValidationPropertyDecoratorDefinition[];
+export declare function validateDecorator<M extends Model, Async extends boolean = false>(newModel: M, oldModel: M, prop: string, decorator: DecoratorMetadataAsync, async?: Async): ConditionalAsync<Async, string | undefined>;
+export declare function validateDecorators<M extends Model, Async extends boolean = false>(newModel: M, oldModel: M, prop: string, decorators: DecoratorMetadataAsync[], async?: Async): ConditionalAsync<Async, Record<string, string>> | undefined;
 /**
  * @description Validates changes between two model versions
  * @summary Compares an old and new model version to validate update operations
  * @template M - Type extending Model
  * @param {M} oldModel - The original model version
  * @param {M} newModel - The updated model version
+ * @param {boolean} async - A flag indicating whether validation should be asynchronous.
  * @param {...string[]} exceptions - Properties to exclude from validation
  * @return {ModelErrorDefinition|undefined} Error definition if validation fails, undefined otherwise
  * @function validateCompare
@@ -29,4 +54,4 @@ import { Model, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
  *   end
  *   validateCompare-->>Caller: validation errors or undefined
  */
-export declare function validateCompare<M extends Model>(oldModel: M, newModel: M, ...exceptions: string[]): ModelErrorDefinition | undefined;
+export declare function validateCompare<M extends Model<any>>(oldModel: M, newModel: M, async: boolean, ...exceptions: string[]): ModelConditionalAsync<M>;

package/lib/esm/model/validation.js

@@ -1,13 +1,133 @@
-import { ModelErrorDefinition, ModelKeys, ReservedModels, sf, Validation, ValidationKeys, } from "@decaf-ts/decorator-validation";
+import { getValidationDecorators, Model, ModelErrorDefinition, ModelKeys, toConditionalPromise, Validation, ValidationKeys, } from "@decaf-ts/decorator-validation";
 import { Reflection } from "@decaf-ts/reflection";
 import { UpdateValidationKeys } from "./../validation/index.js";
 import { findModelId } from "./../identity/index.js";
+/**
+ * @description
+ * Retrieves validation decorator definitions from a model for update operations, including
+ * support for special handling of list decorators.
+ *
+ * @summary
+ * Iterates over the model's own enumerable properties and filters out those specified in the
+ * `propsToIgnore` array. For each remaining property, retrieves validation decorators specific
+ * to update operations using the `UpdateValidationKeys.REFLECT` key. Additionally, it explicitly
+ * checks for and appends any `LIST` type decorators to ensure proper validation of collection types.
+ *
+ * @template M - A generic parameter extending the `Model` class, representing the model type being inspected.
+ *
+ * @param {M} model - The model instance whose properties are being inspected for update-related validations.
+ * @param {string[]} propsToIgnore - A list of property names to exclude from the validation decorator retrieval process.
+ *
+ * @return {ValidationPropertyDecoratorDefinition[]} An array of validation decorator definitions, including both
+ * update-specific and list-type decorators, excluding those for ignored properties.
+ *
+ * @function getValidatableUpdateProps
+ */
+export function getValidatableUpdateProps(model, propsToIgnore) {
+    const decoratedProperties = [];
+    for (const prop in model) {
+        if (Object.prototype.hasOwnProperty.call(model, prop) &&
+            !propsToIgnore.includes(prop)) {
+            const validationPropertyDefinition = getValidationDecorators(model, prop, UpdateValidationKeys.REFLECT);
+            const listDecorator = getValidationDecorators(model, prop).decorators.find(({ key }) => key === ValidationKeys.LIST);
+            if (listDecorator)
+                validationPropertyDefinition.decorators.push(listDecorator);
+            decoratedProperties.push(validationPropertyDefinition);
+        }
+    }
+    return decoratedProperties;
+}
+export function validateDecorator(newModel, oldModel, prop, decorator, async) {
+    const validator = Validation.get(decorator.key);
+    if (!validator) {
+        throw new Error(`Missing validator for ${decorator.key}`);
+    }
+    // Skip validators that aren't UpdateValidators
+    if (!validator.updateHasErrors)
+        return toConditionalPromise(undefined, async);
+    // skip async decorators if validateDecorators is called synchronously (async = false)
+    if (!async && decorator.props.async)
+        return toConditionalPromise(undefined, async);
+    const decoratorProps = Object.values(decorator.props) || {};
+    // const context = PathProxyEngine.create(obj, {
+    //   ignoreUndefined: true,
+    //   ignoreNull: true,
+    // });
+    const maybeError = validator.updateHasErrors(newModel[prop], oldModel[prop], ...decoratorProps);
+    return toConditionalPromise(maybeError, async);
+}
+export function validateDecorators(newModel, oldModel, prop, 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(newModel, oldModel, prop, 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 === ValidationKeys.LIST && (!validationErrors || async)) {
+            const newPropValue = newModel[prop];
+            const oldPropValue = oldModel[prop];
+            const newValues = newPropValue instanceof Set ? [...newPropValue] : newPropValue;
+            const oldValues = oldPropValue instanceof Set ? [...oldPropValue] : oldPropValue;
+            if (newValues && newValues.length > 0) {
+                const types = decorator.props.class ||
+                    decorator.props.clazz ||
+                    decorator.props.customTypes;
+                const allowedTypes = [types].flat().map((t) => String(t).toLowerCase());
+                const errs = newValues.map((childValue) => {
+                    // find by id so the list elements order doesn't matter
+                    const id = findModelId(childValue, true);
+                    if (!id)
+                        return "Failed to find model id";
+                    const oldModel = oldValues.find((el) => id === findModelId(el, true));
+                    if (Model.isModel(childValue)) {
+                        return childValue.hasErrors(oldModel);
+                    }
+                    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;
+    });
+}
 /**
  * @description Validates changes between two model versions
  * @summary Compares an old and new model version to validate update operations
  * @template M - Type extending Model
  * @param {M} oldModel - The original model version
  * @param {M} newModel - The updated model version
+ * @param {boolean} async - A flag indicating whether validation should be asynchronous.
  * @param {...string[]} exceptions - Properties to exclude from validation
  * @return {ModelErrorDefinition|undefined} Error definition if validation fails, undefined otherwise
  * @function validateCompare
@@ -32,112 +152,113 @@ import { findModelId } from "./../identity/index.js";
  *   end
  *   validateCompare-->>Caller: validation errors or undefined
  */
-export function validateCompare(oldModel, newModel, ...exceptions) {
-    const decoratedProperties = [];
-    for (const prop in newModel)
-        if (Object.prototype.hasOwnProperty.call(newModel, prop) &&
-            exceptions.indexOf(prop) === -1)
-            decoratedProperties.push(Reflection.getPropertyDecorators(UpdateValidationKeys.REFLECT, newModel, prop));
-    let result = undefined;
-    for (const decoratedProperty of decoratedProperties) {
-        const { prop, decorators } = decoratedProperty;
-        decorators.shift(); // remove the design:type decorator, since the type will already be checked
-        if (!decorators || !decorators.length)
+export function validateCompare(oldModel, newModel, async, ...exceptions) {
+    const decoratedProperties = getValidatableUpdateProps(newModel, exceptions);
+    const result = {};
+    const nestedErrors = {};
+    for (const { prop, decorators } of decoratedProperties) {
+        const propKey = String(prop);
+        let propValue = newModel[prop];
+        if (!decorators?.length)
             continue;
-        let errs = undefined;
-        for (const decorator of decorators) {
-            const validator = Validation.get(decorator.key);
-            if (!validator) {
-                console.error(`Could not find Matching validator for ${decorator.key} for property ${String(decoratedProperty.prop)}`);
+        // Get the default type validator
+        const designTypeDec = decorators.find((d) => [ModelKeys.TYPE, ValidationKeys.TYPE].includes(d.key));
+        if (!designTypeDec)
+            continue;
+        const designType = designTypeDec.props.name;
+        // Handle array or Set types and enforce the presence of @list decorator
+        if ([Array.name, Set.name].includes(designType)) {
+            const { decorators } = Reflection.getPropertyDecorators(ValidationKeys.REFLECT, newModel, propKey);
+            if (!decorators.some((d) => d.key === ValidationKeys.LIST)) {
+                result[propKey] = {
+                    [ValidationKeys.TYPE]: `Array or Set property '${propKey}' requires a @list decorator`,
+                };
+                continue;
+            }
+            if (propValue &&
+                !(Array.isArray(propValue) || propValue instanceof Set)) {
+                result[propKey] = {
+                    [ValidationKeys.TYPE]: `Property '${String(prop)}' must be either an array or a Set`,
+                };
                 continue;
             }
-            const err = validator.updateHasErrors(newModel[prop.toString()], oldModel[prop.toString()], ...Object.values(decorator.props));
-            if (err) {
-                errs = errs || {};
-                errs[decorator.key] = err;
+            // Remove design:type decorator, since @list decorator already ensures type
+            for (let i = decorators.length - 1; i >= 0; i--) {
+                if (decorators[i].key === ModelKeys.TYPE) {
+                    decorators.splice(i, 1);
+                }
+            }
+            propValue = propValue instanceof Set ? [...propValue] : propValue;
+        }
+        const propErrors = validateDecorators(newModel, oldModel, propKey, decorators, async) || {};
+        // Check for nested properties.
+        // To prevent unnecessary processing, "propValue" must be defined and validatable
+        const isConstr = Model.isPropertyModel(newModel, 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.");
+            }
+            else {
+                nestedErrors[propKey] = instance.hasErrors(oldModel[prop]);
             }
         }
-        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(newModel).filter((k) => {
-        if (exceptions.includes(k))
-            return false;
-        return !result || !result[k];
-    })) {
-        let err;
-        // if a nested Model
-        const allDecorators = Reflection.getPropertyDecorators(ValidationKeys.REFLECT, newModel, prop).decorators;
-        const decorators = Reflection.getPropertyDecorators(ValidationKeys.REFLECT, newModel, prop).decorators.filter((d) => [ModelKeys.TYPE, 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(ReservedModels).map((v) => v.toLowerCase());
-        for (const c of clazz) {
-            if (reserved.indexOf(c.toLowerCase()) === -1) {
-                switch (c) {
-                    case Array.name:
-                    case Set.name:
-                        if (allDecorators.length) {
-                            const listDec = allDecorators.find((d) => d.key === ValidationKeys.LIST);
-                            if (listDec) {
-                                let currentList, oldList;
-                                switch (c) {
-                                    case Array.name:
-                                        currentList = newModel[prop];
-                                        oldList = oldModel[prop];
-                                        break;
-                                    case Set.name:
-                                        currentList = newModel[prop].values();
-                                        oldList = oldModel[prop].values();
-                                        break;
-                                    default:
-                                        throw new Error(`Invalid attribute type ${c}`);
-                                }
-                                err = currentList
-                                    .map((v) => {
-                                    const id = findModelId(v, true);
-                                    if (!id)
-                                        return "Failed to find model id";
-                                    const oldModel = oldList.find((el) => id === findModelId(el, true));
-                                    if (!oldModel)
-                                        return; // nothing to compare with
-                                    return v.hasErrors(oldModel);
-                                })
-                                    .filter((e) => !!e);
-                                if (!err?.length) {
-                                    // if the result is an empty list...
-                                    err = undefined;
-                                }
-                            }
-                        }
-                        break;
-                    default:
-                        try {
-                            if (newModel[prop] &&
-                                oldModel[prop])
-                                err = newModel[prop].hasErrors(oldModel[prop]);
-                            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                        }
-                        catch (e) {
-                            console.warn(sf("Model should be validatable but its not"));
-                        }
-                }
+    // Synchronous return
+    if (!async) {
+        return (Object.keys(result).length > 0
+            ? new 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;
+                    }
+                });
+        }
+        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(result) : undefined;
+        return Object.keys(result).length > 0
+            ? new 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 {\n  Model,\n  ModelErrorDefinition,\n  ModelErrors,\n  ModelKeys,\n  ReservedModels,\n  sf,\n  Validatable,\n  Validation,\n  ValidationKeys,\n  ValidationPropertyDecoratorDefinition,\n} from \"@decaf-ts/decorator-validation\";\nimport { DecoratorMetadata, Reflection } from \"@decaf-ts/reflection\";\nimport { UpdateValidationKeys, UpdateValidator } from \"../validation\";\nimport { findModelId } from \"../identity\";\n\n/**\n * @description Validates changes between two model versions\n * @summary Compares an old and new model version to validate update operations\n * @template M - Type extending Model\n * @param {M} oldModel - The original model version\n * @param {M} newModel - The updated model version\n * @param {...string[]} exceptions - Properties to exclude from validation\n * @return {ModelErrorDefinition|undefined} Error definition if validation fails, undefined otherwise\n * @function validateCompare\n * @memberOf module:db-decorators\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant validateCompare\n *   participant Reflection\n *   participant Validation\n *\n *   Caller->>validateCompare: oldModel, newModel, exceptions\n *   validateCompare->>Reflection: get decorated properties\n *   Reflection-->>validateCompare: property decorators\n *   loop For each decorated property\n *     validateCompare->>Validation: get validator\n *     Validation-->>validateCompare: validator\n *     validateCompare->>validateCompare: validate property update\n *   end\n *   loop For nested models\n *     validateCompare->>validateCompare: validate nested models\n *   end\n *   validateCompare-->>Caller: validation errors or undefined\n */\nexport function validateCompare<M extends Model>(\n  oldModel: M,\n  newModel: M,\n  ...exceptions: string[]\n): ModelErrorDefinition | undefined {\n  const decoratedProperties: ValidationPropertyDecoratorDefinition[] = [];\n  for (const prop in newModel)\n    if (\n      Object.prototype.hasOwnProperty.call(newModel, prop) &&\n      exceptions.indexOf(prop) === -1\n    )\n      decoratedProperties.push(\n        Reflection.getPropertyDecorators(\n          UpdateValidationKeys.REFLECT,\n          newModel,\n          prop\n        ) as unknown as ValidationPropertyDecoratorDefinition\n      );\n\n  let result: ModelErrors | undefined = undefined;\n\n  for (const decoratedProperty of decoratedProperties) {\n    const { prop, decorators } = decoratedProperty;\n\n    decorators.shift(); // remove the design:type decorator, since the type will already be checked\n\n    if (!decorators || !decorators.length) continue;\n    let errs: Record<string, string | undefined> | undefined = undefined;\n\n    for (const decorator of decorators) {\n      const validator: UpdateValidator = Validation.get(\n        decorator.key\n      ) as UpdateValidator;\n      if (!validator) {\n        console.error(\n          `Could not find Matching validator for ${decorator.key} for property ${String(decoratedProperty.prop)}`\n        );\n        continue;\n      }\n\n      const err: string | undefined = validator.updateHasErrors(\n        (newModel as any)[prop.toString()],\n        (oldModel as any)[prop.toString()],\n        ...Object.values(decorator.props)\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  // tests nested classes\n  for (const prop of Object.keys(newModel).filter((k) => {\n    if (exceptions.includes(k)) return false;\n    return !result || !result[k];\n  })) {\n    let err: string | undefined;\n    // if a nested Model\n    const allDecorators = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      newModel,\n      prop\n    ).decorators;\n    const decorators = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      newModel,\n      prop\n    ).decorators.filter(\n      (d) => [ModelKeys.TYPE, ValidationKeys.TYPE].indexOf(d.key as any) !== -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        switch (c) {\n          case Array.name:\n          case Set.name:\n            if (allDecorators.length) {\n              const listDec = allDecorators.find(\n                (d) => d.key === ValidationKeys.LIST\n              );\n              if (listDec) {\n                let currentList, oldList;\n\n                switch (c) {\n                  case Array.name:\n                    currentList = (newModel as Record<string, any>)[prop];\n                    oldList = (oldModel as Record<string, any>)[prop];\n                    break;\n                  case Set.name:\n                    currentList = (newModel as Record<string, any>)[\n                      prop\n                    ].values();\n                    oldList = (oldModel as Record<string, any>)[prop].values();\n                    break;\n                  default:\n                    throw new Error(`Invalid attribute type ${c}`);\n                }\n\n                err = currentList\n                  .map((v: Validatable) => {\n                    const id = findModelId(v as any, true);\n                    if (!id) return \"Failed to find model id\";\n                    const oldModel = oldList.find(\n                      (el: any) => id === findModelId(el, true)\n                    );\n\n                    if (!oldModel) return; // nothing to compare with\n                    return v.hasErrors(oldModel);\n                  })\n                  .filter((e: any) => !!e) as any;\n\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 (\n                (newModel as Record<string, any>)[prop] &&\n                (oldModel as Record<string, any>)[prop]\n              )\n                err = (newModel as Record<string, any>)[prop].hasErrors(\n                  (oldModel as Record<string, any>)[prop]\n                );\n              // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            } catch (e: any) {\n              console.warn(sf(\"Model should be validatable but its not\"));\n            }\n        }\n      }\n      if (err) {\n        result = result || {};\n        result[prop] = err as any;\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 {\n  ConditionalAsync,\n  DecoratorMetadataAsync,\n  getValidationDecorators,\n  Model,\n  ModelConditionalAsync,\n  ModelErrorDefinition,\n  ModelErrors,\n  ModelKeys,\n  toConditionalPromise,\n  Validation,\n  ValidationKeys,\n  ValidationPropertyDecoratorDefinition,\n} from \"@decaf-ts/decorator-validation\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { UpdateValidationKeys, UpdateValidator } from \"../validation\";\nimport { findModelId } from \"../identity\";\n\n/**\n * @description\n * Retrieves validation decorator definitions from a model for update operations, including\n * support for special handling of list decorators.\n *\n * @summary\n * Iterates over the model's own enumerable properties and filters out those specified in the\n * `propsToIgnore` array. For each remaining property, retrieves validation decorators specific\n * to update operations using the `UpdateValidationKeys.REFLECT` key. Additionally, it explicitly\n * checks for and appends any `LIST` type decorators to ensure proper validation of collection types.\n *\n * @template M - A generic parameter extending the `Model` class, representing the model type being inspected.\n *\n * @param {M} model - The model instance whose properties are being inspected for update-related validations.\n * @param {string[]} propsToIgnore - A list of property names to exclude from the validation decorator retrieval process.\n *\n * @return {ValidationPropertyDecoratorDefinition[]} An array of validation decorator definitions, including both\n * update-specific and list-type decorators, excluding those for ignored properties.\n *\n * @function getValidatableUpdateProps\n */\nexport function getValidatableUpdateProps<M extends Model>(\n  model: M,\n  propsToIgnore: string[]\n): ValidationPropertyDecoratorDefinition[] {\n  const decoratedProperties: ValidationPropertyDecoratorDefinition[] = [];\n  for (const prop in model) {\n    if (\n      Object.prototype.hasOwnProperty.call(model, prop) &&\n      !propsToIgnore.includes(prop)\n    ) {\n      const validationPropertyDefinition = getValidationDecorators(\n        model,\n        prop,\n        UpdateValidationKeys.REFLECT\n      );\n\n      const listDecorator = getValidationDecorators(\n        model,\n        prop\n      ).decorators.find(({ key }) => key === ValidationKeys.LIST);\n\n      if (listDecorator)\n        validationPropertyDefinition.decorators.push(listDecorator);\n\n      decoratedProperties.push(validationPropertyDefinition);\n    }\n  }\n\n  return decoratedProperties;\n}\n\nexport function validateDecorator<\n  M extends Model,\n  Async extends boolean = false,\n>(\n  newModel: M,\n  oldModel: M,\n  prop: string,\n  decorator: DecoratorMetadataAsync,\n  async?: Async\n): ConditionalAsync<Async, string | undefined> {\n  const validator: UpdateValidator = Validation.get(\n    decorator.key\n  ) as UpdateValidator;\n\n  if (!validator) {\n    throw new Error(`Missing validator for ${decorator.key}`);\n  }\n\n  // Skip validators that aren't UpdateValidators\n  if (!validator.updateHasErrors) return toConditionalPromise(undefined, async);\n\n  // skip async decorators if validateDecorators is called synchronously (async = false)\n  if (!async && decorator.props.async)\n    return toConditionalPromise(undefined, async);\n\n  const decoratorProps = Object.values(decorator.props) || {};\n\n  // const context = PathProxyEngine.create(obj, {\n  //   ignoreUndefined: true,\n  //   ignoreNull: true,\n  // });\n\n  const maybeError = validator.updateHasErrors(\n    (newModel as any)[prop],\n    (oldModel as any)[prop],\n    ...decoratorProps\n  );\n\n  return toConditionalPromise(maybeError, async);\n}\n\nexport function validateDecorators<\n  M extends Model,\n  Async extends boolean = false,\n>(\n  newModel: M,\n  oldModel: M,\n  prop: string,\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(\n      newModel,\n      oldModel,\n      prop,\n      decorator,\n      async\n    );\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 newPropValue = (newModel as any)[prop];\n      const oldPropValue = (oldModel as any)[prop];\n\n      const newValues =\n        newPropValue instanceof Set ? [...newPropValue] : newPropValue;\n      const oldValues =\n        oldPropValue instanceof Set ? [...oldPropValue] : oldPropValue;\n\n      if (newValues && newValues.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 errs = newValues.map((childValue: any) => {\n          // find by id so the list elements order doesn't matter\n          const id = findModelId(childValue as any, true);\n          if (!id) return \"Failed to find model id\";\n\n          const oldModel = oldValues.find(\n            (el: any) => id === findModelId(el, true)\n          );\n\n          if (Model.isModel(childValue)) {\n            return childValue.hasErrors(oldModel);\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 ? (result as any) : undefined;\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 * @description Validates changes between two model versions\n * @summary Compares an old and new model version to validate update operations\n * @template M - Type extending Model\n * @param {M} oldModel - The original model version\n * @param {M} newModel - The updated model version\n * @param {boolean} async - A flag indicating whether validation should be asynchronous.\n * @param {...string[]} exceptions - Properties to exclude from validation\n * @return {ModelErrorDefinition|undefined} Error definition if validation fails, undefined otherwise\n * @function validateCompare\n * @memberOf module:db-decorators\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant validateCompare\n *   participant Reflection\n *   participant Validation\n *\n *   Caller->>validateCompare: oldModel, newModel, exceptions\n *   validateCompare->>Reflection: get decorated properties\n *   Reflection-->>validateCompare: property decorators\n *   loop For each decorated property\n *     validateCompare->>Validation: get validator\n *     Validation-->>validateCompare: validator\n *     validateCompare->>validateCompare: validate property update\n *   end\n *   loop For nested models\n *     validateCompare->>validateCompare: validate nested models\n *   end\n *   validateCompare-->>Caller: validation errors or undefined\n */\nexport function validateCompare<M extends Model<any>>(\n  oldModel: M,\n  newModel: M,\n  async: boolean,\n  ...exceptions: string[]\n): ModelConditionalAsync<M> {\n  const decoratedProperties: ValidationPropertyDecoratorDefinition[] =\n    getValidatableUpdateProps(newModel, exceptions);\n\n  const result: Record<string, any> = {};\n\n  const nestedErrors: Record<string, any> = {};\n  for (const { prop, decorators } of decoratedProperties) {\n    const propKey = String(prop);\n    let propValue = (newModel as any)[prop];\n\n    if (!decorators?.length) continue;\n\n    // Get the default type validator\n    const designTypeDec = decorators.find((d) =>\n      [ModelKeys.TYPE, ValidationKeys.TYPE].includes(d.key as any)\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      const { decorators } = Reflection.getPropertyDecorators(\n        ValidationKeys.REFLECT,\n        newModel,\n        propKey\n      ) as unknown as ValidationPropertyDecoratorDefinition;\n\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(newModel, oldModel, propKey, decorators, async) || {};\n\n    // Check for nested properties.\n    // To prevent unnecessary processing, \"propValue\" must be defined and validatable\n    const isConstr = Model.isPropertyModel(newModel, 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] =\n        //   \"Model should be validatable but it's not.\";\n        console.warn(\"Model should be validatable but it's not.\");\n      } else {\n        nestedErrors[propKey] = instance.hasErrors((oldModel as any)[prop]);\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"]}