@decaf-ts/db-decorators 0.6.8 → 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/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.9",
   "description": "Agnostic database decorators and repository",
   "type": "module",
   "exports": {