@decaf-ts/db-decorators 0.6.7 → 0.6.9

package/lib/operations/decorators.d.ts

@@ -1,16 +1,82 @@
-import { IdOperationHandler, OperationHandler, StandardOperationHandler, UpdateOperationHandler } from "./types";
+import { GeneralOperationHandler, GeneralUpdateOperationHandler, IdOperationHandler, OperationHandler, StandardOperationHandler, UpdateOperationHandler } from "./types";
 import { OperationKeys } from "./constants";
+import { Model } from "@decaf-ts/decorator-validation";
+import { IRepository } from "../interfaces";
+import { RepositoryFlags } from "../repository/types";
+import { Context } from "../repository/Context";
+/**
+ * @description Represents sorting parameters for grouping decorators
+ * @summary Defines the structure for specifying group sorting options
+ * @typedef {Object} GroupSort
+ * @property {number} priority - The priority of the sorting operation, lower numbers represent higher priority
+ * @property {string} [group] - Optional property to group decorators, used for grouping related operations
+ * @property {number} [groupPriority] - Optional property to specify the priority within a group, lower numbers represent higher priority within the group
+ * @category Type Definitions
+ */
+export type GroupSort = {
+    priority: number;
+    group?: string;
+    groupPriority?: number;
+};
+/**
+ * @description DecoratorObject type definition
+ * @summary Defines the structure of an object used to represent a decorator in the context of database operations.
+ * @typedef {Object} DecoratorObject
+ * @property {OperationHandler<any, any, any, any, any>} handler - The handler function to be executed during the operation
+ * @property {object} data - Optional metadata to be passed to the handler function
+ * @property {string} prop - The property key to which the decorator is applied
+ * @category Type Definitions
+ */
+export type DecoratorObject = {
+    handler: OperationHandler<any, any, any, any, any>;
+    data: Record<string, any>[];
+    prop: string[];
+};
+/**
+ * @description Retrieves decorator objects for handling database operations
+ * @summary Retrieves a list of decorator objects representing operation handlers for a given model and decorators
+ * @template M - Type for the model, defaults to Model<true | false>
+ * @template R - Type for the repository, defaults to IRepository<M, F, C>
+ * @template V - Type for metadata, defaults to object
+ * @template F - Type for repository flags, defaults to RepositoryFlags
+ * @template C - Type for context, defaults to Context<F>
+ * @param {Model} model - The model for which to retrieve decorator objects
+ * @param {Record<string, DecoratorMetadata[]>} decorators - The decorators associated with the model properties
+ * @param {string} prefix - The operation prefix (e.g., 'on', 'after')
+ * @return {DecoratorObject[]} An array of decorator objects representing operation handlers
+ * @function getHandlersDecorators
+ * @category Function
+ */
+export declare function getHandlersDecorators<M extends Model<true | false>, R extends IRepository<M, F, C>, V extends object = object, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>>(model: Model, decorators: Record<string, DecoratorMetadata[]>, prefix: string): DecoratorObject[];
+/**
+ * @description Groups decorators based on their group property
+ * @summary Groups decorator objects by their group property, combining data and properties within each group
+ * @param {DecoratorObject[]} decorators - The array of decorator objects to group
+ * @return {DecoratorObject[]} An array of grouped decorator objects
+ * @function groupDecorators
+ * @category Function
+ */
+export declare function groupDecorators(decorators: DecoratorObject[]): DecoratorObject[];
+/**
+ * @description Sorts decorator objects based on their priority
+ * @summary Sorts an array of decorator objects by the priority of their first data element
+ * @param {DecoratorObject[]} decorators - The array of decorator objects to sort
+ * @return {DecoratorObject[]} The sorted array of decorator objects
+ * @function sortDecorators
+ * @category Function
+ */
+export declare function sortDecorators(decorators: DecoratorObject[]): DecoratorObject[];
 /**
  * @description Decorator for handling create and update operations
  * @summary Defines a behavior to execute during both create and update operations
  * @template V - Type for metadata, defaults to object
- * @param {StandardOperationHandler<any, any, V, any, any> | UpdateOperationHandler<any, any, V, any, any>} handler - The method called upon the operation
+ * @param {GeneralOperationHandler<any, any, V, any, any> | GeneralUpdateOperationHandler<any, any, V, any, any>} handler - The method called upon the operation
  * @param {V} [data] - Optional metadata to pass to the handler
  * @return {PropertyDecorator} A decorator that can be applied to class properties
  * @function onCreateUpdate
  * @category Property Decorators
  */
-export declare function onCreateUpdate<V = object>(handler: StandardOperationHandler<any, any, V, any, any> | UpdateOperationHandler<any, any, V, any, any>, data?: V): (target: object, propertyKey?: any) => void;
+export declare function onCreateUpdate<V = object>(handler: GeneralOperationHandler<any, any, V, any, any> | GeneralUpdateOperationHandler<any, any, V, any, any>, data?: V, groupsort?: GroupSort): (target: any, propertyKey?: any) => void;
 /**
  * @description Decorator for handling update operations
  * @summary Defines a behavior to execute during update operations
@@ -21,18 +87,18 @@ export declare function onCreateUpdate<V = object>(handler: StandardOperationHan
  * @function onUpdate
  * @category Property Decorators
  */
-export declare function onUpdate<V = object>(handler: UpdateOperationHandler<any, any, V, any>, data?: V): (target: object, propertyKey?: any) => void;
+export declare function onUpdate<V = object>(handler: UpdateOperationHandler<any, any, V, any>, data?: V, groupsort?: GroupSort): (target: any, propertyKey?: any) => void;
 /**
  * @description Decorator for handling create operations
  * @summary Defines a behavior to execute during create operations
  * @template V - Type for metadata, defaults to object
- * @param {StandardOperationHandler<any, any, V, any, any>} handler - The method called upon the operation
+ * @param {GeneralOperationHandler<any, any, V, any, any>} handler - The method called upon the operation
  * @param {V} [data] - Optional metadata to pass to the handler
  * @return {PropertyDecorator} A decorator that can be applied to class properties
  * @function onCreate
  * @category Property Decorators
  */
