@decaf-ts/db-decorators 0.6.1 → 0.6.3

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

@@ -1,145 +1,6 @@
-import { Comparable, Hashable, ModelArg, ModelErrorDefinition, Serializable, Validatable, Constructor, ModelBuilderFunction, BuilderRegistry, ModelConstructor } from "@decaf-ts/decorator-validation";
+import type { ModelErrorDefinition } from "@decaf-ts/decorator-validation";
 declare module "@decaf-ts/decorator-validation" {
-    abstract class Model implements Validatable, Serializable, Hashable, Comparable<Model> {
-        protected constructor(arg?: ModelArg<Model>);
-        hasErrors(...exclusions: any[]): ModelErrorDefinition | undefined;
+    interface Model {
         hasErrors(previousVersion?: Model | any, ...exclusions: any[]): ModelErrorDefinition | undefined;
-        /**
-         * @summary Compare object equality recursively
-         * @param {any} obj object to compare to
-         * @param {string} [exceptions] property names to be excluded from the comparison
-         */
-        equals(obj: any, ...exceptions: string[]): boolean;
-        /**
-         * @summary Returns the serialized model according to the currently defined {@link Serializer}
-         */
-        serialize(): string;
-        /**
-         * @summary Override the implementation for js's 'toString()' which sucks...
-         * @override
-         */
-        toString(): string;
-        /**
-         * @summary Defines a default implementation for object hash. Relies on a very basic implementation based on Java's string hash;
-         */
-        hash(): string;
-        /**
-         * @summary Deserializes a Model
-         * @param {string} str
-         *
-         * @throws {Error} If it fails to parse the string, or if it fails to build the model
-         */
-        static deserialize(str: string): any;
-        /**
-         * @summary Repopulates the Object properties with the ones from the new object
-         * @description Iterates all common properties of obj (if existing) and self, and copies them onto self
-         *
-         * @param {T} self
-         * @param {T | Record<string, any>} [obj]
-         *
-         */
-        static fromObject<T extends Model>(self: T, obj?: T | Record<string, any>): T;
-        /**
-         * @summary Repopulates the instance with the ones from the new Model Object
-         * @description Iterates all common properties of obj (if existing) and self, and copies them onto self.
-         * Is aware of nested Model Objects and rebuilds them also.
-         * When List properties are decorated with {@link list}, they list items will also be rebuilt
-         *
-         * @param {T} self
-         * @param {T | Record<string, any>} [obj]
-         *
-         */
-        static fromModel<T extends Model>(self: T, obj?: T | Record<string, any>): T;
-        /**
-         * @summary Sets the Global {@link ModelBuilderFunction}
-         * @param {ModelBuilderFunction} [builder]
-         */
-        static setBuilder(builder?: ModelBuilderFunction): void;
-        /**
-         * @summary Retrieves the current global {@link ModelBuilderFunction}
-         */
-        static getBuilder(): ModelBuilderFunction | undefined;
-        /**
-         * Returns the current {@link ModelRegistryManager}
-         *
-         * @return ModelRegistry, defaults to {@link ModelRegistryManager}
-         */
-        private static getRegistry;
-        /**
-         * Returns the current actingModelRegistry
-         *
-         * @param {BuilderRegistry} modelRegistry the new implementation of Registry
-         */
-        static setRegistry(modelRegistry: BuilderRegistry<any>): void;
-        /**
-         * @summary register new Models
-         * @param {any} constructor
-         * @param {string} [name] when not defined, the name of the constructor will be used
-         *
-         * @see ModelRegistry
-         */
-        static register<T extends Model>(constructor: ModelConstructor<T>, name?: string): void;
-        /**
-         * @summary Gets a registered Model {@link ModelConstructor}
-         * @param {string} name
-         *
-         * @see ModelRegistry
-         */
-        static get<T extends Model>(name: string): ModelConstructor<T> | undefined;
-        /**
-         * @param {Record<string, any>} obj
-         * @param {string} [clazz] when provided, it will attempt to find the matching constructor
-         *
-         * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property
-         *
-         * @see ModelRegistry
-         */
-        static build<T extends Model>(obj?: Record<string, any>, clazz?: string): T;
-        static getMetadata<V extends Model>(model: V): any;
-        static getAttributes<V extends Model>(model: Constructor<V> | V): string[];
-        static equals<M extends Model>(obj1: M, obj2: M, ...exceptions: any[]): boolean;
-        static hasErrors<M extends Model>(model: M, ...propsToIgnore: string[]): ModelErrorDefinition | undefined;
-        static serialize<M extends Model>(model: M): any;
-        static hash<M extends Model>(model: M): any;
-        /**
-         * @summary Builds the key to store as Metadata under Reflections
-         * @description concatenates {@link ModelKeys#REFLECT} with the provided key
-         * @param {string} str
-         */
-        static key(str: string): string;
-        /**
-         * @description Determines if an object is a model instance or has model metadata
-         * @summary Checks whether a given object is either an instance of the Model class or
-         * has model metadata attached to it. This function is essential for serialization and
-         * deserialization processes, as it helps identify model objects that need special handling.
-         * It safely handles potential errors during metadata retrieval.
-         *
-         * @param {Record<string, any>} target - The object to check
-         * @return {boolean} True if the object is a model instance or has model metadata, false otherwise
-         *
-         * @example
-         * ```typescript
-         * // Check if an object is a model
-         * const user = new User({ name: "John" });
-         * const isUserModel = isModel(user); // true
-         *
-         * // Check a plain object
-         * const plainObject = { name: "John" };
-         * const isPlainObjectModel = isModel(plainObject); // false
-         * ```
-         */
-        static isModel(target: Record<string, any>): boolean;
-        /**
-         * @description Checks if a property of a model is itself a model or has a model type
-         * @summary Determines whether a specific property of a model instance is either a model instance
-         * or has a type that is registered as a model. This function is used for model serialization
-         * and deserialization to properly handle nested models.
-         * @template M extends {@link Model}
-         * @param {M} target - The model instance to check
-         * @param {string} attribute - The property name to check
-         * @return {boolean | string | undefined} Returns true if the property is a model instance,
-         * the model name if the property has a model type, or undefined if not a model
-         */
-        static isPropertyModel<M extends Model>(target: M, attribute: string): boolean | string | undefined;
     }
 }

package/lib/esm/model/model.js

@@ -1,13 +1,2 @@
-import { Model, validate, } from "@decaf-ts/decorator-validation";
-import { validateCompare } from "./validation";
-Model.prototype.hasErrors = function (previousVersion, ...exclusions) {
-    if (previousVersion && !(previousVersion instanceof Model)) {
-        exclusions.unshift(previousVersion);
-        previousVersion = undefined;
-    }
-    const errs = validate(this, ...exclusions);
-    if (errs || !previousVersion)
-        return errs;
-    return validateCompare(previousVersion, this, ...exclusions);
-};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model.js","sourceRoot":"","sources":["../../../src/model/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,EACL,QAAQ,GAKT,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C,KAAK,CAAC,SAAS,CAAC,SAAS,GAAG,UAE1B,eAAyB,EACzB,GAAG,UAAiB;IAEpB,IAAI,eAAe,IAAI,CAAC,CAAC,eAAe,YAAY,KAAK,CAAC,EAAE,CAAC;QAC3D,UAAU,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;QACpC,eAAe,GAAG,SAAS,CAAC;IAC9B,CAAC;IAED,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,GAAG,UAAU,CAAC,CAAC;IAC3C,IAAI,IAAI,IAAI,CAAC,eAAe;QAAE,OAAO,IAAI,CAAC;IAE1C,OAAO,eAAe,CAAC,eAAe,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC,CAAC;AAC/D,CAAC,CAAC","sourcesContent":["import {\n  Comparable,\n  Hashable,\n  ModelArg,\n  ModelErrorDefinition,\n  Serializable,\n  Validatable,\n  Model,\n  validate,\n  Constructor,\n  ModelBuilderFunction,\n  BuilderRegistry,\n  ModelConstructor,\n} from \"@decaf-ts/decorator-validation\";\nimport { validateCompare } from \"./validation\";\n\nModel.prototype.hasErrors = function <M extends Model>(\n  this: M,\n  previousVersion?: M | any,\n  ...exclusions: any[]\n): ModelErrorDefinition | undefined {\n  if (previousVersion && !(previousVersion instanceof Model)) {\n    exclusions.unshift(previousVersion);\n    previousVersion = undefined;\n  }\n\n  const errs = validate(this, ...exclusions);\n  if (errs || !previousVersion) return errs;\n\n  return validateCompare(previousVersion, this, ...exclusions);\n};\n\ndeclare module \"@decaf-ts/decorator-validation\" {\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-expect-error\n  declare abstract class Model\n    implements Validatable, Serializable, Hashable, Comparable<Model>\n  {\n    protected constructor(arg?: ModelArg<Model>);\n\n    hasErrors(...exclusions: any[]): ModelErrorDefinition | undefined;\n    hasErrors(\n      previousVersion?: Model | any,\n      ...exclusions: any[]\n    ): ModelErrorDefinition | undefined;\n\n    /**\n     * @summary Compare object equality recursively\n     * @param {any} obj object to compare to\n     * @param {string} [exceptions] property names to be excluded from the comparison\n     */\n    equals(obj: any, ...exceptions: string[]): boolean;\n\n    /**\n     * @summary Returns the serialized model according to the currently defined {@link Serializer}\n     */\n    serialize(): string;\n\n    /**\n     * @summary Override the implementation for js's 'toString()' which sucks...\n     * @override\n     */\n    toString(): string;\n\n    /**\n     * @summary Defines a default implementation for object hash. Relies on a very basic implementation based on Java's string hash;\n     */\n    hash(): string;\n\n    /**\n     * @summary Deserializes a Model\n     * @param {string} str\n     *\n     * @throws {Error} If it fails to parse the string, or if it fails to build the model\n     */\n    static deserialize(str: string): any;\n\n    /**\n     * @summary Repopulates the Object properties with the ones from the new object\n     * @description Iterates all common properties of obj (if existing) and self, and copies them onto self\n     *\n     * @param {T} self\n     * @param {T | Record<string, any>} [obj]\n     *\n     */\n    static fromObject<T extends Model>(\n      self: T,\n      obj?: T | Record<string, any>\n    ): T;\n\n    /**\n     * @summary Repopulates the instance with the ones from the new Model Object\n     * @description Iterates all common properties of obj (if existing) and self, and copies them onto self.\n     * Is aware of nested Model Objects and rebuilds them also.\n     * When List properties are decorated with {@link list}, they list items will also be rebuilt\n     *\n     * @param {T} self\n     * @param {T | Record<string, any>} [obj]\n     *\n     */\n    static fromModel<T extends Model>(\n      self: T,\n      obj?: T | Record<string, any>\n    ): T;\n\n    /**\n     * @summary Sets the Global {@link ModelBuilderFunction}\n     * @param {ModelBuilderFunction} [builder]\n     */\n    static setBuilder(builder?: ModelBuilderFunction): void;\n\n    /**\n     * @summary Retrieves the current global {@link ModelBuilderFunction}\n     */\n    static getBuilder(): ModelBuilderFunction | undefined;\n\n    /**\n     * Returns the current {@link ModelRegistryManager}\n     *\n     * @return ModelRegistry, defaults to {@link ModelRegistryManager}\n     */\n    private static getRegistry;\n\n    /**\n     * Returns the current actingModelRegistry\n     *\n     * @param {BuilderRegistry} modelRegistry the new implementation of Registry\n     */\n    static setRegistry(modelRegistry: BuilderRegistry<any>): void;\n\n    /**\n     * @summary register new Models\n     * @param {any} constructor\n     * @param {string} [name] when not defined, the name of the constructor will be used\n     *\n     * @see ModelRegistry\n     */\n    static register<T extends Model>(\n      constructor: ModelConstructor<T>,\n      name?: string\n    ): void;\n\n    /**\n     * @summary Gets a registered Model {@link ModelConstructor}\n     * @param {string} name\n     *\n     * @see ModelRegistry\n     */\n    static get<T extends Model>(name: string): ModelConstructor<T> | undefined;\n\n    /**\n     * @param {Record<string, any>} obj\n     * @param {string} [clazz] when provided, it will attempt to find the matching constructor\n     *\n     * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property\n     *\n     * @see ModelRegistry\n     */\n    static build<T extends Model>(obj?: Record<string, any>, clazz?: string): T;\n\n    static getMetadata<V extends Model>(model: V): any;\n\n    static getAttributes<V extends Model>(model: Constructor<V> | V): string[];\n\n    static equals<M extends Model>(\n      obj1: M,\n      obj2: M,\n      ...exceptions: any[]\n    ): boolean;\n\n    static hasErrors<M extends Model>(\n      model: M,\n      ...propsToIgnore: string[]\n    ): ModelErrorDefinition | undefined;\n\n    static serialize<M extends Model>(model: M): any;\n\n    static hash<M extends Model>(model: M): any;\n\n    /**\n     * @summary Builds the key to store as Metadata under Reflections\n     * @description concatenates {@link ModelKeys#REFLECT} with the provided key\n     * @param {string} str\n     */\n    static key(str: string): string;\n\n    /**\n     * @description Determines if an object is a model instance or has model metadata\n     * @summary Checks whether a given object is either an instance of the Model class or\n     * has model metadata attached to it. This function is essential for serialization and\n     * deserialization processes, as it helps identify model objects that need special handling.\n     * It safely handles potential errors during metadata retrieval.\n     *\n     * @param {Record<string, any>} target - The object to check\n     * @return {boolean} True if the object is a model instance or has model metadata, false otherwise\n     *\n     * @example\n     * ```typescript\n     * // Check if an object is a model\n     * const user = new User({ name: \"John\" });\n     * const isUserModel = isModel(user); // true\n     *\n     * // Check a plain object\n     * const plainObject = { name: \"John\" };\n     * const isPlainObjectModel = isModel(plainObject); // false\n     * ```\n     */\n    static isModel(target: Record<string, any>): boolean;\n\n    /**\n     * @description Checks if a property of a model is itself a model or has a model type\n     * @summary Determines whether a specific property of a model instance is either a model instance\n     * or has a type that is registered as a model. This function is used for model serialization\n     * and deserialization to properly handle nested models.\n     * @template M extends {@link Model}\n     * @param {M} target - The model instance to check\n     * @param {string} attribute - The property name to check\n     * @return {boolean | string | undefined} Returns true if the property is a model instance,\n     * the model name if the property has a model type, or undefined if not a model\n     */\n    static isPropertyModel<M extends Model>(\n      target: M,\n      attribute: string\n    ): boolean | string | undefined;\n  }\n}\n"]}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbW9kZWwvbW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTW9kZWxFcnJvckRlZmluaXRpb24gfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5cbmRlY2xhcmUgbW9kdWxlIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCIge1xuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L2Jhbi10cy1jb21tZW50XG4gIC8vIEB0cy1leHBlY3QtZXJyb3JcbiAgZGVjbGFyZSBpbnRlcmZhY2UgTW9kZWwge1xuICAgIGhhc0Vycm9ycyhcbiAgICAgIHByZXZpb3VzVmVyc2lvbj86IE1vZGVsIHwgYW55LFxuICAgICAgLi4uZXhjbHVzaW9uczogYW55W11cbiAgICApOiBNb2RlbEVycm9yRGVmaW5pdGlvbiB8IHVuZGVmaW5lZDtcbiAgfVxufVxuIl19

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

