@decaf-ts/db-decorators 0.6.1 → 0.6.2

package/lib/esm/model/constants.js

@@ -1,9 +1,9 @@
 import { ModelKeys } from "@decaf-ts/decorator-validation";
 /**
- * @summary Holds the Model reflection keys
+ * @description Database reflection keys
+ * @summary Collection of keys used for reflection metadata in database operations
  * @const DBKeys
- *
- * @memberOf module:db-decorators.Model
+ * @memberOf module:db-decorators
  */
 export const DBKeys = {
     REFLECT: `${ModelKeys.REFLECT}persistence.`,
@@ -22,19 +22,17 @@ export const DBKeys = {
     ORIGINAL: "__originalObj",
 };
 /**
- * @summary The default separator when concatenating indexes
- *
- * @const DefaultIndexSeparator
- *
- * @category Managers
- * @subcategory Constants
+ * @description Default separator character for composite indexes
+ * @summary The default separator character used when concatenating multiple fields into a single index
+ * @const DefaultSeparator
+ * @memberOf module:db-decorators
  */
 export const DefaultSeparator = "_";
 /**
- * @summary Holds the default timestamp date format
- * @constant DEFAULT_TIMESTAMP_FORMAT
- *
- * @memberOf module:db-decorators.Model
+ * @description Default format for timestamp fields
+ * @summary Standard date format string used for timestamp fields in database models
+ * @const DEFAULT_TIMESTAMP_FORMAT
+ * @memberOf module:db-decorators
  */
 export const DEFAULT_TIMESTAMP_FORMAT = "dd/MM/yyyy HH:mm:ss:S";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -4,12 +4,43 @@ import { Context } from "../repository/Context";
 import { CrudOperations } from "../operations";
 import { RepositoryFlags } from "../repository/types";
 /**
- *
- * @param {str} str
- * @memberOf db-decorators.model
+ * @description Hashes a property value during create or update operations
+ * @summary Callback function used by the hash decorator to apply hashing to a property value
+ * @template M - Type extending Model
+ * @template R - Type extending IRepository
+ * @template V - Type for metadata
+ * @template F - Type extending RepositoryFlags
+ * @template C - Type extending Context
+ * @param {C} context - The operation context
+ * @param {V} data - Metadata for the operation
+ * @param key - The property key to hash
+ * @param {M} model - The model being processed
+ * @param {M} [oldModel] - The previous model state (for updates)
+ * @return {void}
+ * @function hashOnCreateUpdate
+ * @memberOf module:db-decorators
  */
 export declare function hashOnCreateUpdate<M extends Model, R extends IRepository<M, F, C>, V extends object, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>>(this: R, context: C, data: V, key: keyof M, model: M, oldModel?: M): void;
+/**
+ * @description Creates a decorator that hashes a property value
+ * @summary Decorator that automatically hashes a property value during create and update operations
+ * @return {PropertyDecorator} A decorator that can be applied to class properties
+ * @function hash
+ * @category Property Decorators
+ */
 export declare function hash(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @description Metadata for composed property decorators
+ * @summary Configuration options for property composition from other properties
+ * @typedef {Object} ComposedFromMetadata
+ * @property {string[]} args - Property names to compose from
+ * @property {string} separator - Character used to join the composed values
+ * @property {boolean} hashResult - Whether to hash the composed result
+ * @property {"keys"|"values"} type - Whether to use property keys or values
+ * @property {string} [prefix] - Optional prefix to add to the composed value
+ * @property {string} [suffix] - Optional suffix to add to the composed value
+ * @memberOf module:db-decorators
+ */
 export type ComposedFromMetadata = {
     args: string[];
     separator: string;
@@ -18,35 +49,93 @@ export type ComposedFromMetadata = {
     prefix?: string;
     suffix?: string;
 };
+/**
+ * @description Composes a property value from other properties during create or update operations
+ * @summary Callback function used by composed decorators to generate a property value from other properties
+ * @template M - Type extending Model
+ * @template R - Type extending IRepository
+ * @template V - Type extending ComposedFromMetadata
+ * @template F - Type extending RepositoryFlags
+ * @template C - Type extending Context
+ * @param {C} context - The operation context
+ * @param {V} data - Metadata for the composition
+ * @param key - The property key to set the composed value on
+ * @param {M} model - The model being processed
+ * @return {void}
+ * @function composedFromCreateUpdate
+ * @memberOf module:db-decorators
+ */
 export declare function composedFromCreateUpdate<M extends Model, R extends IRepository<M, F, C>, V extends ComposedFromMetadata, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>>(this: R, context: C, data: V, key: keyof M, model: M): void;
+/**
+ * @description Creates a decorator that composes a property value from property keys
+ * @summary Decorator that generates a property value by joining the names of other properties
+ * @param {string[]} args - Property names to compose from
+ * @param {string} [separator=DefaultSeparator] - Character used to join the property names
+ * @param {boolean} [hash=false] - Whether to hash the composed result
+ * @param {string} [prefix=""] - Optional prefix to add to the composed value
+ * @param {string} [suffix=""] - Optional suffix to add to the composed value
+ * @return {PropertyDecorator} A decorator that can be applied to class properties
+ * @function composedFromKeys
+ * @category PropertyDecorators
+ */
 export declare function composedFromKeys(args: string[], separator?: string, hash?: boolean, prefix?: string, suffix?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @description Creates a decorator that composes a property value from property values
+ * @summary Decorator that generates a property value by joining the values of other properties
+ * @param {string[]} args - Property names whose values will be composed
+ * @param {string} [separator=DefaultSeparator] - Character used to join the property values
+ * @param {boolean} [hash=false] - Whether to hash the composed result
+ * @param {string} [prefix=""] - Optional prefix to add to the composed value
+ * @param {string} [suffix=""] - Optional suffix to add to the composed value
+ * @return {PropertyDecorator} A decorator that can be applied to class properties
+ * @function composed
+ * @category PropertyDecorators
+ */
 export declare function composed(args: string[], separator?: string, hash?: boolean, prefix?: string, suffix?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
 /**
- * Creates a decorator function that updates the version of a model during create or update operations.
- *
- * @param {CrudOperations} operation - The type of operation being performed (CREATE or UPDATE).
- * @returns {function} A function that updates the version of the model based on the operation type.
- *
+ * @description Creates a function that updates a version property during operations
+ * @summary Factory function that generates a callback for incrementing version numbers
+ * @param {CrudOperations} operation - The type of operation (CREATE or UPDATE)
+ * @return {Function} A callback function that updates the version property
  * @template M - Type extending Model
- * @template V - Type extending IRepository<M>
+ * @template R - Type extending IRepository
+ * @template V - Type for metadata
+ * @template F - Type extending RepositoryFlags
+ * @template C - Type extending Context
+ * @function versionCreateUpdate
+ * @memberOf module:db-decorators
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant versionCreateUpdate
  *
- * @this {V} - The repository instance
- * @param {Context<M>} context - The context of the operation
- * @param {unknown} data - Additional data for the operation (not used in this function)
- * @param {string} key - The key of the version property in the model
- * @param {M} model - The model being updated
- * @throws {InternalError} If an invalid operation is provided or if version update fails
+ *   Caller->>versionCreateUpdate: operation
+ *   versionCreateUpdate-->>Caller: callback function
+ *   Note over Caller,versionCreateUpdate: When callback is executed:
+ *   Caller->>versionCreateUpdate: context, data, key, model
+ *   alt operation is CREATE
+ *     versionCreateUpdate->>versionCreateUpdate: set version to 1
+ *   else operation is UPDATE
+ *     versionCreateUpdate->>versionCreateUpdate: increment version
+ *   else invalid operation
+ *     versionCreateUpdate->>versionCreateUpdate: throw error
+ *   end
+ *   versionCreateUpdate-->>Caller: void
  */
 export declare function versionCreateUpdate(operation: CrudOperations): <M extends Model, R extends IRepository<M, F, C>, V extends object, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>>(this: R, context: C, data: V, key: keyof M, model: M) => void;
 /**
- * @description Creates a decorator for versioning a property in a model.
- * @summary This decorator applies multiple sub-decorators to handle version management during create and update operations.
- *
- * @returns {Function} A composite decorator that:
- *   - Sets the type of the property to Number
- *   - Applies a version update on create operations
- *   - Applies a version update on update operations
- *   - Adds metadata indicating this property is used for versioning
+ * @description Creates a decorator for versioning a property in a model
+ * @summary This decorator applies multiple sub-decorators to handle version management during create and update operations
+ * @return {PropertyDecorator} A composite decorator that sets the type to Number, manages version updates, and adds versioning metadata
+ * @function version
+ * @category PropertyDecorators
  */
 export declare function version(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @description Creates a decorator that marks a property as transient
+ * @summary Decorator that indicates a property should not be persisted to the database
+ * @return {PropertyDecorator} A decorator that can be applied to class properties
+ * @function transient
+ * @category PropertyDecorators
+ */
 export declare function transient(): (model: any, attribute: string) => void;

package/lib/esm/model/decorators.js

@@ -1,14 +1,26 @@
-import { DBKeys, DefaultSeparator } from "./constants";
+import { DBKeys, DefaultSeparator } from "./constants.js";
 import { apply } from "@decaf-ts/reflection";
 import { Hashing, propMetadata, type, } from "@decaf-ts/decorator-validation";
-import { onCreate, onCreateUpdate, onUpdate } from "../operations/decorators";
-import { InternalError } from "../repository/errors";
-import { Repository } from "../repository/Repository";
-import { OperationKeys } from "../operations";
+import { onCreate, onCreateUpdate, onUpdate } from "./../operations/decorators.js";
+import { InternalError } from "./../repository/errors.js";
+import { Repository } from "./../repository/Repository.js";
+import { OperationKeys } from "./../operations/index.js";
 /**
- *
- * @param {str} str
- * @memberOf db-decorators.model
+ * @description Hashes a property value during create or update operations
+ * @summary Callback function used by the hash decorator to apply hashing to a property value
+ * @template M - Type extending Model
+ * @template R - Type extending IRepository
+ * @template V - Type for metadata
+ * @template F - Type extending RepositoryFlags
+ * @template C - Type extending Context
+ * @param {C} context - The operation context
+ * @param {V} data - Metadata for the operation
+ * @param key - The property key to hash
+ * @param {M} model - The model being processed
+ * @param {M} [oldModel] - The previous model state (for updates)
+ * @return {void}
+ * @function hashOnCreateUpdate
+ * @memberOf module:db-decorators
  */
 export function hashOnCreateUpdate(context, data, key, model, oldModel) {
     if (typeof model[key] === "undefined")
@@ -18,9 +30,32 @@ export function hashOnCreateUpdate(context, data, key, model, oldModel) {
         return;
     model[key] = hash;
 }
+/**
+ * @description Creates a decorator that hashes a property value
+ * @summary Decorator that automatically hashes a property value during create and update operations
+ * @return {PropertyDecorator} A decorator that can be applied to class properties
+ * @function hash
+ * @category Property Decorators
+ */
 export function hash() {
     return apply(onCreateUpdate(hashOnCreateUpdate), propMetadata(Repository.key(DBKeys.HASH), {}));
 }
+/**
+ * @description Composes a property value from other properties during create or update operations
+ * @summary Callback function used by composed decorators to generate a property value from other properties
+ * @template M - Type extending Model
+ * @template R - Type extending IRepository
+ * @template V - Type extending ComposedFromMetadata
+ * @template F - Type extending RepositoryFlags
+ * @template C - Type extending Context
+ * @param {C} context - The operation context
+ * @param {V} data - Metadata for the composition
+ * @param key - The property key to set the composed value on
+ * @param {M} model - The model being processed
+ * @return {void}
+ * @function composedFromCreateUpdate
+ * @memberOf module:db-decorators
+ */
 export function composedFromCreateUpdate(context, data, key, model) {
     try {
         const { args, type, prefix, suffix, separator } = data;
@@ -43,6 +78,19 @@ export function composedFromCreateUpdate(context, data, key, model) {
         throw new InternalError(`Failed to compose value: ${e}`);
     }
 }
+/**
+ * @description Creates a decorator that composes a property value from other properties
+ * @summary Base function for creating property composition decorators
+ * @param {string[]} args - Property names to compose from
+ * @param {boolean} [hashResult=false] - Whether to hash the composed result
+ * @param {string} [separator=DefaultSeparator] - Character used to join the composed values
+ * @param {"keys"|"values"} [type="values"] - Whether to use property keys or values
+ * @param {string} [prefix=""] - Optional prefix to add to the composed value
+ * @param {string} [suffix=""] - Optional suffix to add to the composed value
+ * @return {PropertyDecorator} A decorator that can be applied to class properties
+ * @function composedFrom
+ * @category PropertyDecorators
+ */
 function composedFrom(args, hashResult = false, separator = DefaultSeparator, type = "values", prefix = "", suffix = "") {
     const data = {
         args: args,
@@ -60,27 +108,65 @@ function composedFrom(args, hashResult = false, separator = DefaultSeparator, ty
         decorators.push(hash());
     return apply(...decorators);
 }
+/**
+ * @description Creates a decorator that composes a property value from property keys
+ * @summary Decorator that generates a property value by joining the names of other properties
+ * @param {string[]} args - Property names to compose from
+ * @param {string} [separator=DefaultSeparator] - Character used to join the property names
+ * @param {boolean} [hash=false] - Whether to hash the composed result
+ * @param {string} [prefix=""] - Optional prefix to add to the composed value
+ * @param {string} [suffix=""] - Optional suffix to add to the composed value
+ * @return {PropertyDecorator} A decorator that can be applied to class properties
+ * @function composedFromKeys
+ * @category PropertyDecorators
+ */
 export function composedFromKeys(args, separator = DefaultSeparator, hash = false, prefix = "", suffix = "") {
     return composedFrom(args, hash, separator, "keys", prefix, suffix);
 }
+/**
+ * @description Creates a decorator that composes a property value from property values
+ * @summary Decorator that generates a property value by joining the values of other properties
+ * @param {string[]} args - Property names whose values will be composed
+ * @param {string} [separator=DefaultSeparator] - Character used to join the property values
+ * @param {boolean} [hash=false] - Whether to hash the composed result
+ * @param {string} [prefix=""] - Optional prefix to add to the composed value
+ * @param {string} [suffix=""] - Optional suffix to add to the composed value
+ * @return {PropertyDecorator} A decorator that can be applied to class properties
+ * @function composed
+ * @category PropertyDecorators
+ */
 export function composed(args, separator = DefaultSeparator, hash = false, prefix = "", suffix = "") {
     return composedFrom(args, hash, separator, "values", prefix, suffix);
 }
 /**
- * Creates a decorator function that updates the version of a model during create or update operations.
- *
- * @param {CrudOperations} operation - The type of operation being performed (CREATE or UPDATE).
- * @returns {function} A function that updates the version of the model based on the operation type.
- *
+ * @description Creates a function that updates a version property during operations
+ * @summary Factory function that generates a callback for incrementing version numbers
+ * @param {CrudOperations} operation - The type of operation (CREATE or UPDATE)
+ * @return {Function} A callback function that updates the version property
  * @template M - Type extending Model
- * @template V - Type extending IRepository<M>
+ * @template R - Type extending IRepository
+ * @template V - Type for metadata
+ * @template F - Type extending RepositoryFlags
+ * @template C - Type extending Context
+ * @function versionCreateUpdate
+ * @memberOf module:db-decorators
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant versionCreateUpdate
  *
- * @this {V} - The repository instance
- * @param {Context<M>} context - The context of the operation
- * @param {unknown} data - Additional data for the operation (not used in this function)
- * @param {string} key - The key of the version property in the model
- * @param {M} model - The model being updated
- * @throws {InternalError} If an invalid operation is provided or if version update fails
+ *   Caller->>versionCreateUpdate: operation
+ *   versionCreateUpdate-->>Caller: callback function
+ *   Note over Caller,versionCreateUpdate: When callback is executed:
+ *   Caller->>versionCreateUpdate: context, data, key, model
+ *   alt operation is CREATE
+ *     versionCreateUpdate->>versionCreateUpdate: set version to 1
+ *   else operation is UPDATE
+ *     versionCreateUpdate->>versionCreateUpdate: increment version
+ *   else invalid operation
+ *     versionCreateUpdate->>versionCreateUpdate: throw error
+ *   end
+ *   versionCreateUpdate-->>Caller: void
  */
 export function versionCreateUpdate(operation) {
     return function versionCreateUpdate(context, data, key, model) {
@@ -102,22 +188,26 @@ export function versionCreateUpdate(operation) {
     };
 }
 /**
- * @description Creates a decorator for versioning a property in a model.
- * @summary This decorator applies multiple sub-decorators to handle version management during create and update operations.
- *
- * @returns {Function} A composite decorator that:
- *   - Sets the type of the property to Number
- *   - Applies a version update on create operations
- *   - Applies a version update on update operations
- *   - Adds metadata indicating this property is used for versioning
+ * @description Creates a decorator for versioning a property in a model
+ * @summary This decorator applies multiple sub-decorators to handle version management during create and update operations
+ * @return {PropertyDecorator} A composite decorator that sets the type to Number, manages version updates, and adds versioning metadata
+ * @function version
+ * @category PropertyDecorators
  */
 export function version() {
     return apply(type(Number.name), onCreate(versionCreateUpdate(OperationKeys.CREATE)), onUpdate(versionCreateUpdate(OperationKeys.UPDATE)), propMetadata(Repository.key(DBKeys.VERSION), true));
 }
+/**
+ * @description Creates a decorator that marks a property as transient
+ * @summary Decorator that indicates a property should not be persisted to the database
+ * @return {PropertyDecorator} A decorator that can be applied to class properties
+ * @function transient
+ * @category PropertyDecorators
+ */
 export function transient() {
     return function transient(model, attribute) {
         propMetadata(Repository.key(DBKeys.TRANSIENT), true)(model, attribute);
         propMetadata(Repository.key(DBKeys.TRANSIENT), true)(model.constructor);
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../../src/model/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import { DBKeys, DefaultSeparator } from \"./constants\";\nimport { apply } from \"@decaf-ts/reflection\";\nimport {\n  Hashing,\n  Model,\n  propMetadata,\n  type,\n} from \"@decaf-ts/decorator-validation\";\nimport { onCreate, onCreateUpdate, onUpdate } from \"../operations/decorators\";\nimport { IRepository } from \"../interfaces/IRepository\";\nimport { InternalError } from \"../repository/errors\";\nimport { Repository } from \"../repository/Repository\";\nimport { Context } from \"../repository/Context\";\nimport { CrudOperations, OperationKeys } from \"../operations\";\nimport { RepositoryFlags } from \"../repository/types\";\n\n/**\n *\n * @param {str} str\n * @memberOf db-decorators.model\n */\n\nexport function hashOnCreateUpdate<\n  M extends Model,\n  R extends IRepository<M, F, C>,\n  V extends object,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n>(this: R, context: C, data: V, key: keyof M, model: M, oldModel?: M): void {\n  if (typeof model[key] === \"undefined\") return;\n  const hash = Hashing.hash((model as any)[key]);\n  if (oldModel && (model as any)[key] === hash) return;\n  model[key] = hash;\n}\n\nexport function hash() {\n  return apply(\n    onCreateUpdate(hashOnCreateUpdate),\n    propMetadata(Repository.key(DBKeys.HASH), {})\n  );\n}\n\nexport type ComposedFromMetadata = {\n  args: string[];\n  separator: string;\n  hashResult: boolean;\n  type: \"keys\" | \"values\";\n  prefix?: string;\n  suffix?: string;\n};\n\nexport function composedFromCreateUpdate<\n  M extends Model,\n  R extends IRepository<M, F, C>,\n  V extends ComposedFromMetadata,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n>(this: R, context: C, data: V, key: keyof M, model: M) {\n  try {\n    const { args, type, prefix, suffix, separator } = data;\n    const composed = args.map((arg: string) => {\n      if (!(arg in model))\n        throw new InternalError(`Property ${arg} not found to compose from`);\n      if (type === \"keys\") return arg;\n      if (typeof (model as any)[arg] === \"undefined\")\n        throw new InternalError(\n          `Property ${args} does not contain a value to compose from`\n        );\n      return ((model as any)[arg] as any).toString();\n    });\n\n    if (prefix) composed.unshift(prefix);\n    if (suffix) composed.push(suffix);\n\n    (model as any)[key] = composed.join(separator);\n  } catch (e: any) {\n    throw new InternalError(`Failed to compose value: ${e}`);\n  }\n}\n\nfunction composedFrom(\n  args: string[],\n  hashResult: boolean = false,\n  separator: string = DefaultSeparator,\n  type: \"keys\" | \"values\" = \"values\",\n  prefix = \"\",\n  suffix = \"\"\n) {\n  const data: ComposedFromMetadata = {\n    args: args,\n    hashResult: hashResult,\n    separator: separator,\n    type: type,\n    prefix: prefix,\n    suffix: suffix,\n  };\n\n  const decorators = [\n    onCreateUpdate(composedFromCreateUpdate, data),\n    propMetadata(Repository.key(DBKeys.COMPOSED), data),\n  ];\n  if (hashResult) decorators.push(hash());\n  return apply(...decorators);\n}\n\nexport function composedFromKeys(\n  args: string[],\n  separator: string = DefaultSeparator,\n  hash: boolean = false,\n  prefix = \"\",\n  suffix = \"\"\n) {\n  return composedFrom(args, hash, separator, \"keys\", prefix, suffix);\n}\n\nexport function composed(\n  args: string[],\n  separator: string = DefaultSeparator,\n  hash: boolean = false,\n  prefix = \"\",\n  suffix = \"\"\n) {\n  return composedFrom(args, hash, separator, \"values\", prefix, suffix);\n}\n\n/**\n * Creates a decorator function that updates the version of a model during create or update operations.\n *\n * @param {CrudOperations} operation - The type of operation being performed (CREATE or UPDATE).\n * @returns {function} A function that updates the version of the model based on the operation type.\n *\n * @template M - Type extending Model\n * @template V - Type extending IRepository<M>\n *\n * @this {V} - The repository instance\n * @param {Context<M>} context - The context of the operation\n * @param {unknown} data - Additional data for the operation (not used in this function)\n * @param {string} key - The key of the version property in the model\n * @param {M} model - The model being updated\n * @throws {InternalError} If an invalid operation is provided or if version update fails\n */\nexport function versionCreateUpdate(operation: CrudOperations) {\n  return function versionCreateUpdate<\n    M extends Model,\n    R extends IRepository<M, F, C>,\n    V extends object,\n    F extends RepositoryFlags = RepositoryFlags,\n    C extends Context<F> = Context<F>,\n  >(this: R, context: C, data: V, key: keyof M, model: M) {\n    try {\n      switch (operation) {\n        case OperationKeys.CREATE:\n          (model as any)[key] = 1;\n          break;\n        case OperationKeys.UPDATE:\n          (model as any)[key]++;\n          break;\n        default:\n          throw new InternalError(`Invalid operation: ${operation}`);\n      }\n    } catch (e: unknown) {\n      throw new InternalError(`Failed to update version: ${e}`);\n    }\n  };\n}\n\n/**\n * @description Creates a decorator for versioning a property in a model.\n * @summary This decorator applies multiple sub-decorators to handle version management during create and update operations.\n *\n * @returns {Function} A composite decorator that:\n *   - Sets the type of the property to Number\n *   - Applies a version update on create operations\n *   - Applies a version update on update operations\n *   - Adds metadata indicating this property is used for versioning\n */\nexport function version() {\n  return apply(\n    type(Number.name),\n    onCreate(versionCreateUpdate(OperationKeys.CREATE)),\n    onUpdate(versionCreateUpdate(OperationKeys.UPDATE)),\n    propMetadata(Repository.key(DBKeys.VERSION), true)\n  );\n}\n\nexport function transient() {\n  return function transient(model: any, attribute: string) {\n    propMetadata(Repository.key(DBKeys.TRANSIENT), true)(model, attribute);\n    propMetadata(Repository.key(DBKeys.TRANSIENT), true)(model.constructor);\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../../src/model/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import { DBKeys, DefaultSeparator } from \"./constants\";\nimport { apply } from \"@decaf-ts/reflection\";\nimport {\n  Hashing,\n  Model,\n  propMetadata,\n  type,\n} from \"@decaf-ts/decorator-validation\";\nimport { onCreate, onCreateUpdate, onUpdate } from \"../operations/decorators\";\nimport { IRepository } from \"../interfaces/IRepository\";\nimport { InternalError } from \"../repository/errors\";\nimport { Repository } from \"../repository/Repository\";\nimport { Context } from \"../repository/Context\";\nimport { CrudOperations, OperationKeys } from \"../operations\";\nimport { RepositoryFlags } from \"../repository/types\";\n\n/**\n * @description Hashes a property value during create or update operations\n * @summary Callback function used by the hash decorator to apply hashing to a property value\n * @template M - Type extending Model\n * @template R - Type extending IRepository\n * @template V - Type for metadata\n * @template F - Type extending RepositoryFlags\n * @template C - Type extending Context\n * @param {C} context - The operation context\n * @param {V} data - Metadata for the operation\n * @param key - The property key to hash\n * @param {M} model - The model being processed\n * @param {M} [oldModel] - The previous model state (for updates)\n * @return {void}\n * @function hashOnCreateUpdate\n * @memberOf module:db-decorators\n */\nexport function hashOnCreateUpdate<\n  M extends Model,\n  R extends IRepository<M, F, C>,\n  V extends object,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n>(this: R, context: C, data: V, key: keyof M, model: M, oldModel?: M): void {\n  if (typeof model[key] === \"undefined\") return;\n  const hash = Hashing.hash((model as any)[key]);\n  if (oldModel && (model as any)[key] === hash) return;\n  model[key] = hash;\n}\n\n/**\n * @description Creates a decorator that hashes a property value\n * @summary Decorator that automatically hashes a property value during create and update operations\n * @return {PropertyDecorator} A decorator that can be applied to class properties\n * @function hash\n * @category Property Decorators\n */\nexport function hash() {\n  return apply(\n    onCreateUpdate(hashOnCreateUpdate),\n    propMetadata(Repository.key(DBKeys.HASH), {})\n  );\n}\n\n/**\n * @description Metadata for composed property decorators\n * @summary Configuration options for property composition from other properties\n * @typedef {Object} ComposedFromMetadata\n * @property {string[]} args - Property names to compose from\n * @property {string} separator - Character used to join the composed values\n * @property {boolean} hashResult - Whether to hash the composed result\n * @property {\"keys\"|\"values\"} type - Whether to use property keys or values\n * @property {string} [prefix] - Optional prefix to add to the composed value\n * @property {string} [suffix] - Optional suffix to add to the composed value\n * @memberOf module:db-decorators\n */\nexport type ComposedFromMetadata = {\n  args: string[];\n  separator: string;\n  hashResult: boolean;\n  type: \"keys\" | \"values\";\n  prefix?: string;\n  suffix?: string;\n};\n\n/**\n * @description Composes a property value from other properties during create or update operations\n * @summary Callback function used by composed decorators to generate a property value from other properties\n * @template M - Type extending Model\n * @template R - Type extending IRepository\n * @template V - Type extending ComposedFromMetadata\n * @template F - Type extending RepositoryFlags\n * @template C - Type extending Context\n * @param {C} context - The operation context\n * @param {V} data - Metadata for the composition\n * @param key - The property key to set the composed value on\n * @param {M} model - The model being processed\n * @return {void}\n * @function composedFromCreateUpdate\n * @memberOf module:db-decorators\n */\nexport function composedFromCreateUpdate<\n  M extends Model,\n  R extends IRepository<M, F, C>,\n  V extends ComposedFromMetadata,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n>(this: R, context: C, data: V, key: keyof M, model: M) {\n  try {\n    const { args, type, prefix, suffix, separator } = data;\n    const composed = args.map((arg: string) => {\n      if (!(arg in model))\n        throw new InternalError(`Property ${arg} not found to compose from`);\n      if (type === \"keys\") return arg;\n      if (typeof (model as any)[arg] === \"undefined\")\n        throw new InternalError(\n          `Property ${args} does not contain a value to compose from`\n        );\n      return ((model as any)[arg] as any).toString();\n    });\n\n    if (prefix) composed.unshift(prefix);\n    if (suffix) composed.push(suffix);\n\n    (model as any)[key] = composed.join(separator);\n  } catch (e: any) {\n    throw new InternalError(`Failed to compose value: ${e}`);\n  }\n}\n\n/**\n * @description Creates a decorator that composes a property value from other properties\n * @summary Base function for creating property composition decorators\n * @param {string[]} args - Property names to compose from\n * @param {boolean} [hashResult=false] - Whether to hash the composed result\n * @param {string} [separator=DefaultSeparator] - Character used to join the composed values\n * @param {\"keys\"|\"values\"} [type=\"values\"] - Whether to use property keys or values\n * @param {string} [prefix=\"\"] - Optional prefix to add to the composed value\n * @param {string} [suffix=\"\"] - Optional suffix to add to the composed value\n * @return {PropertyDecorator} A decorator that can be applied to class properties\n * @function composedFrom\n * @category PropertyDecorators\n */\nfunction composedFrom(\n  args: string[],\n  hashResult: boolean = false,\n  separator: string = DefaultSeparator,\n  type: \"keys\" | \"values\" = \"values\",\n  prefix = \"\",\n  suffix = \"\"\n) {\n  const data: ComposedFromMetadata = {\n    args: args,\n    hashResult: hashResult,\n    separator: separator,\n    type: type,\n    prefix: prefix,\n    suffix: suffix,\n  };\n\n  const decorators = [\n    onCreateUpdate(composedFromCreateUpdate, data),\n    propMetadata(Repository.key(DBKeys.COMPOSED), data),\n  ];\n  if (hashResult) decorators.push(hash());\n  return apply(...decorators);\n}\n\n/**\n * @description Creates a decorator that composes a property value from property keys\n * @summary Decorator that generates a property value by joining the names of other properties\n * @param {string[]} args - Property names to compose from\n * @param {string} [separator=DefaultSeparator] - Character used to join the property names\n * @param {boolean} [hash=false] - Whether to hash the composed result\n * @param {string} [prefix=\"\"] - Optional prefix to add to the composed value\n * @param {string} [suffix=\"\"] - Optional suffix to add to the composed value\n * @return {PropertyDecorator} A decorator that can be applied to class properties\n * @function composedFromKeys\n * @category PropertyDecorators\n */\nexport function composedFromKeys(\n  args: string[],\n  separator: string = DefaultSeparator,\n  hash: boolean = false,\n  prefix = \"\",\n  suffix = \"\"\n) {\n  return composedFrom(args, hash, separator, \"keys\", prefix, suffix);\n}\n\n/**\n * @description Creates a decorator that composes a property value from property values\n * @summary Decorator that generates a property value by joining the values of other properties\n * @param {string[]} args - Property names whose values will be composed\n * @param {string} [separator=DefaultSeparator] - Character used to join the property values\n * @param {boolean} [hash=false] - Whether to hash the composed result\n * @param {string} [prefix=\"\"] - Optional prefix to add to the composed value\n * @param {string} [suffix=\"\"] - Optional suffix to add to the composed value\n * @return {PropertyDecorator} A decorator that can be applied to class properties\n * @function composed\n * @category PropertyDecorators\n */\nexport function composed(\n  args: string[],\n  separator: string = DefaultSeparator,\n  hash: boolean = false,\n  prefix = \"\",\n  suffix = \"\"\n) {\n  return composedFrom(args, hash, separator, \"values\", prefix, suffix);\n}\n\n/**\n * @description Creates a function that updates a version property during operations\n * @summary Factory function that generates a callback for incrementing version numbers\n * @param {CrudOperations} operation - The type of operation (CREATE or UPDATE)\n * @return {Function} A callback function that updates the version property\n * @template M - Type extending Model\n * @template R - Type extending IRepository\n * @template V - Type for metadata\n * @template F - Type extending RepositoryFlags\n * @template C - Type extending Context\n * @function versionCreateUpdate\n * @memberOf module:db-decorators\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant versionCreateUpdate\n *\n *   Caller->>versionCreateUpdate: operation\n *   versionCreateUpdate-->>Caller: callback function\n *   Note over Caller,versionCreateUpdate: When callback is executed:\n *   Caller->>versionCreateUpdate: context, data, key, model\n *   alt operation is CREATE\n *     versionCreateUpdate->>versionCreateUpdate: set version to 1\n *   else operation is UPDATE\n *     versionCreateUpdate->>versionCreateUpdate: increment version\n *   else invalid operation\n *     versionCreateUpdate->>versionCreateUpdate: throw error\n *   end\n *   versionCreateUpdate-->>Caller: void\n */\nexport function versionCreateUpdate(operation: CrudOperations) {\n  return function versionCreateUpdate<\n    M extends Model,\n    R extends IRepository<M, F, C>,\n    V extends object,\n    F extends RepositoryFlags = RepositoryFlags,\n    C extends Context<F> = Context<F>,\n  >(this: R, context: C, data: V, key: keyof M, model: M) {\n    try {\n      switch (operation) {\n        case OperationKeys.CREATE:\n          (model as any)[key] = 1;\n          break;\n        case OperationKeys.UPDATE:\n          (model as any)[key]++;\n          break;\n        default:\n          throw new InternalError(`Invalid operation: ${operation}`);\n      }\n    } catch (e: unknown) {\n      throw new InternalError(`Failed to update version: ${e}`);\n    }\n  };\n}\n\n/**\n * @description Creates a decorator for versioning a property in a model\n * @summary This decorator applies multiple sub-decorators to handle version management during create and update operations\n * @return {PropertyDecorator} A composite decorator that sets the type to Number, manages version updates, and adds versioning metadata\n * @function version\n * @category PropertyDecorators\n */\nexport function version() {\n  return apply(\n    type(Number.name),\n    onCreate(versionCreateUpdate(OperationKeys.CREATE)),\n    onUpdate(versionCreateUpdate(OperationKeys.UPDATE)),\n    propMetadata(Repository.key(DBKeys.VERSION), true)\n  );\n}\n\n/**\n * @description Creates a decorator that marks a property as transient\n * @summary Decorator that indicates a property should not be persisted to the database\n * @return {PropertyDecorator} A decorator that can be applied to class properties\n * @function transient\n * @category PropertyDecorators\n */\nexport function transient() {\n  return function transient(model: any, attribute: string) {\n    propMetadata(Repository.key(DBKeys.TRANSIENT), true)(model, attribute);\n    propMetadata(Repository.key(DBKeys.TRANSIENT), true)(model.constructor);\n  };\n}\n"]}

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

@@ -2,4 +2,5 @@ export * from "./validation";
 export * from "./constants";
 export * from "./decorators";
 export * from "./model";
+export * from "./overrides";
 export * from "./utils";

package/lib/esm/model/index.js

@@ -1,6 +1,7 @@
-export * from "./validation";
-export * from "./constants";
-export * from "./decorators";
-export * from "./model";
-export * from "./utils";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbW9kZWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi92YWxpZGF0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL21vZGVsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi91dGlsc1wiO1xuIl19
+export * from "./validation.js";
+export * from "./constants.js";
+export * from "./decorators.js";
+export * from "./model.js";
+export * from "./overrides.js";
+export * from "./utils.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbW9kZWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZ0NBQTZCO0FBQzdCLCtCQUE0QjtBQUM1QixnQ0FBNkI7QUFDN0IsMkJBQXdCO0FBQ3hCLCtCQUE0QjtBQUM1QiwyQkFBd0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi92YWxpZGF0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL21vZGVsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9vdmVycmlkZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG4iXX0=