-export declare function onCreate<V = object>(handler: StandardOperationHandler<any, any, V, any, any>, data?: V): (target: object, propertyKey?: any) => void;
+export declare function onCreate<V = object>(handler: GeneralOperationHandler<any, any, V, any, any>, data?: V, groupsort?: GroupSort): (target: any, propertyKey?: any) => void;
 /**
  * @description Decorator for handling read operations
  * @summary Defines a behavior to execute during read operations
@@ -43,7 +109,7 @@ export declare function onCreate<V = object>(handler: StandardOperationHandler<a
  * @function onRead
  * @category Property Decorators
  */
-export declare function onRead<V = object>(handler: IdOperationHandler<any, any, V, any, any>, data: V): (target: object, propertyKey?: any) => void;
+export declare function onRead<V = object>(handler: IdOperationHandler<any, any, V, any, any>, data: V, groupsort?: GroupSort): (target: any, propertyKey?: any) => void;
 /**
  * @description Decorator for handling delete operations
  * @summary Defines a behavior to execute during delete operations
@@ -54,7 +120,7 @@ export declare function onRead<V = object>(handler: IdOperationHandler<any, any,
  * @function onDelete
  * @category Property Decorators
  */
-export declare function onDelete<V = object>(handler: OperationHandler<any, any, V, any, any>, data: V): (target: object, propertyKey?: any) => void;
+export declare function onDelete<V = object>(handler: OperationHandler<any, any, V, any, any>, data: V, groupsort?: GroupSort): (target: any, propertyKey?: any) => void;
 /**
  * @description Decorator for handling all operation types
  * @summary Defines a behavior to execute during any database operation
@@ -65,7 +131,7 @@ export declare function onDelete<V = object>(handler: OperationHandler<any, any,
  * @function onAny
  * @category Property Decorators
  */
-export declare function onAny<V = object>(handler: OperationHandler<any, any, V, any, any>, data: V): (target: object, propertyKey?: any) => void;
+export declare function onAny<V = object>(handler: OperationHandler<any, any, V, any, any>, data: V, groupsort?: GroupSort): (target: any, propertyKey?: any) => void;
 /**
  * @description Base decorator for handling database operations
  * @summary Defines a behavior to execute during specified database operations
@@ -83,7 +149,7 @@ export declare function onAny<V = object>(handler: OperationHandler<any, any, V,
  *   myProperty: string;
  * }
  */
-export declare function on<V = object>(op: OperationKeys[] | undefined, handler: OperationHandler<any, any, V, any, any>, data?: V): (target: object, propertyKey?: any) => void;
+export declare function on<V = object>(op: OperationKeys[] | undefined, handler: OperationHandler<any, any, V, any, any>, data?: V, groupsort?: GroupSort): (target: any, propertyKey?: any) => void;
 /**
  * @description Decorator for handling post-create and post-update operations
  * @summary Defines a behavior to execute after both create and update operations
@@ -94,7 +160,7 @@ export declare function on<V = object>(op: OperationKeys[] | undefined, handler:
  * @function afterCreateUpdate
  * @category Property Decorators
  */
-export declare function afterCreateUpdate<V = object>(handler: StandardOperationHandler<any, any, V, any, any> | UpdateOperationHandler<any, any, V, any, any>, data: V): (target: object, propertyKey?: any) => void;
+export declare function afterCreateUpdate<V = object>(handler: StandardOperationHandler<any, any, V, any, any> | UpdateOperationHandler<any, any, V, any, any>, data: V, groupsort?: GroupSort): (target: any, propertyKey?: any) => void;
 /**
  * @description Decorator for handling post-update operations
  * @summary Defines a behavior to execute after update operations
@@ -105,7 +171,7 @@ export declare function afterCreateUpdate<V = object>(handler: StandardOperation
  * @function afterUpdate
  * @category Property Decorators
  */
-export declare function afterUpdate<V = object>(handler: UpdateOperationHandler<any, any, V, any, any>, data: V): (target: object, propertyKey?: any) => void;
+export declare function afterUpdate<V = object>(handler: UpdateOperationHandler<any, any, V, any, any>, data: V, groupsort?: GroupSort): (target: any, propertyKey?: any) => void;
 /**
  * @description Decorator for handling post-create operations
  * @summary Defines a behavior to execute after create operations
@@ -116,7 +182,7 @@ export declare function afterUpdate<V = object>(handler: UpdateOperationHandler<
  * @function afterCreate
  * @category Property Decorators
  */
-export declare function afterCreate<V = object>(handler: StandardOperationHandler<any, any, V, any, any>, data: V): (target: object, propertyKey?: any) => void;
+export declare function afterCreate<V = object>(handler: StandardOperationHandler<any, any, V, any, any>, data: V, groupsort?: GroupSort): (target: any, propertyKey?: any) => void;
 /**
  * @description Decorator for handling post-read operations
  * @summary Defines a behavior to execute after read operations
@@ -127,7 +193,7 @@ export declare function afterCreate<V = object>(handler: StandardOperationHandle
  * @function afterRead
  * @category Property Decorators
  */
-export declare function afterRead<V = object>(handler: StandardOperationHandler<any, any, V, any, any>, data?: V): (target: object, propertyKey?: any) => void;
+export declare function afterRead<V = object>(handler: StandardOperationHandler<any, any, V, any, any>, data?: V, groupsort?: GroupSort): (target: any, propertyKey?: any) => void;
 /**
  * @description Decorator for handling post-delete operations
  * @summary Defines a behavior to execute after delete operations
@@ -138,7 +204,7 @@ export declare function afterRead<V = object>(handler: StandardOperationHandler<
  * @function afterDelete
  * @category Property Decorators
  */
-export declare function afterDelete<V = object>(handler: StandardOperationHandler<any, any, V, any, any>, data?: V): (target: object, propertyKey?: any) => void;
+export declare function afterDelete<V = object>(handler: StandardOperationHandler<any, any, V, any, any>, data?: V, groupsort?: GroupSort): (target: any, propertyKey?: any) => void;
 /**
  * @description Decorator for handling post-operation for all operation types
  * @summary Defines a behavior to execute after any database operation
@@ -149,7 +215,7 @@ export declare function afterDelete<V = object>(handler: StandardOperationHandle
  * @function afterAny
  * @category Property Decorators
  */