@@ -0,0 +1 @@
+export {};

package/lib/esm/model/overrides.js

@@ -0,0 +1,34 @@
+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
+ * @template M - Type extending Model
+ * @param {M|any} [previousVersion] - Optional previous version of the model for comparison
+ * @param {...any[]} exclusions - Properties to exclude from validation
+ * @return {ModelErrorDefinition|undefined} Error definition if validation fails, undefined otherwise
+ * @function hasErrors
+ * @memberOf module:db-decorators
+ */
+// @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 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;
+    // @ts-expect-error Overriding Model prototype method with dynamic conditional return type.
+    return validateCompare(previousVersion, this, async, ...exclusions);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcnJpZGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21vZGVsL292ZXJyaWRlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsS0FBSyxFQUVMLFFBQVEsR0FDVCxNQUFNLGdDQUFnQyxDQUFDO0FBQ3hDLE9BQU8sRUFBRSxlQUFlLEVBQUUsd0JBQXFCO0FBRS9DOzs7Ozs7Ozs7R0FTRztBQUNILDJGQUEyRjtBQUMzRixLQUFLLENBQUMsU0FBUyxDQUFDLFNBQVMsR0FBRyxVQUUxQixlQUF5QixFQUN6QixHQUFHLFVBQWlCO0lBRXBCLElBQUksZUFBZSxJQUFJLENBQUMsQ0FBQyxlQUFlLFlBQVksS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUMzRCxVQUFVLENBQUMsT0FBTyxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBQ3BDLGVBQWUsR0FBRyxTQUFTLENBQUM7SUFDOUIsQ0FBQztJQUVELE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUM3QixNQUFNLElBQUksR0FBRyxRQUFRLENBQUMsSUFBSSxFQUFFLEtBQUssRUFBRSxHQUFHLFVBQVUsQ0FBQyxDQUFDO0lBRWxELElBQUksS0FBSyxFQUFFLENBQUM7UUFDVixPQUFPLE9BQU8sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsWUFBWSxFQUFFLEVBQUU7WUFDakQsSUFBSSxZQUFZLElBQUksQ0FBQyxlQUFlLEVBQUUsQ0FBQztnQkFDckMsT0FBTyxZQUFZLENBQUM7WUFDdEIsQ0FBQztZQUNELE9BQU8sZUFBZSxDQUFDLGVBQWUsRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLEdBQUcsVUFBVSxDQUFDLENBQUM7UUFDdEUsQ0FBQyxDQUFRLENBQUM7SUFDWixDQUFDO0lBRUQsSUFBSSxJQUFJLElBQUksQ0FBQyxlQUFlO1FBQUUsT0FBTyxJQUFXLENBQUM7SUFFakQsMkZBQTJGO0lBQzNGLE9BQU8sZUFBZSxDQUFDLGVBQWUsRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLEdBQUcsVUFBVSxDQUFDLENBQUM7QUFDdEUsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgTW9kZWwsXG4gIE1vZGVsQ29uZGl0aW9uYWxBc3luYyxcbiAgdmFsaWRhdGUsXG59IGZyb20gXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIjtcbmltcG9ydCB7IHZhbGlkYXRlQ29tcGFyZSB9IGZyb20gXCIuL3ZhbGlkYXRpb25cIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gVmFsaWRhdGVzIHRoZSBtb2RlbCBhbmQgY2hlY2tzIGZvciBlcnJvcnNcbiAqIEBzdW1tYXJ5IFZhbGlkYXRlcyB0aGUgY3VycmVudCBtb2RlbCBzdGF0ZSBhbmQgb3B0aW9uYWxseSBjb21wYXJlcyB3aXRoIGEgcHJldmlvdXMgdmVyc2lvblxuICogQHRlbXBsYXRlIE0gLSBUeXBlIGV4dGVuZGluZyBNb2RlbFxuICogQHBhcmFtIHtNfGFueX0gW3ByZXZpb3VzVmVyc2lvbl0gLSBPcHRpb25hbCBwcmV2aW91cyB2ZXJzaW9uIG9mIHRoZSBtb2RlbCBmb3IgY29tcGFyaXNvblxuICogQHBhcmFtIHsuLi5hbnlbXX0gZXhjbHVzaW9ucyAtIFByb3BlcnRpZXMgdG8gZXhjbHVkZSBmcm9tIHZhbGlkYXRpb25cbiAqIEByZXR1cm4ge01vZGVsRXJyb3JEZWZpbml0aW9ufHVuZGVmaW5lZH0gRXJyb3IgZGVmaW5pdGlvbiBpZiB2YWxpZGF0aW9uIGZhaWxzLCB1bmRlZmluZWQgb3RoZXJ3aXNlXG4gKiBAZnVuY3Rpb24gaGFzRXJyb3JzXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmRiLWRlY29yYXRvcnNcbiAqL1xuLy8gQHRzLWV4cGVjdC1lcnJvciBPdmVycmlkaW5nIE1vZGVsIHByb3RvdHlwZSBtZXRob2Qgd2l0aCBkeW5hbWljIGNvbmRpdGlvbmFsIHJldHVybiB0eXBlLlxuTW9kZWwucHJvdG90eXBlLmhhc0Vycm9ycyA9IGZ1bmN0aW9uIDxNIGV4dGVuZHMgTW9kZWw8Ym9vbGVhbj4+KFxuICB0aGlzOiBNLFxuICBwcmV2aW91c1ZlcnNpb24/OiBNIHwgYW55LFxuICAuLi5leGNsdXNpb25zOiBhbnlbXVxuKTogTW9kZWxDb25kaXRpb25hbEFzeW5jPE0+IHtcbiAgaWYgKHByZXZpb3VzVmVyc2lvbiAmJiAhKHByZXZpb3VzVmVyc2lvbiBpbnN0YW5jZW9mIE1vZGVsKSkge1xuICAgIGV4Y2x1c2lvbnMudW5zaGlmdChwcmV2aW91c1ZlcnNpb24pO1xuICAgIHByZXZpb3VzVmVyc2lvbiA9IHVuZGVmaW5lZDtcbiAgfVxuXG4gIGNvbnN0IGFzeW5jID0gdGhpcy5pc0FzeW5jKCk7XG4gIGNvbnN0IGVycnMgPSB2YWxpZGF0ZSh0aGlzLCBhc3luYywgLi4uZXhjbHVzaW9ucyk7XG5cbiAgaWYgKGFzeW5jKSB7XG4gICAgcmV0dXJuIFByb21pc2UucmVzb2x2ZShlcnJzKS50aGVuKChyZXNvbHZlZEVycnMpID0+IHtcbiAgICAgIGlmIChyZXNvbHZlZEVycnMgfHwgIXByZXZpb3VzVmVyc2lvbikge1xuICAgICAgICByZXR1cm4gcmVzb2x2ZWRFcnJzO1xuICAgICAgfVxuICAgICAgcmV0dXJuIHZhbGlkYXRlQ29tcGFyZShwcmV2aW91c1ZlcnNpb24sIHRoaXMsIGFzeW5jLCAuLi5leGNsdXNpb25zKTtcbiAgICB9KSBhcyBhbnk7XG4gIH1cblxuICBpZiAoZXJycyB8fCAhcHJldmlvdXNWZXJzaW9uKSByZXR1cm4gZXJycyBhcyBhbnk7XG5cbiAgLy8gQHRzLWV4cGVjdC1lcnJvciBPdmVycmlkaW5nIE1vZGVsIHByb3RvdHlwZSBtZXRob2Qgd2l0aCBkeW5hbWljIGNvbmRpdGlvbmFsIHJldHVybiB0eXBlLlxuICByZXR1cm4gdmFsaWRhdGVDb21wYXJlKHByZXZpb3VzVmVyc2lvbiwgdGhpcywgYXN5bmMsIC4uLmV4Y2x1c2lvbnMpO1xufTtcbiJdfQ==

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

