@decaf-ts/db-decorators 0.6.1 → 0.6.2

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,23 @@
+import { Model, validate, } from "@decaf-ts/decorator-validation";
+/**
+ * @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
+ */
+import { validateCompare } from "./validation.js";
+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,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

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,32 @@
 import { Model, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
 /**
- * @summary Validates the update of a model
- *
- * @param {T} oldModel
- * @param {T} newModel
- * @param {string[]} [exceptions]
- *
+ * @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 {...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;

package/lib/esm/model/validation.js

@@ -1,18 +1,36 @@
 import { ModelErrorDefinition, ModelKeys, ReservedModels, sf, Validation, ValidationKeys, } from "@decaf-ts/decorator-validation";
 import { Reflection } from "@decaf-ts/reflection";
-import { UpdateValidationKeys } from "../validation";
-import { findModelId } from "../identity";
+import { UpdateValidationKeys } from "./../validation/index.js";
+import { findModelId } from "./../identity/index.js";
 /**
- * @summary Validates the update of a model
- *
- * @param {T} oldModel
- * @param {T} newModel
- * @param {string[]} [exceptions]
- *
+ * @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 {...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 function validateCompare(oldModel, newModel, ...exceptions) {
     const decoratedProperties = [];
@@ -122,4 +140,4 @@ export function validateCompare(oldModel, newModel, ...exceptions) {
     }
     return result ? 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 * @summary Validates the update of a model\n *\n * @param {T} oldModel\n * @param {T} newModel\n * @param {string[]} [exceptions]\n *\n * @function validateCompare\n * @return {ModelErrorDefinition | undefined}\n *\n * @memberOf module:db-decorators.Model\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 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  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"]}

package/lib/esm/operations/Operations.d.ts

@@ -5,18 +5,80 @@ import { IRepository } from "../interfaces";
 import { Context } from "../repository";
 import { RepositoryFlags } from "../repository/types";
 /**
- * @summary Static class holding common Operation Functionality
- *
+ * @description Static utility class for database operation management
+ * @summary Provides functionality for registering, retrieving, and managing database operation handlers
  * @class Operations
+ * @template M - Model type
+ * @template R - Repository type
+ * @template V - Metadata type
+ * @template F - Repository flags
+ * @template C - Context type
+ * @example
+ * // Register a handler for a create operation
+ * Operations.register(myHandler, OperationKeys.CREATE, targetModel, 'propertyName');
+ *
+ * // Get handlers for a specific operation
+ * const handlers = Operations.get(targetModel.constructor.name, 'propertyName', 'onCreate');
  *
- * @category Operations
+ * @mermaid
+ * classDiagram
+ *   class Operations {
+ *     -registry: OperationsRegistry
+ *     +getHandlerName(handler)
+ *     +key(str)
+ *     +get(targetName, propKey, operation)
+ *     -getOpRegistry()
+ *     +register(handler, operation, target, propKey)
+ *   }
+ *   Operations --> OperationsRegistry : uses
  */
 export declare class Operations {
     private static registry;
     private constructor();
+    /**
+     * @description Gets a unique name for an operation handler
+     * @summary Returns the name of the handler function or generates a hash if name is not available
+     * @param {OperationHandler<any, any, any, any, any>} handler - The handler function to get the name for
+     * @return {string} The name of the handler or a generated hash
+     */
     static getHandlerName(handler: OperationHandler<any, any, any, any, any>): any;
+    /**
+     * @description Generates a reflection metadata key
+     * @summary Creates a fully qualified metadata key by prefixing with the reflection namespace
+     * @param {string} str - The operation key string to prefix
+     * @return {string} The fully qualified metadata key
+     */
     static key(str: string): string;
+    /**
+     * @description Retrieves operation handlers for a specific target and operation
+     * @summary Gets registered handlers from the operations registry for a given target, property, and operation
+     * @template M - Model type extending Model
+     * @template R - Repository type extending IRepository
+     * @template V - Metadata type, defaults to object
+     * @template F - Repository flags extending RepositoryFlags
+     * @template C - Context type extending Context<F>
+     * @param {string | Record<string, any>} targetName - The target class name or object
+     * @param {string} propKey - The property key to get handlers for
+     * @param {string} operation - The operation key to get handlers for
+     * @return {any} The registered handlers for the specified target, property, and operation
+     */
     static get<M extends Model, R extends IRepository<M, F, C>, V = object, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>>(targetName: string | Record<string, any>, propKey: string, operation: string): OperationHandler<M, R, V, F, C>[] | undefined;
+    /**
+     * @description Gets or initializes the operations registry
+     * @summary Returns the existing registry or creates a new one if it doesn't exist
+     * @return {OperationsRegistry} The operations registry instance
+     * @private
+     */
     private static getOpRegistry;
+    /**
+     * @description Registers an operation handler for a specific target and operation
+     * @summary Adds a handler to the operations registry for a given target, property, and operation
+     * @template V - Model type extending Model
+     * @param {OperationHandler<V, any, any>} handler - The handler function to register
+     * @param {OperationKeys} operation - The operation key to register the handler for
+     * @param {V} target - The target model instance
+     * @param {string | symbol} propKey - The property key to register the handler for
+     * @return {void}
+     */
     static register<V extends Model>(handler: OperationHandler<V, any, any>, operation: OperationKeys, target: V, propKey: string | symbol): void;
 }