-export declare function afterAny<V = object>(handler: StandardOperationHandler<any, any, V, any, any>, data?: V): (target: object, propertyKey?: any) => void;
+export declare function afterAny<V = object>(handler: StandardOperationHandler<any, any, V, any, any>, data?: V, groupsort?: GroupSort): (target: any, propertyKey?: any) => void;
 /**
  * @description Base decorator for handling post-operation behaviors
  * @summary Defines a behavior to execute after specified database operations
@@ -167,7 +233,7 @@ export declare function afterAny<V = object>(handler: StandardOperationHandler<a
  *   myProperty: string;
  * }
  */
-export declare function after<V = object>(op: OperationKeys[] | undefined, handler: OperationHandler<any, any, V, any, any>, data?: V): (target: object, propertyKey?: any) => void;
+export declare function after<V = object>(op: OperationKeys[] | undefined, handler: OperationHandler<any, any, V, any, any>, data?: V, groupsort?: GroupSort): (target: any, propertyKey?: any) => void;
 /**
  * @description Core decorator factory for operation handlers
  * @summary Creates decorators that register handlers for database operations
@@ -196,4 +262,4 @@ export declare function after<V = object>(op: OperationKeys[] | undefined, handl
  *   Handler-->>Operations: Return result
  *   Operations-->>Client: Return final result
  */
-export declare function operation<V = object>(baseOp: OperationKeys.ON | OperationKeys.AFTER, operation: OperationKeys[] | undefined, handler: OperationHandler<any, any, V, any, any>, dataToAdd?: V): (target: object, propertyKey?: any) => void;
+export declare function operation<V = object>(baseOp: OperationKeys.ON | OperationKeys.AFTER, operation: OperationKeys[] | undefined, handler: OperationHandler<any, any, V, any, any>, dataToAdd?: V, groupsort?: GroupSort): (target: any, propertyKey?: any) => void;