@@ -1,5 +1,44 @@
 import { Model } from "@decaf-ts/decorator-validation";
+/**
+ * @description Checks if a model is marked as transient
+ * @summary Determines whether a model class has been decorated with the transient decorator
+ * @template M - Type extending Model
+ * @param {M} model - The model instance to check
+ * @return {boolean} True if the model is transient, false otherwise
+ * @function isTransient
+ * @memberOf module:db-decorators
+ */
 export declare function isTransient<M extends Model>(model: M): boolean;
+/**
+ * @description Separates transient properties from a model
+ * @summary Extracts properties marked as transient into a separate object
+ * @template M - Type extending Model
+ * @param {M} model - The model instance to process
+ * @return {Object} Object containing the model without transient properties and a separate transient object
+ * @property {M} model - The model with transient properties removed
+ * @property {Record<string, any>} [transient] - Object containing the transient properties
+ * @function modelToTransient
+ * @memberOf module:db-decorators
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant modelToTransient
+ *   participant isTransient
+ *   participant getAllPropertyDecoratorsRecursive
+ *
+ *   Caller->>modelToTransient: model
+ *   modelToTransient->>isTransient: check if model is transient
+ *   isTransient-->>modelToTransient: transient status
+ *   alt model is not transient
+ *     modelToTransient-->>Caller: {model}
+ *   else model is transient
+ *     modelToTransient->>getAllPropertyDecoratorsRecursive: get transient properties
+ *     getAllPropertyDecoratorsRecursive-->>modelToTransient: property decorators
+ *     modelToTransient->>modelToTransient: separate properties
+ *     modelToTransient->>Model.build: rebuild model without transient props
+ *     modelToTransient-->>Caller: {model, transient}
+ *   end
+ */
 export declare function modelToTransient<M extends Model>(model: M): {
     model: M;
     transient?: Record<string, any>;

package/lib/esm/model/utils.js

@@ -1,10 +1,49 @@
-import { getAllPropertyDecoratorsRecursive, Repository, SerializationError, } from "../repository";
+import { getAllPropertyDecoratorsRecursive, Repository, SerializationError, } from "./../repository/index.js";
 import { Model } from "@decaf-ts/decorator-validation";
-import { DBKeys } from "./constants";
+import { DBKeys } from "./constants.js";
+/**
+ * @description Checks if a model is marked as transient
+ * @summary Determines whether a model class has been decorated with the transient decorator
+ * @template M - Type extending Model
+ * @param {M} model - The model instance to check
+ * @return {boolean} True if the model is transient, false otherwise
+ * @function isTransient
+ * @memberOf module:db-decorators
+ */
 export function isTransient(model) {
     return !!(Reflect.getMetadata(Repository.key(DBKeys.TRANSIENT), model.constructor) ||
         Reflect.getMetadata(Repository.key(DBKeys.TRANSIENT), Model.get(model.constructor.name)));
 }
+/**
+ * @description Separates transient properties from a model
+ * @summary Extracts properties marked as transient into a separate object
+ * @template M - Type extending Model
+ * @param {M} model - The model instance to process
+ * @return {Object} Object containing the model without transient properties and a separate transient object
+ * @property {M} model - The model with transient properties removed
+ * @property {Record<string, any>} [transient] - Object containing the transient properties
+ * @function modelToTransient
+ * @memberOf module:db-decorators
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant modelToTransient
+ *   participant isTransient
+ *   participant getAllPropertyDecoratorsRecursive
+ *
+ *   Caller->>modelToTransient: model
+ *   modelToTransient->>isTransient: check if model is transient
+ *   isTransient-->>modelToTransient: transient status
+ *   alt model is not transient
+ *     modelToTransient-->>Caller: {model}
+ *   else model is transient
+ *     modelToTransient->>getAllPropertyDecoratorsRecursive: get transient properties
+ *     getAllPropertyDecoratorsRecursive-->>modelToTransient: property decorators
+ *     modelToTransient->>modelToTransient: separate properties
+ *     modelToTransient->>Model.build: rebuild model without transient props
+ *     modelToTransient-->>Caller: {model, transient}
+ *   end
+ */
 export function modelToTransient(model) {
     if (!isTransient(model))
         return { model: model };
@@ -29,4 +68,4 @@ export function modelToTransient(model) {
     result.model = Model.build(result.model, model.constructor.name);
     return result;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,14 +1,57 @@
-import { Model, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
+import { ConditionalAsync, DecoratorMetadataAsync, Model, ModelConditionalAsync, ValidationPropertyDecoratorDefinition } from "@decaf-ts/decorator-validation";
 /**
- * @summary Validates the update of a model
+ * @description
+ * Retrieves validation decorator definitions from a model for update operations, including
+ * support for special handling of list decorators.
  *
- * @param {T} oldModel
- * @param {T} newModel
- * @param {string[]} [exceptions]
+ * @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
- * @return {ModelErrorDefinition | undefined}
+ * @memberOf module:db-decorators
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant validateCompare
+ *   participant Reflection
+ *   participant Validation
  *
- * @memberOf module:db-decorators.Model
+ *   Caller->>validateCompare: oldModel, newModel, exceptions
+ *   validateCompare->>Reflection: get decorated properties
+ *   Reflection-->>validateCompare: property decorators
+ *   loop For each decorated property
+ *     validateCompare->>Validation: get validator
+ *     Validation-->>validateCompare: validator
+ *     validateCompare->>validateCompare: validate property update
+ *   end
+ *   loop For nested models
+ *     validateCompare->>validateCompare: validate nested models
+ *   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>;