@decaf-ts/db-decorators 0.6.8 → 0.6.10

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,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

package/lib/operations/types.d.ts

@@ -18,7 +18,44 @@ 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>
+ * @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>;
 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;
 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;
 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;
+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;
+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

@@ -102,6 +102,8 @@ class Context {
     }
     /**
      * @description Retrieves a value from the context by key.
+     * @param {string} key
+     * @return {any}
      */
     get(key) {
         try {
@@ -161,4 +163,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  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"]}
+//# 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   * @param {string} key\n   * @return {any}\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"]}

package/lib/repository/Context.d.ts

@@ -91,6 +91,8 @@ export declare class Context<F extends RepositoryFlags> {
     get timestamp(): F["timestamp"];
     /**
      * @description Retrieves a value from the context by key.
+     * @param {string} key
+     * @return {any}
      */
     get<K extends keyof F>(key: K): F[K];
     /**

package/lib/repository/utils.cjs

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAllPropertyDecoratorsRecursive = exports.getHandlerArgs = void 0;
 exports.enforceDBDecorators = enforceDBDecorators;
 exports.getDbDecorators = getDbDecorators;
-const Operations_1 = require("./../operations/Operations.cjs");
 const constants_1 = require("./../operations/constants.cjs");
 const reflection_1 = require("@decaf-ts/reflection");
 const errors_1 = require("./errors.cjs");
 const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const decorators_1 = require("./../operations/decorators.cjs");
 /**
  * @summary retrieves the arguments for the handler
  * @param {any} dec the decorator
@@ -50,37 +50,29 @@ async function enforceDBDecorators(repo, context, model, operation, prefix, oldM
     const decorators = getDbDecorators(model, operation, prefix);
     if (!decorators)
         return;
-    for (const prop in decorators) {
-        const decs = decorators[prop];
-        for (const dec of decs) {
-            const { key } = dec;
-            const handlers = Operations_1.Operations.get(model, prop, prefix + key);
-            if (!handlers || !handlers.length)
-                throw new errors_1.InternalError(`Could not find registered handler for the operation ${prefix + key} under property ${prop}`);
-            const handlerArgs = (0, exports.getHandlerArgs)(dec, prop, model);
-            if (!handlerArgs || Object.values(handlerArgs).length !== handlers.length)
-                throw new errors_1.InternalError("Args and handlers length do not match");
-            let handler;
-            let data;
-            for (let i = 0; i < handlers.length; i++) {
-                handler = handlers[i];
-                data = Object.values(handlerArgs)[i];
-                const args = [context, data.data, prop, model];
-                if (operation === constants_1.OperationKeys.UPDATE && prefix === constants_1.OperationKeys.ON) {
-                    if (!oldModel)
-                        throw new errors_1.InternalError("Missing old model for update operation");
-                    args.push(oldModel);
-                }
-                try {
-                    await handler.apply(repo, args);
-                }
-                catch (e) {
-                    const msg = `Failed to execute handler ${handler.name} for ${prop} on ${model.constructor.name} due to error: ${e}`;
-                    if (context.get("breakOnHandlerError"))
-                        throw new errors_1.InternalError(msg);
-                    console.log(msg);
-                }
-            }
+    const hanlersDecorators = (0, decorators_1.getHandlersDecorators)(model, decorators, prefix);
+    const groupedDecorators = (0, decorators_1.groupDecorators)(hanlersDecorators);
+    const sortedDecorators = (0, decorators_1.sortDecorators)(groupedDecorators);
+    for (const dec of sortedDecorators) {
+        const args = [
+            context,
+            dec.data.length > 1 ? dec.data : dec.data[0],
+            dec.prop.length > 1 ? dec.prop : dec.prop[0],
+            model,
+        ];
+        if (operation === constants_1.OperationKeys.UPDATE && prefix === constants_1.OperationKeys.ON) {
+            if (!oldModel)
+                throw new errors_1.InternalError("Missing old model for update operation");
+            args.push(oldModel);
+        }
+        try {
+            await dec.handler.apply(repo, args);
+        }
+        catch (e) {
+            const msg = `Failed to execute handler ${dec.handler.name} for ${dec.prop} on ${model.constructor.name} due to error: ${e}`;
+            if (context.get("breakOnHandlerError"))
+                throw new errors_1.InternalError(msg);
+            console.log(msg);
         }
     }
 }
@@ -179,4 +171,4 @@ const getAllPropertyDecoratorsRecursive = function (model, accum, ...prefixes) {
     return (0, exports.getAllPropertyDecoratorsRecursive)(proto, accumulator, ...prefixes);
 };
 exports.getAllPropertyDecoratorsRecursive = getAllPropertyDecoratorsRecursive;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/repository/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { Operations } from \"../operations/Operations\";\nimport { OperationHandler, UpdateOperationHandler } from \"../operations/types\";\nimport { IRepository } from \"../interfaces/IRepository\";\nimport { OperationKeys } from \"../operations/constants\";\nimport { DecoratorMetadata, Reflection } from \"@decaf-ts/reflection\";\nimport { InternalError } from \"./errors\";\nimport { Constructor, Model, ModelKeys } from \"@decaf-ts/decorator-validation\";\nimport { Context } from \"./Context\";\nimport { RepositoryFlags } from \"./types\";\n\n/**\n * @description Context arguments for repository operations.\n * @summary Represents the context and arguments for repository operations.\n * This type is used to pass context and arguments between repository methods.\n * @template F - The repository flags type, defaults to RepositoryFlags\n * @template C - The context type, defaults to Context<F>\n * @typedef {Object} ContextArgs\n * @property {C} context - The operation context\n * @property {any[]} args - The operation arguments\n * @memberOf module:db-decorators\n */\nexport type ContextArgs<\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n> = {\n  context: C;\n  args: any[];\n};\n\n/**\n * @summary retrieves the arguments for the handler\n * @param {any} dec the decorator\n * @param {string} prop the property name\n * @param {{}} m the model\n * @param {{}} [accum] accumulator used for internal recursiveness\n *\n * @function getHandlerArgs\n * @memberOf module:db-decorators.Repository\n */\nexport const getHandlerArgs = function (\n  dec: any,\n  prop: string,\n  m: Constructor<any>,\n  accum?: Record<string, { args: string[] }>\n): Record<string, { args: string[] }> | void {\n  const name = m.constructor.name;\n  if (!name) throw new InternalError(\"Could not determine model class\");\n  accum = accum || {};\n\n  if (dec.props.handlers[name] && dec.props.handlers[name][prop])\n    accum = { ...dec.props.handlers[name][prop], ...accum };\n\n  let proto = Object.getPrototypeOf(m);\n  if (proto === Object.prototype) return accum;\n  if (proto.constructor.name === name) proto = Object.getPrototypeOf(proto);\n\n  return getHandlerArgs(dec, prop, proto, accum);\n};\n\n/**\n *\n * @param {IRepository<T>} repo\n * @param context\n * @param {T} model\n * @param operation\n * @param prefix\n *\n * @param oldModel\n * @function enforceDBPropertyDecoratorsAsync\n *\n * @memberOf db-decorators.utils\n */\nexport async function enforceDBDecorators<\n  M extends Model<true | false>,\n  R extends IRepository<M, F, C>,\n  V extends object = object,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n>(\n  repo: R,\n  context: C,\n  model: M,\n  operation: string,\n  prefix: string,\n  oldModel?: M\n): Promise<void> {\n  const decorators: Record<string, DecoratorMetadata[]> | undefined =\n    getDbDecorators(model, operation, prefix);\n\n  if (!decorators) return;\n\n  for (const prop in decorators) {\n    const decs: DecoratorMetadata[] = decorators[prop];\n    for (const dec of decs) {\n      const { key } = dec;\n      const handlers: OperationHandler<M, R, V, F, C>[] | undefined =\n        Operations.get<M, R, V, F, C>(model, prop, prefix + key);\n      if (!handlers || !handlers.length)\n        throw new InternalError(\n          `Could not find registered handler for the operation ${prefix + key} under property ${prop}`\n        );\n\n      const handlerArgs = getHandlerArgs(dec, prop, model as any);\n\n      if (!handlerArgs || Object.values(handlerArgs).length !== handlers.length)\n        throw new InternalError(\"Args and handlers length do not match\");\n\n      let handler: OperationHandler<M, R, V, F, C>;\n      let data: any;\n      for (let i = 0; i < handlers.length; i++) {\n        handler = handlers[i];\n        data = Object.values(handlerArgs)[i];\n\n        const args: any[] = [context, data.data, prop, model];\n\n        if (operation === OperationKeys.UPDATE && prefix === OperationKeys.ON) {\n          if (!oldModel)\n            throw new InternalError(\"Missing old model for update operation\");\n          args.push(oldModel);\n        }\n        try {\n          await (handler as UpdateOperationHandler<M, R, V, F, C>).apply(\n            repo,\n            args as [C, V, keyof M, M, M]\n          );\n        } catch (e: unknown) {\n          const msg = `Failed to execute handler ${handler.name} for ${prop} on ${model.constructor.name} due to error: ${e}`;\n          if (context.get(\"breakOnHandlerError\")) throw new InternalError(msg);\n          console.log(msg);\n        }\n      }\n    }\n  }\n}\n\n/**\n * Specific for DB Decorators\n * @param {T} model\n * @param {string} operation CRUD {@link OperationKeys}\n * @param {string} [extraPrefix]\n *\n * @function getDbPropertyDecorators\n *\n * @memberOf db-decorators.utils\n */\nexport function getDbDecorators<T extends Model>(\n  model: T,\n  operation: string,\n  extraPrefix?: string\n): Record<string, DecoratorMetadata[]> | undefined {\n  const decorators: Record<string, DecoratorMetadata[]> | undefined =\n    Reflection.getAllPropertyDecorators(\n      model,\n      // undefined,\n      OperationKeys.REFLECT + (extraPrefix ? extraPrefix : \"\")\n    );\n  if (!decorators) return;\n  return Object.keys(decorators).reduce(\n    (accum: Record<string, DecoratorMetadata[]> | undefined, decorator) => {\n      const dec = decorators[decorator].filter((d) => d.key === operation);\n      if (dec && dec.length) {\n        if (!accum) accum = {};\n        accum[decorator] = dec;\n      }\n      return accum;\n    },\n    undefined\n  );\n}\n\n/**\n * @summary Retrieves the decorators for an object's properties prefixed by {@param prefixes} recursively\n * @param model\n * @param accum\n * @param prefixes\n *\n * @function getAllPropertyDecoratorsRecursive\n * @memberOf module:db-decorators.Repository\n */\nexport const getAllPropertyDecoratorsRecursive = function <T extends Model>(\n  model: T,\n  accum: { [indexer: string]: any[] } | undefined,\n  ...prefixes: string[]\n): { [indexer: string]: any[] } | undefined {\n  const accumulator = accum || {};\n  const mergeDecorators = function (decs: { [indexer: string]: any[] }) {\n    const pushOrSquash = (key: string, ...values: any[]) => {\n      values.forEach((val) => {\n        let match: any;\n        if (\n          !(match = accumulator[key].find((e) => e.key === val.key)) ||\n          match.props.operation !== val.props.operation\n        ) {\n          accumulator[key].push(val);\n          return;\n        }\n\n        if (val.key === ModelKeys.TYPE) return;\n\n        const { handlers, operation } = val.props;\n\n        if (\n          !operation ||\n          !operation.match(\n            new RegExp(\n              `^(:?${OperationKeys.ON}|${OperationKeys.AFTER})(:?${OperationKeys.CREATE}|${OperationKeys.READ}|${OperationKeys.UPDATE}|${OperationKeys.DELETE})$`\n            )\n          )\n        ) {\n          accumulator[key].push(val);\n          return;\n        }\n\n        const accumHandlers = match.props.handlers;\n\n        Object.entries(handlers).forEach(([clazz, handlerDef]) => {\n          if (!(clazz in accumHandlers)) {\n            accumHandlers[clazz] = handlerDef;\n            return;\n          }\n\n          Object.entries(handlerDef as object).forEach(\n            ([handlerProp, handler]) => {\n              if (!(handlerProp in accumHandlers[clazz])) {\n                accumHandlers[clazz][handlerProp] = handler;\n                return;\n              }\n\n              Object.entries(handler as object).forEach(\n                ([handlerKey, argsObj]) => {\n                  if (!(handlerKey in accumHandlers[clazz][handlerProp])) {\n                    accumHandlers[clazz][handlerProp][handlerKey] = argsObj;\n                    return;\n                  }\n                  console.warn(\n                    `Skipping handler registration for ${clazz} under prop ${handlerProp} because handler is the same`\n                  );\n                }\n              );\n            }\n          );\n        });\n      });\n    };\n\n    Object.entries(decs).forEach(([key, value]) => {\n      accumulator[key] = accumulator[key] || [];\n      pushOrSquash(key, ...value);\n    });\n  };\n\n  const decs: { [indexer: string]: any[] } | undefined =\n    Reflection.getAllPropertyDecorators(model, ...prefixes);\n  if (decs) mergeDecorators(decs);\n\n  if (Object.getPrototypeOf(model) === Object.prototype) return accumulator;\n\n  // const name = model.constructor.name;\n  const proto = Object.getPrototypeOf(model);\n  if (!proto) return accumulator;\n  // if (proto.constructor && proto.constructor.name === name)\n  //     proto = Object.getPrototypeOf(proto)\n  return getAllPropertyDecoratorsRecursive(proto, accumulator, ...prefixes);\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/repository/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { IRepository } from \"../interfaces/IRepository\";\nimport { OperationKeys } from \"../operations/constants\";\nimport { DecoratorMetadata, Reflection } from \"@decaf-ts/reflection\";\nimport { InternalError } from \"./errors\";\nimport { Constructor, Model, ModelKeys } from \"@decaf-ts/decorator-validation\";\nimport { Context } from \"./Context\";\nimport { RepositoryFlags } from \"./types\";\nimport {\n  getHandlersDecorators,\n  groupDecorators,\n  sortDecorators,\n} from \"../operations/decorators\";\nimport { UpdateOperationHandler } from \"../operations/types\";\n\n/**\n * @description Context arguments for repository operations.\n * @summary Represents the context and arguments for repository operations.\n * This type is used to pass context and arguments between repository methods.\n * @template F - The repository flags type, defaults to RepositoryFlags\n * @template C - The context type, defaults to Context<F>\n * @typedef {Object} ContextArgs\n * @property {C} context - The operation context\n * @property {any[]} args - The operation arguments\n * @memberOf module:db-decorators\n */\nexport type ContextArgs<\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n> = {\n  context: C;\n  args: any[];\n};\n\n/**\n * @summary retrieves the arguments for the handler\n * @param {any} dec the decorator\n * @param {string} prop the property name\n * @param {{}} m the model\n * @param {{}} [accum] accumulator used for internal recursiveness\n *\n * @function getHandlerArgs\n * @memberOf module:db-decorators.Repository\n */\nexport const getHandlerArgs = function (\n  dec: any,\n  prop: string,\n  m: Constructor<any>,\n  accum?: Record<string, { args: string[] }>\n): Record<string, { args: string[] }> | void {\n  const name = m.constructor.name;\n  if (!name) throw new InternalError(\"Could not determine model class\");\n  accum = accum || {};\n\n  if (dec.props.handlers[name] && dec.props.handlers[name][prop])\n    accum = { ...dec.props.handlers[name][prop], ...accum };\n\n  let proto = Object.getPrototypeOf(m);\n  if (proto === Object.prototype) return accum;\n  if (proto.constructor.name === name) proto = Object.getPrototypeOf(proto);\n\n  return getHandlerArgs(dec, prop, proto, accum);\n};\n\n/**\n *\n * @param {IRepository<T>} repo\n * @param context\n * @param {T} model\n * @param operation\n * @param prefix\n *\n * @param oldModel\n * @function enforceDBPropertyDecoratorsAsync\n *\n * @memberOf db-decorators.utils\n */\nexport async function enforceDBDecorators<\n  M extends Model<true | false>,\n  R extends IRepository<M, F, C>,\n  V extends object = object,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n>(\n  repo: R,\n  context: C,\n  model: M,\n  operation: string,\n  prefix: string,\n  oldModel?: M\n): Promise<void> {\n  const decorators: Record<string, DecoratorMetadata[]> | undefined =\n    getDbDecorators(model, operation, prefix);\n\n  if (!decorators) return;\n\n  const hanlersDecorators = getHandlersDecorators(model, decorators, prefix);\n  const groupedDecorators = groupDecorators(hanlersDecorators);\n  const sortedDecorators = sortDecorators(groupedDecorators);\n\n  for (const dec of sortedDecorators) {\n    const args: any[] = [\n      context,\n      dec.data.length > 1 ? dec.data : dec.data[0],\n      dec.prop.length > 1 ? dec.prop : dec.prop[0],\n      model,\n    ];\n\n    if (operation === OperationKeys.UPDATE && prefix === OperationKeys.ON) {\n      if (!oldModel)\n        throw new InternalError(\"Missing old model for update operation\");\n      args.push(oldModel);\n    }\n    try {\n      await (dec.handler as UpdateOperationHandler<M, R, V, F, C>).apply(\n        repo,\n        args as [C, V, keyof M, M, M]\n      );\n    } catch (e: unknown) {\n      const msg = `Failed to execute handler ${dec.handler.name} for ${dec.prop} on ${model.constructor.name} due to error: ${e}`;\n      if (context.get(\"breakOnHandlerError\")) throw new InternalError(msg);\n      console.log(msg);\n    }\n  }\n}\n\n/**\n * Specific for DB Decorators\n * @param {T} model\n * @param {string} operation CRUD {@link OperationKeys}\n * @param {string} [extraPrefix]\n *\n * @function getDbPropertyDecorators\n *\n * @memberOf db-decorators.utils\n */\nexport function getDbDecorators<T extends Model>(\n  model: T,\n  operation: string,\n  extraPrefix?: string\n): Record<string, DecoratorMetadata[]> | undefined {\n  const decorators: Record<string, DecoratorMetadata[]> | undefined =\n    Reflection.getAllPropertyDecorators(\n      model,\n      // undefined,\n      OperationKeys.REFLECT + (extraPrefix ? extraPrefix : \"\")\n    );\n  if (!decorators) return;\n  return Object.keys(decorators).reduce(\n    (accum: Record<string, DecoratorMetadata[]> | undefined, decorator) => {\n      const dec = decorators[decorator].filter((d) => d.key === operation);\n      if (dec && dec.length) {\n        if (!accum) accum = {};\n        accum[decorator] = dec;\n      }\n      return accum;\n    },\n    undefined\n  );\n}\n\n/**\n * @summary Retrieves the decorators for an object's properties prefixed by {@param prefixes} recursively\n * @param model\n * @param accum\n * @param prefixes\n *\n * @function getAllPropertyDecoratorsRecursive\n * @memberOf module:db-decorators.Repository\n */\nexport const getAllPropertyDecoratorsRecursive = function <T extends Model>(\n  model: T,\n  accum: { [indexer: string]: any[] } | undefined,\n  ...prefixes: string[]\n): { [indexer: string]: any[] } | undefined {\n  const accumulator = accum || {};\n  const mergeDecorators = function (decs: { [indexer: string]: any[] }) {\n    const pushOrSquash = (key: string, ...values: any[]) => {\n      values.forEach((val) => {\n        let match: any;\n        if (\n          !(match = accumulator[key].find((e) => e.key === val.key)) ||\n          match.props.operation !== val.props.operation\n        ) {\n          accumulator[key].push(val);\n          return;\n        }\n\n        if (val.key === ModelKeys.TYPE) return;\n\n        const { handlers, operation } = val.props;\n\n        if (\n          !operation ||\n          !operation.match(\n            new RegExp(\n              `^(:?${OperationKeys.ON}|${OperationKeys.AFTER})(:?${OperationKeys.CREATE}|${OperationKeys.READ}|${OperationKeys.UPDATE}|${OperationKeys.DELETE})$`\n            )\n          )\n        ) {\n          accumulator[key].push(val);\n          return;\n        }\n\n        const accumHandlers = match.props.handlers;\n\n        Object.entries(handlers).forEach(([clazz, handlerDef]) => {\n          if (!(clazz in accumHandlers)) {\n            accumHandlers[clazz] = handlerDef;\n            return;\n          }\n\n          Object.entries(handlerDef as object).forEach(\n            ([handlerProp, handler]) => {\n              if (!(handlerProp in accumHandlers[clazz])) {\n                accumHandlers[clazz][handlerProp] = handler;\n                return;\n              }\n\n              Object.entries(handler as object).forEach(\n                ([handlerKey, argsObj]) => {\n                  if (!(handlerKey in accumHandlers[clazz][handlerProp])) {\n                    accumHandlers[clazz][handlerProp][handlerKey] = argsObj;\n                    return;\n                  }\n                  console.warn(\n                    `Skipping handler registration for ${clazz} under prop ${handlerProp} because handler is the same`\n                  );\n                }\n              );\n            }\n          );\n        });\n      });\n    };\n\n    Object.entries(decs).forEach(([key, value]) => {\n      accumulator[key] = accumulator[key] || [];\n      pushOrSquash(key, ...value);\n    });\n  };\n\n  const decs: { [indexer: string]: any[] } | undefined =\n    Reflection.getAllPropertyDecorators(model, ...prefixes);\n  if (decs) mergeDecorators(decs);\n\n  if (Object.getPrototypeOf(model) === Object.prototype) return accumulator;\n\n  // const name = model.constructor.name;\n  const proto = Object.getPrototypeOf(model);\n  if (!proto) return accumulator;\n  // if (proto.constructor && proto.constructor.name === name)\n  //     proto = Object.getPrototypeOf(proto)\n  return getAllPropertyDecoratorsRecursive(proto, accumulator, ...prefixes);\n};\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decaf-ts/db-decorators",
-  "version": "0.6.8",
+  "version": "0.6.10",
   "description": "Agnostic database decorators and repository",
   "type": "module",
   "exports": {
@@ -26,14 +26,21 @@
     "coverage": "rimraf ./workdocs/reports/data/*.json && npm run test:all -- --coverage --config=./workdocs/reports/jest.coverage.config.ts",
     "lint": "eslint .",
     "lint-fix": "eslint --fix .",
-    "prepare-pr": "npm run lint-fix && npm run build:prod && npm run coverage && npm run docs",
+    "prepare-pr": "npm run repo:pr && npm run lint-fix && npm run build:prod && npm run coverage && npm run docs",
     "prepare-release": "npm run lint-fix && npm run build:prod && npm run coverage && npm run docs",
     "release": "./bin/tag-release.sh",
     "clean-publish": "npx clean-publish",
     "drawings": "for FILE in workdocs/drawings/*.drawio; do echo \"converting $FILE to image...\" && docker run --rm -v $(pwd):/data rlespinasse/drawio-export --format png $FILE; done && cp -rf workdocs/drawings/export/* workdocs/resources/",
     "uml": "cd workdocs/uml && for FILE in ./*.puml; do docker run --rm -v $(pwd):/work -w /work miy4/plantuml -DPLANTUML_LIMIT_SIZE=8192 -tpng $FILE; done && cd ../.. && cp -fr workdocs/uml/*.png workdocs/resources/",
     "docs": "npx rimraf ./docs && mkdir docs && npx build-scripts --docs",
-    "publish-docs": "docker run -it --rm --user $(id -u):$(id -g) -v \"$(pwd)/workdocs/confluence:/content\" -e ATLASSIAN_API_TOKEN=$(cat .confluence-token) ghcr.io/markdown-confluence/publish:latest"
+    "publish-docs": "docker run -it --rm --user $(id -u):$(id -g) -v \"$(pwd)/workdocs/confluence:/content\" -e ATLASSIAN_API_TOKEN=$(cat .confluence-token) ghcr.io/markdown-confluence/publish:latest",
+    "repo:init": "codex exec \"$(cat ./.codex/prompts/repo-setup.md)\nbase_path is `./`, initialize the repository\"",
+    "repo:setup": "codex exec \"$(cat ./.codex/prompts/repo-setup.md)\nbase_path is ./\"",
+    "repo:doc": "codex exec \"$(cat ./.codex/prompts/doc.md) $(cat ./.codex/prompts/bulk-docs.md)\nbase_path is ./\"",
+    "repo:tests": "codex exec \"$(cat ./.codex/prompts/bulk-tests.md)\nbase_path is ./ and coverage is 95%\" -s workspace-write",
+    "repo:readme": "codex exec \"$(cat ./.codex/prompts/update-readme.md)\nbase_path is ./\"",
+    "repo:pr": "npm run repo:doc && npm run repo:tests && npm run repo:readme",
+    "sync-codex": "./bin/sync-codex.sh"
   },
   "repository": {
     "type": "git",
@@ -67,7 +74,7 @@
     "typescript",
     "ts"
   ],
-  "author": "Tiago Venceslau",
+  "author": "Tiago Venceslau and Contributors",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/decaf-ts/db-decorators/issues"