package/lib/operations/types.cjs

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/operations/types.ts"],"names":[],"mappings":"","sourcesContent":["import { OperationKeys } from \"./constants\";\nimport { IRepository } from \"../interfaces/IRepository\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { Context } from \"../repository/Context\";\nimport { RepositoryFlags } from \"../repository/types\";\n\n/**\n * @description Metadata for database operations\n * @summary Contains information about an operation, its handler, and associated metadata\n * @template V - Type of the metadata\n * @typedef {Object} OperationMetadata\n * @property {OperationKeys} operation - The type of operation\n * @property {string} handler - The name of the handler function\n * @property {V} [metadata] - Optional metadata associated with the operation\n * @memberOf module:db-decorators\n */\nexport type OperationMetadata<V> = {\n  operation: OperationKeys;\n  handler: string;\n  metadata?: V;\n};\n\n/**\n * @description Union type for all operation handler types\n * @summary Represents any type of operation handler function that can be used with database operations\n * @template M - Model type extending Model\n * @template R - Repository type extending IRepository\n * @template V - Metadata type, defaults to object\n * @template F - Repository flags extending RepositoryFlags\n * @template C - Context type extending Context<F>\n * @typedef {(StandardOperationHandler<M, R, V, F, C> | UpdateOperationHandler<M, R, V, F, C> | IdOperationHandler<M, R, V, F, C>)} OperationHandler\n * @memberOf module:db-decorators\n */\nexport type OperationHandler<\n  M extends Model,\n  R extends IRepository<M, F, C>,\n  V = object,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n> =\n  | StandardOperationHandler<M, R, V, F, C>\n  | UpdateOperationHandler<M, R, V, F, C>\n  | IdOperationHandler<M, R, V, F, C>\n  | GroupOperationHandler<M, R, V, F, C>\n  | GroupUpdateOperationHandler<M, R, V, F, C>;\n\n/**\n * @description Handler type for standard database operations\n * @summary Function signature for handlers that process standard operations like create and read\n * @template M - Model type extending Model\n * @template R - Repository type extending IRepository\n * @template V - Metadata type, defaults to object\n * @template F - Repository flags extending RepositoryFlags\n * @template C - Context type extending Context<F>\n * @typedef {Function} StandardOperationHandler\n * @param {R} this - The repository instance (this context)\n * @param {C} context - The operation context\n * @param {V} metadata - Metadata associated with the operation\n * @param {keyof M} key - The property key being operated on\n * @param {M} model - The model instance being operated on\n * @return {Promise<void> | void} Nothing or a Promise resolving to nothing\n * @memberOf module:db-decorators\n */\nexport type StandardOperationHandler<\n  M extends Model,\n  R extends IRepository<M, F, C>,\n  V = object,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n> = (\n  this: R,\n  context: C,\n  metadata: V,\n  key: keyof M,\n  model: M\n) => Promise<void> | void;\n\n/**\n * @description Handler type for ID-based database operations\n * @summary Function signature for handlers that process operations using only an ID (like read by ID)\n * @template M - Model type extending Model\n * @template R - Repository type extending IRepository\n * @template V - Metadata type, defaults to object\n * @template F - Repository flags extending RepositoryFlags\n * @template C - Context type extending Context<F>\n * @typedef {Function} IdOperationHandler\n * @param {R} this - The repository instance (this context)\n * @param {C} context - The operation context\n * @param {V} decorator - Metadata associated with the operation\n * @param {keyof M} key - The property key being operated on\n * @param {string} id - The ID of the model being operated on\n * @return {Promise<void> | void} Nothing or a Promise resolving to nothing\n * @memberOf module:db-decorators\n */\nexport type IdOperationHandler<\n  M extends Model,\n  R extends IRepository<M, F, C>,\n  V = object,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n> = (\n  this: R,\n  context: C,\n  decorator: V,\n  key: keyof M,\n  id: string\n) => Promise<void> | void;\n\n/**\n * @description Handler type for update database operations\n * @summary Function signature for handlers that process update operations with both new and old model states\n * @template M - Model type extending Model\n * @template R - Repository type extending IRepository\n * @template V - Metadata type, defaults to object\n * @template F - Repository flags extending RepositoryFlags\n * @template C - Context type extending Context<F>\n * @typedef {Function} UpdateOperationHandler\n * @param {R} this - The repository instance (this context)\n * @param {C} context - The operation context\n * @param {V} decorator - Metadata associated with the operation\n * @param {keyof M} key - The property key being operated on\n * @param {M} model - The new model instance after update\n * @param {M} oldModel - The original model instance before update\n * @return {Promise<void> | void} Nothing or a Promise resolving to nothing\n * @memberOf module:db-decorators\n */\nexport type UpdateOperationHandler<\n  M extends Model,\n  R extends IRepository<M, F, C>,\n  V = object,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n> = (\n  this: R,\n  context: C,\n  decorator: V,\n  key: keyof M,\n  model: M,\n  oldModel: M\n) => Promise<void> | void;\n\n/**\n * @description Handler type for standard database operations\n * @summary Function signature for handlers that process standard operations like create and read\n * @template M - Model type extending Model\n * @template R - Repository type extending IRepository\n * @template V - Metadata type, defaults to object\n * @template F - Repository flags extending RepositoryFlags\n * @template C - Context type extending Context<F>\n * @typedef {Function} StandardOperationHandler\n * @param {R} this - The repository instance (this context)\n * @param {C} context - The operation context\n * @param {V} metadata - Metadata associated with the operation\n * @param {keyof M} key - The property key being operated on\n * @param {M} model - The model instance being operated on\n * @return {Promise<void> | void} Nothing or a Promise resolving to nothing\n * @memberOf module:db-decorators\n */\nexport type GroupOperationHandler<\n  M extends Model,\n  R extends IRepository<M, F, C>,\n  V = object,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n> = (\n  this: R,\n  context: C,\n  metadata: V[],\n  keys: (keyof M)[],\n  model: M\n) => Promise<void> | void;\n\n/**\n * @description Handler type for grouped update database operations\n * @summary Function signature for handlers that process update operations with both new and old model states\n * @template M - Model type extending Model\n * @template R - Repository type extending IRepository\n * @template V - Metadata type, defaults to object\n * @template F - Repository flags extending RepositoryFlags\n * @template C - Context type extending Context<F>\n * @typedef {Function} GroupUpdateOperationHandler\n * @param {R} this - The repository instance (this context)\n * @param {C} context - The operation context\n * @param {V} metadata - Metadata associated with the operation\n * @param {keyof M} keys - The property key being operated on\n * @param {M} model - The model instance being operated on\n * @return {Promise<void> | void} Nothing or a Promise resolving to nothing\n * @memberOf module:db-decorators\n */\nexport type GroupUpdateOperationHandler<\n  M extends Model,\n  R extends IRepository<M, F, C>,\n  V = object,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n> = (\n  this: R,\n  context: C,\n  decorator: V[],\n  keys: (keyof M)[],\n  model: M,\n  oldModel: M\n) => Promise<void> | void;\n\n/**\n * @description General handler type for database operations\n * @summary Function signature for handlers that process operations like create and read\n * @template M - Model type extending Model\n * @template R - Repository type extending IRepository\n * @template V - Metadata type, defaults to object\n * @template F - Repository flags extending RepositoryFlags\n * @template C - Context type extending Context<F>\n * @typedef {Function} GeneralOperationHandler\n * @return {Promise<void> | void} Nothing or a Promise resolving to nothing\n * @memberOf module:db-decorators\n */\nexport type GeneralOperationHandler<\n  M extends Model,\n  R extends IRepository<M, F, C>,\n  V = object,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n> =\n  | StandardOperationHandler<M, R, V, F, C>\n  | GroupOperationHandler<M, R, V, F, C>;\n\n/**\n * @description General handler type for group update database operations\n * @summary Function signature for handlers that process update operations with both new and old model states\n * @template M - Model type extending Model\n * @template R - Repository type extending IRepository\n * @template V - Metadata type, defaults to object\n * @template F - Repository flags extending RepositoryFlags\n * @template C - Context type extending Context<F>\n * @typedef {Function} GeneralUpdateOperationHandler\n * @memberOf module:db-decorators\n */\nexport type GeneralUpdateOperationHandler<\n  M extends Model,\n  R extends IRepository<M, F, C>,\n  V = object,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n> =\n  | UpdateOperationHandler<M, R, V, F, C>\n  | GroupUpdateOperationHandler<M, R, V, F, C>;\n"]}

package/lib/operations/types.d.ts

@@ -18,7 +18,131 @@ export type OperationMetadata<V> = {
     handler: string;
     metadata?: V;
 };
-export type OperationHandler<M extends Model, R extends IRepository<M, F, C>, V = object, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>> = StandardOperationHandler<M, R, V, F, C> | UpdateOperationHandler<M, R, V, F, C> | IdOperationHandler<M, R, V, F, C>;
+/**
+ * @description Union type for all operation handler types
+ * @summary Represents any type of operation handler function that can be used with database operations
+ * @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>
+ * @typedef {(StandardOperationHandler<M, R, V, F, C> | UpdateOperationHandler<M, R, V, F, C> | IdOperationHandler<M, R, V, F, C>)} OperationHandler
+ * @memberOf module:db-decorators
+ */
+export type OperationHandler<M extends Model, R extends IRepository<M, F, C>, V = object, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>> = StandardOperationHandler<M, R, V, F, C> | UpdateOperationHandler<M, R, V, F, C> | IdOperationHandler<M, R, V, F, C> | GroupOperationHandler<M, R, V, F, C> | GroupUpdateOperationHandler<M, R, V, F, C>;
+/**
+ * @description Handler type for standard database operations
+ * @summary Function signature for handlers that process standard operations like create and read
+ * @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>
+ * @typedef {Function} StandardOperationHandler
+ * @param {R} this - The repository instance (this context)
+ * @param {C} context - The operation context
+ * @param {V} metadata - Metadata associated with the operation
+ * @param {keyof M} key - The property key being operated on
+ * @param {M} model - The model instance being operated on
+ * @return {Promise<void> | void} Nothing or a Promise resolving to nothing
+ * @memberOf module:db-decorators
+ */
 export type StandardOperationHandler<M extends Model, R extends IRepository<M, F, C>, V = object, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>> = (this: R, context: C, metadata: V, key: keyof M, model: M) => Promise<void> | void;
+/**
+ * @description Handler type for ID-based database operations
+ * @summary Function signature for handlers that process operations using only an ID (like read by ID)
+ * @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>
+ * @typedef {Function} IdOperationHandler
+ * @param {R} this - The repository instance (this context)
+ * @param {C} context - The operation context
+ * @param {V} decorator - Metadata associated with the operation
+ * @param {keyof M} key - The property key being operated on
+ * @param {string} id - The ID of the model being operated on
+ * @return {Promise<void> | void} Nothing or a Promise resolving to nothing
+ * @memberOf module:db-decorators
+ */
 export type IdOperationHandler<M extends Model, R extends IRepository<M, F, C>, V = object, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>> = (this: R, context: C, decorator: V, key: keyof M, id: string) => Promise<void> | void;
+/**
+ * @description Handler type for update database operations
+ * @summary Function signature for handlers that process update operations with both new and old model states
+ * @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>
+ * @typedef {Function} UpdateOperationHandler
+ * @param {R} this - The repository instance (this context)
+ * @param {C} context - The operation context
+ * @param {V} decorator - Metadata associated with the operation
+ * @param {keyof M} key - The property key being operated on
+ * @param {M} model - The new model instance after update
+ * @param {M} oldModel - The original model instance before update
+ * @return {Promise<void> | void} Nothing or a Promise resolving to nothing
+ * @memberOf module:db-decorators
+ */
 export type UpdateOperationHandler<M extends Model, R extends IRepository<M, F, C>, V = object, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>> = (this: R, context: C, decorator: V, key: keyof M, model: M, oldModel: M) => Promise<void> | void;
+/**
+ * @description Handler type for standard database operations
+ * @summary Function signature for handlers that process standard operations like create and read
+ * @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>
+ * @typedef {Function} StandardOperationHandler
+ * @param {R} this - The repository instance (this context)
+ * @param {C} context - The operation context
+ * @param {V} metadata - Metadata associated with the operation
+ * @param {keyof M} key - The property key being operated on
+ * @param {M} model - The model instance being operated on
+ * @return {Promise<void> | void} Nothing or a Promise resolving to nothing
+ * @memberOf module:db-decorators
+ */
+export type GroupOperationHandler<M extends Model, R extends IRepository<M, F, C>, V = object, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>> = (this: R, context: C, metadata: V[], keys: (keyof M)[], model: M) => Promise<void> | void;
+/**
+ * @description Handler type for grouped update database operations
+ * @summary Function signature for handlers that process update operations with both new and old model states
+ * @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>
+ * @typedef {Function} GroupUpdateOperationHandler
+ * @param {R} this - The repository instance (this context)
+ * @param {C} context - The operation context
+ * @param {V} metadata - Metadata associated with the operation
+ * @param {keyof M} keys - The property key being operated on
+ * @param {M} model - The model instance being operated on
+ * @return {Promise<void> | void} Nothing or a Promise resolving to nothing
+ * @memberOf module:db-decorators
+ */
+export type GroupUpdateOperationHandler<M extends Model, R extends IRepository<M, F, C>, V = object, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>> = (this: R, context: C, decorator: V[], keys: (keyof M)[], model: M, oldModel: M) => Promise<void> | void;
+/**
+ * @description General handler type for database operations
+ * @summary Function signature for handlers that process operations like create and read
+ * @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>
+ * @typedef {Function} GeneralOperationHandler
+ * @return {Promise<void> | void} Nothing or a Promise resolving to nothing
+ * @memberOf module:db-decorators
+ */
+export type GeneralOperationHandler<M extends Model, R extends IRepository<M, F, C>, V = object, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>> = StandardOperationHandler<M, R, V, F, C> | GroupOperationHandler<M, R, V, F, C>;
+/**
+ * @description General handler type for group update database operations
+ * @summary Function signature for handlers that process update operations with both new and old model states
+ * @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>
+ * @typedef {Function} GeneralUpdateOperationHandler
+ * @memberOf module:db-decorators
+ */
+export type GeneralUpdateOperationHandler<M extends Model, R extends IRepository<M, F, C>, V = object, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>> = UpdateOperationHandler<M, R, V, F, C> | GroupUpdateOperationHandler<M, R, V, F, C>;

package/lib/repository/Context.cjs

@@ -87,11 +87,6 @@ class Context {
      * @description Accumulates new values into the context.
      * @summary Merges the provided value object with the existing context state,
      * creating a new immutable cache state.
-     *
-     * @template F - current accumulator type
-     * @template V - Type extending object for the values to accumulate
-     * @param {V} value - The object containing values to accumulate
-     * @returns A new context instance with accumulated values
      */
     accumulate(value) {
         Object.defineProperty(this, "cache", {
@@ -107,64 +102,26 @@ class Context {
     }
     /**
      * @description Retrieves a value from the context by key.
-     * @summary Attempts to get a value from the current context's cache.
-     * If not found, traverses up the parent context chain.
-     *
-     * @template K - Type extending keyof F for the key to retrieve
-     * @template F - Accumulator type
-     * @param {K} key - The key to retrieve from the context
-     * @returns The value associated with the key
-     * @throws {Error} If the key is not found in the context chain
      */
     get(key) {
         try {
             return this.cache.get(key);
         }
         catch (e) {
-            if (this.cache.parentContext)
-                return this.cache.parentContext.get(key);
+            const parent = this.cache.parentContext;
+            if (parent)
+                return parent.get(key);
             throw e;
         }
     }
-    /**
-     * @description Creates a child context
-     * @summary Generates a new context instance with current context as parent
-     *
-     * @template M - Type extending Model
-     * @param {OperationKeys} operation - The operation type
-     * @param {Constructor<M>} [model] - Optional model constructor
-     * @returns {C} New child context instance
-     */
-    child(operation, model) {
-        return Context.childFrom(this, {
-            operation: operation,
-            affectedTables: model ? [model] : [],
-        });
-    }
     /**
      * @description Creates a child context from another context
-     * @summary Generates a new context instance with parent reference
-     *
-     * @template F - Type extending Repository Flags
-     * @template C - Type extending Context<F>
-     * @param {C} context - The parent context
-     * @param {Partial<F>} [overrides] - Optional flag overrides
-     * @returns {C} New child context instance
      */
     static childFrom(context, overrides) {
         return Context.factory(Object.assign({}, context.cache, overrides || {}));
     }
     /**
      * @description Creates a new context from operation parameters
-     * @summary Generates a context instance for specific operation
-     *
-     * @template F - Type extending Repository Flags
-     * @template M - Type extending Model
-     * @param {OperationKeys.DELETE} operation - The operation type
-     * @param {Partial<F>} overrides - Flag overrides
-     * @param {Constructor<M>} model - The model constructor
-     * @param {any} args - Operation arguments
-     * @returns {Promise<C>} Promise resolving to new context
      */
     static async from(operation, overrides, model, 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -176,30 +133,6 @@ class Context {
     }
     /**
      * @description Prepares arguments for context operations
-     * @summary Creates a context args object with the specified operation parameters
-     *
-     * @template F - Type extending {@link RepositoryFlags}
-     * @template M - Type extending {@link Model}
-     * @param {OperationKeys.DELETE} operation - The operation type
-     * @param {Constructor<M>} model - The model constructor
-     * @param {any[]} args - Operation arguments
-     * @param {Contextual<F>} [contextual] - Optional contextual object
-     * @param {Partial<F>} [overrides] - Optional flag overrides
-     * @returns {Promise<ContextArgs>} Promise resolving to context arguments
-     *
-     * @mermaid
-     * sequenceDiagram
-     *   participant C as Context
-     *   participant M as Model
-     *   participant A as Args
-     *
-     *   C->>C: Receive operation request
-     *   C->>M: Validate model constructor
-     *   C->>C: Create child context
-     *   C->>A: Process operation args
-     *   A->>C: Return context args
-     *   C->>C: Apply overrides
-     *   C->>C: Return final context
      */
     static async args(operation, model, args, contextual, overrides) {
         const last = args.pop();
@@ -228,4 +161,4 @@ class Context {
     }
 }
 exports.Context = Context;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Context.js","sourceRoot":"","sources":["../../src/repository/Context.ts"],"names":[],"mappings":"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","sourcesContent":["import { ContextArgs } from \"./utils\";\nimport { Contextual } from \"../interfaces/Contextual\";\nimport { OperationKeys } from \"../operations/constants\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { DefaultRepositoryFlags } from \"./constants\";\nimport { ObjectAccumulator } from \"typed-object-accumulator\";\nimport { RepositoryFlags } from \"./types\";\n\n/**\n * @description Factory type for creating context instances.\n * @summary Defines a function type that creates context instances with specific repository flags.\n * @template F - The repository flags type extending RepositoryFlags\n * @typedef {Function} ContextFactory\n * @memberOf module:db-decorators\n */\nexport type ContextFactory<F extends RepositoryFlags> = <C extends Context<F>>(\n  arg: Omit<F, \"timestamp\">\n) => C;\n\n/**\n * @description Default factory for creating context instances.\n * @summary A factory function that creates new Context instances with the provided repository flags.\n * It automatically adds a timestamp to the context and returns a properly typed context instance.\n * @const DefaultContextFactory\n * @memberOf module:db-decorators\n */\nexport const DefaultContextFactory: ContextFactory<any> = <\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  arg: Omit<F, \"timestamp\">\n) => {\n  return new Context<F>().accumulate(\n    Object.assign({}, arg, { timestamp: new Date() }) as F\n  ) as C;\n};\n\n/**\n * @description A context management class for handling repository operations.\n * @summary The Context class provides a mechanism for managing repository operations with flags,\n * parent-child relationships, and state accumulation. It allows for hierarchical context chains\n * and maintains operation-specific configurations while supporting type safety through generics.\n *\n * @template F - Type extending RepositoryFlags that defines the context configuration\n *\n * @param {ObjectAccumulator<F>} cache - The internal cache storing accumulated values\n *\n * @class\n *\n * @example\n * ```typescript\n * // Creating a new context with repository flags\n * const context = new Context<RepositoryFlags>();\n *\n * // Accumulating values\n * const enrichedContext = context.accumulate({\n *   writeOperation: true,\n *   affectedTables: ['users'],\n *   operation: OperationKeys.CREATE\n * });\n *\n * // Accessing values\n * const isWrite = enrichedContext.get('writeOperation'); // true\n * const tables = enrichedContext.get('affectedTables'); // ['users']\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant Ctx as Context\n *   participant Cache as ObjectAccumulator\n *\n *   C->>Ctx: new Context()\n *   Ctx->>Cache: create cache\n *\n *   C->>Ctx: accumulate(value)\n *   Ctx->>Cache: accumulate(value)\n *   Cache-->>Ctx: updated cache\n *   Ctx-->>C: updated context\n *\n *   C->>Ctx: get(key)\n *   Ctx->>Cache: get(key)\n *   alt Key exists in cache\n *     Cache-->>Ctx: value\n *   else Key not found\n *     Ctx->>Ctx: check parent context\n *     alt Parent exists\n *       Ctx->>Parent: get(key)\n *       Parent-->>Ctx: value\n *     else No parent\n *       Ctx-->>C: throw error\n *     end\n *   end\n *   Ctx-->>C: requested value\n */\nexport class Context<F extends RepositoryFlags> {\n  constructor() {\n    Object.defineProperty(this, \"cache\", {\n      value: new ObjectAccumulator<F>(),\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    });\n  }\n\n  static factory: ContextFactory<any> = DefaultContextFactory;\n\n  private readonly cache: F & ObjectAccumulator<F> =\n    new ObjectAccumulator() as F & ObjectAccumulator<F>;\n\n  /**\n   * @description Accumulates new values into the context.\n   * @summary Merges the provided value object with the existing context state,\n   * creating a new immutable cache state.\n   *\n   * @template F - current accumulator type\n   * @template V - Type extending object for the values to accumulate\n   * @param {V} value - The object containing values to accumulate\n   * @returns A new context instance with accumulated values\n   */\n  accumulate<V extends object>(value: V) {\n    Object.defineProperty(this, \"cache\", {\n      value: this.cache.accumulate(value),\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    });\n    return this as unknown as Context<F & V>;\n  }\n\n  get timestamp() {\n    return this.cache.timestamp;\n  }\n\n  /**\n   * @description Retrieves a value from the context by key.\n   * @summary Attempts to get a value from the current context's cache.\n   * If not found, traverses up the parent context chain.\n   *\n   * @template K - Type extending keyof F for the key to retrieve\n   * @template F - Accumulator type\n   * @param {K} key - The key to retrieve from the context\n   * @returns The value associated with the key\n   * @throws {Error} If the key is not found in the context chain\n   */\n  get<K extends keyof F>(key: K): F[K] {\n    try {\n      return this.cache.get(key);\n    } catch (e: unknown) {\n      if (this.cache.parentContext) return this.cache.parentContext.get(key);\n      throw e;\n    }\n  }\n\n  /**\n   * @description Creates a child context\n   * @summary Generates a new context instance with current context as parent\n   *\n   * @template M - Type extending Model\n   * @param {OperationKeys} operation - The operation type\n   * @param {Constructor<M>} [model] - Optional model constructor\n   * @returns {C} New child context instance\n   */\n  child<M extends Model, C extends Context<F>>(\n    operation: OperationKeys,\n    model?: Constructor<M>\n  ): C {\n    return Context.childFrom<F, C>(\n      this as unknown as C,\n      {\n        operation: operation,\n        affectedTables: model ? [model] : [],\n      } as unknown as Partial<F>\n    );\n  }\n\n  /**\n   * @description Creates a child context from another context\n   * @summary Generates a new context instance with parent reference\n   *\n   * @template F - Type extending Repository Flags\n   * @template C - Type extending Context<F>\n   * @param {C} context - The parent context\n   * @param {Partial<F>} [overrides] - Optional flag overrides\n   * @returns {C} New child context instance\n   */\n  static childFrom<F extends RepositoryFlags, C extends Context<F>>(\n    context: C,\n    overrides?: Partial<F>\n  ): C {\n    return Context.factory(\n      Object.assign({}, context.cache, overrides || {})\n    ) as unknown as C;\n  }\n\n  /**\n   * @description Creates a new context from operation parameters\n   * @summary Generates a context instance for specific operation\n   *\n   * @template F - Type extending Repository Flags\n   * @template M - Type extending Model\n   * @param {OperationKeys.DELETE} operation - The operation type\n   * @param {Partial<F>} overrides - Flag overrides\n   * @param {Constructor<M>} model - The model constructor\n   * @param {any} args - Operation arguments\n   * @returns {Promise<C>} Promise resolving to new context\n   */\n  static async from<\n    M extends Model,\n    F extends RepositoryFlags,\n    C extends Context<F>,\n  >(\n    operation:\n      | OperationKeys.CREATE\n      | OperationKeys.READ\n      | OperationKeys.UPDATE\n      | OperationKeys.DELETE,\n    overrides: Partial<F>,\n    model: Constructor<M>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Promise<C> {\n    return Context.factory(\n      Object.assign({}, DefaultRepositoryFlags, overrides, {\n        operation: operation,\n        model: model,\n      })\n    ) as C;\n  }\n\n  /**\n   * @description Prepares arguments for context operations\n   * @summary Creates a context args object with the specified operation parameters\n   *\n   * @template F - Type extending {@link RepositoryFlags}\n   * @template M - Type extending {@link Model}\n   * @param {OperationKeys.DELETE} operation - The operation type\n   * @param {Constructor<M>} model - The model constructor\n   * @param {any[]} args - Operation arguments\n   * @param {Contextual<F>} [contextual] - Optional contextual object\n   * @param {Partial<F>} [overrides] - Optional flag overrides\n   * @returns {Promise<ContextArgs>} Promise resolving to context arguments\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Context\n   *   participant M as Model\n   *   participant A as Args\n   *\n   *   C->>C: Receive operation request\n   *   C->>M: Validate model constructor\n   *   C->>C: Create child context\n   *   C->>A: Process operation args\n   *   A->>C: Return context args\n   *   C->>C: Apply overrides\n   *   C->>C: Return final context\n   */\n  static async args<\n    M extends Model<any>,\n    C extends Context<F>,\n    F extends RepositoryFlags,\n  >(\n    operation:\n      | OperationKeys.CREATE\n      | OperationKeys.READ\n      | OperationKeys.UPDATE\n      | OperationKeys.DELETE,\n    model: Constructor<M>,\n    args: any[],\n    contextual?: Contextual<F>,\n    overrides?: Partial<F>\n  ): Promise<ContextArgs<F, C>> {\n    const last = args.pop();\n\n    async function getContext() {\n      if (contextual)\n        return contextual.context(operation, overrides || {}, model, ...args);\n      return Context.from(operation, overrides || {}, model, ...args);\n    }\n\n    let c: C;\n    if (last) {\n      if (last instanceof Context) {\n        c = last as C;\n        args.push(last);\n      } else {\n        args.push(last);\n        c = (await getContext()) as C;\n        args.push(c);\n      }\n    } else {\n      c = (await getContext()) as C;\n      args.push(c);\n    }\n\n    return { context: c, args: args };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Context.js","sourceRoot":"","sources":["../../src/repository/Context.ts"],"names":[],"mappings":"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","sourcesContent":["import { ContextArgs } from \"./utils\";\nimport { Contextual } from \"../interfaces/Contextual\";\nimport { OperationKeys } from \"../operations/constants\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { DefaultRepositoryFlags } from \"./constants\";\nimport { ObjectAccumulator } from \"typed-object-accumulator\";\nimport { RepositoryFlags } from \"./types\";\n\n/**\n * @description Factory type for creating context instances.\n * @summary Defines a function type that creates context instances with specific repository flags.\n * @template F - The repository flags type extending RepositoryFlags\n * @typedef {Function} ContextFactory\n * @memberOf module:db-decorators\n */\nexport type ContextFactory<F extends RepositoryFlags> = <C extends Context<F>>(\n  arg: Omit<F, \"timestamp\">\n) => C;\n\n/**\n * @description Default factory for creating context instances.\n * @summary A factory function that creates new Context instances with the provided repository flags.\n * It automatically adds a timestamp to the context and returns a properly typed context instance.\n * @const DefaultContextFactory\n * @memberOf module:db-decorators\n */\nexport const DefaultContextFactory: ContextFactory<any> = <\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  arg: Omit<F, \"timestamp\">\n) => {\n  return new Context<F>().accumulate(\n    Object.assign({}, arg, { timestamp: new Date() }) as F\n  ) as C;\n};\n\n/**\n * @description A context management class for handling repository operations.\n * @summary The Context class provides a mechanism for managing repository operations with flags,\n * parent-child relationships, and state accumulation. It allows for hierarchical context chains\n * and maintains operation-specific configurations while supporting type safety through generics.\n *\n * @template F - Type extending RepositoryFlags that defines the context configuration\n *\n * @param {ObjectAccumulator<F>} cache - The internal cache storing accumulated values\n *\n * @class\n *\n * @example\n * ```typescript\n * // Creating a new context with repository flags\n * const context = new Context<RepositoryFlags>();\n *\n * // Accumulating values\n * const enrichedContext = context.accumulate({\n *   writeOperation: true,\n *   affectedTables: ['users'],\n *   operation: OperationKeys.CREATE\n * });\n *\n * // Accessing values\n * const isWrite = enrichedContext.get('writeOperation'); // true\n * const tables = enrichedContext.get('affectedTables'); // ['users']\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant Ctx as Context\n *   participant Cache as ObjectAccumulator\n *\n *   C->>Ctx: new Context()\n *   Ctx->>Cache: create cache\n *\n *   C->>Ctx: accumulate(value)\n *   Ctx->>Cache: accumulate(value)\n *   Cache-->>Ctx: updated cache\n *   Ctx-->>C: updated context\n *\n *   C->>Ctx: get(key)\n *   Ctx->>Cache: get(key)\n *   alt Key exists in cache\n *     Cache-->>Ctx: value\n *   else Key not found\n *     Ctx->>Ctx: check parent context\n *     alt Parent exists\n *       Ctx->>Parent: get(key)\n *       Parent-->>Ctx: value\n *     else No parent\n *       Ctx-->>C: throw error\n *     end\n *   end\n *   Ctx-->>C: requested value\n */\nexport class Context<F extends RepositoryFlags> {\n  constructor() {\n    Object.defineProperty(this, \"cache\", {\n      value: new ObjectAccumulator<F>(),\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    });\n  }\n\n  static factory: ContextFactory<any> = DefaultContextFactory;\n\n  readonly cache: RepositoryFlags & ObjectAccumulator<any> =\n    new ObjectAccumulator() as unknown as RepositoryFlags &\n      ObjectAccumulator<any>;\n\n  /**\n   * @description Accumulates new values into the context.\n   * @summary Merges the provided value object with the existing context state,\n   * creating a new immutable cache state.\n   */\n  accumulate<V extends object>(value: V) {\n    Object.defineProperty(this, \"cache\", {\n      value: (this.cache as ObjectAccumulator<any>).accumulate(value),\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    });\n    return this as unknown as Context<F & V>;\n  }\n\n  get timestamp() {\n    return (this.cache as any).timestamp as F[\"timestamp\"];\n  }\n\n  /**\n   * @description Retrieves a value from the context by key.\n   */\n  get<K extends keyof F>(key: K): F[K] {\n    try {\n      return (this.cache as ObjectAccumulator<any>).get(\n        key as unknown as string\n      ) as F[K];\n    } catch (e: unknown) {\n      const parent = (this.cache as any).parentContext as\n        | Context<F>\n        | undefined;\n      if (parent) return parent.get(key);\n      throw e;\n    }\n  }\n\n  /**\n   * @description Creates a child context from another context\n   */\n  static childFrom<F extends RepositoryFlags, C extends Context<F>>(\n    context: C,\n    overrides?: Partial<F>\n  ): C {\n    return Context.factory(\n      Object.assign({}, (context as any).cache, overrides || {})\n    ) as unknown as C;\n  }\n\n  /**\n   * @description Creates a new context from operation parameters\n   */\n  static async from<\n    M extends Model,\n    F extends RepositoryFlags,\n    C extends Context<F>,\n  >(\n    operation:\n      | OperationKeys.CREATE\n      | OperationKeys.READ\n      | OperationKeys.UPDATE\n      | OperationKeys.DELETE,\n    overrides: Partial<F>,\n    model: Constructor<M>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Promise<C> {\n    return Context.factory(\n      Object.assign({}, DefaultRepositoryFlags as RepositoryFlags, overrides, {\n        operation: operation,\n        model: model,\n      })\n    ) as C;\n  }\n\n  /**\n   * @description Prepares arguments for context operations\n   */\n  static async args<\n    M extends Model<any>,\n    C extends Context<F>,\n    F extends RepositoryFlags,\n  >(\n    operation:\n      | OperationKeys.CREATE\n      | OperationKeys.READ\n      | OperationKeys.UPDATE\n      | OperationKeys.DELETE,\n    model: Constructor<M>,\n    args: any[],\n    contextual?: Contextual<F>,\n    overrides?: Partial<F>\n  ): Promise<ContextArgs<F, C>> {\n    const last = args.pop();\n\n    async function getContext() {\n      if (contextual)\n        return contextual.context(operation, overrides || {}, model, ...args);\n      return Context.from(operation, overrides || {}, model, ...args);\n    }\n\n    let c: C;\n    if (last) {\n      if (last instanceof Context) {\n        c = last as C;\n        args.push(last);\n      } else {\n        args.push(last);\n        c = (await getContext()) as C;\n        args.push(c);\n      }\n    } else {\n      c = (await getContext()) as C;\n      args.push(c);\n    }\n\n    return { context: c, args: args };\n  }\n}\n"]}