@decaf-ts/db-decorators 0.6.0 → 0.6.2

package/lib/esm/operations/Operations.js

@@ -1,34 +1,96 @@
 import { Hashing } from "@decaf-ts/decorator-validation";
-import { OperationsRegistry } from "./OperationsRegistry";
-import { OperationKeys } from "./constants";
+import { OperationsRegistry } from "./OperationsRegistry.js";
+import { OperationKeys } from "./constants.js";
 /**
- * @summary Static class holding common Operation Functionality
- *
+ * @description Static utility class for database operation management
+ * @summary Provides functionality for registering, retrieving, and managing database operation handlers
  * @class Operations
+ * @template M - Model type
+ * @template R - Repository type
+ * @template V - Metadata type
+ * @template F - Repository flags
+ * @template C - Context type
+ * @example
+ * // Register a handler for a create operation
+ * Operations.register(myHandler, OperationKeys.CREATE, targetModel, 'propertyName');
+ *
+ * // Get handlers for a specific operation
+ * const handlers = Operations.get(targetModel.constructor.name, 'propertyName', 'onCreate');
  *
- * @category Operations
+ * @mermaid
+ * classDiagram
+ *   class Operations {
+ *     -registry: OperationsRegistry
+ *     +getHandlerName(handler)
+ *     +key(str)
+ *     +get(targetName, propKey, operation)
+ *     -getOpRegistry()
+ *     +register(handler, operation, target, propKey)
+ *   }
+ *   Operations --> OperationsRegistry : uses
  */
 export class Operations {
     constructor() { }
+    /**
+     * @description Gets a unique name for an operation handler
+     * @summary Returns the name of the handler function or generates a hash if name is not available
+     * @param {OperationHandler<any, any, any, any, any>} handler - The handler function to get the name for
+     * @return {string} The name of the handler or a generated hash
+     */
     static getHandlerName(handler) {
         if (handler.name)
             return handler.name;
         console.warn("Handler name not defined. A name will be generated, but this is not desirable. please avoid using anonymous functions");
         return Hashing.hash(handler.toString());
     }
+    /**
+     * @description Generates a reflection metadata key
+     * @summary Creates a fully qualified metadata key by prefixing with the reflection namespace
+     * @param {string} str - The operation key string to prefix
+     * @return {string} The fully qualified metadata key
+     */
     static key(str) {
         return OperationKeys.REFLECT + str;
     }
+    /**
+     * @description Retrieves operation handlers for a specific target and operation
+     * @summary Gets registered handlers from the operations registry for a given target, property, and operation
+     * @template M - Model type extending Model
+     * @template R - Repository type extending IRepository
+     * @template V - Metadata type, defaults to object
+     * @template F - Repository flags extending RepositoryFlags
+     * @template C - Context type extending Context<F>
+     * @param {string | Record<string, any>} targetName - The target class name or object
+     * @param {string} propKey - The property key to get handlers for
+     * @param {string} operation - The operation key to get handlers for
+     * @return {any} The registered handlers for the specified target, property, and operation
+     */
     static get(targetName, propKey, operation) {
         return Operations.registry.get(targetName, propKey, operation);
     }
+    /**
+     * @description Gets or initializes the operations registry
+     * @summary Returns the existing registry or creates a new one if it doesn't exist
+     * @return {OperationsRegistry} The operations registry instance
+     * @private
+     */
     static getOpRegistry() {
         if (!Operations.registry)
             Operations.registry = new OperationsRegistry();
         return Operations.registry;
     }
+    /**
+     * @description Registers an operation handler for a specific target and operation
+     * @summary Adds a handler to the operations registry for a given target, property, and operation
+     * @template V - Model type extending Model
+     * @param {OperationHandler<V, any, any>} handler - The handler function to register
+     * @param {OperationKeys} operation - The operation key to register the handler for
+     * @param {V} target - The target model instance
+     * @param {string | symbol} propKey - The property key to register the handler for
+     * @return {void}
+     */
     static register(handler, operation, target, propKey) {
         Operations.getOpRegistry().register(handler, operation, target, propKey);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Operations.js","sourceRoot":"","sources":["../../../src/operations/Operations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAS,MAAM,gCAAgC,CAAC;AAEhE,OAAO,EAAE,kBAAkB,EAAE,gCAA6B;AAC1D,OAAO,EAAE,aAAa,EAAE,uBAAoB;AAK5C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,OAAO,UAAU;IAGrB,gBAAuB,CAAC;IAExB;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAC,OAAkD;QACtE,IAAI,OAAO,CAAC,IAAI;YAAE,OAAO,OAAO,CAAC,IAAI,CAAC;QAEtC,OAAO,CAAC,IAAI,CACV,uHAAuH,CACxH,CAAC;QACF,OAAO,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,GAAG,CAAC,GAAW;QACpB,OAAO,aAAa,CAAC,OAAO,GAAG,GAAG,CAAC;IACrC,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,GAAG,CAOR,UAAwC,EACxC,OAAe,EACf,SAAiB;QAEjB,OAAO,UAAU,CAAC,QAAQ,CAAC,GAAG,CAC5B,UAAU,EACV,OAAO,EACP,SAAS,CACV,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACK,MAAM,CAAC,aAAa;QAC1B,IAAI,CAAC,UAAU,CAAC,QAAQ;YAAE,UAAU,CAAC,QAAQ,GAAG,IAAI,kBAAkB,EAAE,CAAC;QACzE,OAAO,UAAU,CAAC,QAAQ,CAAC;IAC7B,CAAC;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,QAAQ,CACb,OAAsC,EACtC,SAAwB,EACxB,MAAS,EACT,OAAwB;QAExB,UAAU,CAAC,aAAa,EAAE,CAAC,QAAQ,CACjC,OAAc,EACd,SAAS,EACT,MAAM,EACN,OAAO,CACR,CAAC;IACJ,CAAC;CACF","sourcesContent":["import { Hashing, Model } from \"@decaf-ts/decorator-validation\";\nimport { OperationHandler } from \"./types\";\nimport { OperationsRegistry } from \"./OperationsRegistry\";\nimport { OperationKeys } from \"./constants\";\nimport { IRepository } from \"../interfaces\";\nimport { Context } from \"../repository\";\nimport { RepositoryFlags } from \"../repository/types\";\n\n/**\n * @description Static utility class for database operation management\n * @summary Provides functionality for registering, retrieving, and managing database operation handlers\n * @class Operations\n * @template M - Model type\n * @template R - Repository type\n * @template V - Metadata type\n * @template F - Repository flags\n * @template C - Context type\n * @example\n * // Register a handler for a create operation\n * Operations.register(myHandler, OperationKeys.CREATE, targetModel, 'propertyName');\n * \n * // Get handlers for a specific operation\n * const handlers = Operations.get(targetModel.constructor.name, 'propertyName', 'onCreate');\n * \n * @mermaid\n * classDiagram\n *   class Operations {\n *     -registry: OperationsRegistry\n *     +getHandlerName(handler)\n *     +key(str)\n *     +get(targetName, propKey, operation)\n *     -getOpRegistry()\n *     +register(handler, operation, target, propKey)\n *   }\n *   Operations --> OperationsRegistry : uses\n */\nexport class Operations {\n  private static registry: OperationsRegistry;\n\n  private constructor() {}\n\n  /**\n   * @description Gets a unique name for an operation handler\n   * @summary Returns the name of the handler function or generates a hash if name is not available\n   * @param {OperationHandler<any, any, any, any, any>} handler - The handler function to get the name for\n   * @return {string} The name of the handler or a generated hash\n   */\n  static getHandlerName(handler: OperationHandler<any, any, any, any, any>) {\n    if (handler.name) return handler.name;\n\n    console.warn(\n      \"Handler name not defined. A name will be generated, but this is not desirable. please avoid using anonymous functions\"\n    );\n    return Hashing.hash(handler.toString());\n  }\n\n  /**\n   * @description Generates a reflection metadata key\n   * @summary Creates a fully qualified metadata key by prefixing with the reflection namespace\n   * @param {string} str - The operation key string to prefix\n   * @return {string} The fully qualified metadata key\n   */\n  static key(str: string) {\n    return OperationKeys.REFLECT + str;\n  }\n\n  /**\n   * @description Retrieves operation handlers for a specific target and operation\n   * @summary Gets registered handlers from the operations registry for a given target, property, and operation\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   * @param {string | Record<string, any>} targetName - The target class name or object\n   * @param {string} propKey - The property key to get handlers for\n   * @param {string} operation - The operation key to get handlers for\n   * @return {any} The registered handlers for the specified target, property, and operation\n   */\n  static get<\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    targetName: string | Record<string, any>,\n    propKey: string,\n    operation: string\n  ) {\n    return Operations.registry.get<M, R, V, F, C>(\n      targetName,\n      propKey,\n      operation\n    );\n  }\n\n  /**\n   * @description Gets or initializes the operations registry\n   * @summary Returns the existing registry or creates a new one if it doesn't exist\n   * @return {OperationsRegistry} The operations registry instance\n   * @private\n   */\n  private static getOpRegistry() {\n    if (!Operations.registry) Operations.registry = new OperationsRegistry();\n    return Operations.registry;\n  }\n\n  /**\n   * @description Registers an operation handler for a specific target and operation\n   * @summary Adds a handler to the operations registry for a given target, property, and operation\n   * @template V - Model type extending Model\n   * @param {OperationHandler<V, any, any>} handler - The handler function to register\n   * @param {OperationKeys} operation - The operation key to register the handler for\n   * @param {V} target - The target model instance\n   * @param {string | symbol} propKey - The property key to register the handler for\n   * @return {void}\n   */\n  static register<V extends Model>(\n    handler: OperationHandler<V, any, any>,\n    operation: OperationKeys,\n    target: V,\n    propKey: string | symbol\n  ) {\n    Operations.getOpRegistry().register(\n      handler as any,\n      operation,\n      target,\n      propKey\n    );\n  }\n}\n"]}

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

@@ -5,32 +5,60 @@ import { Model } from "@decaf-ts/decorator-validation";
 import { Context } from "../repository";
 import { RepositoryFlags } from "../repository/types";
 /**
- * @summary Holds the registered operation handlers
- *
+ * @description Registry for database operation handlers
+ * @summary Manages and stores operation handlers for different model properties and operations
  * @class OperationsRegistry
- * @implements IRegistry<OperationHandler<any>>
+ * @template M - Model type
+ * @template R - Repository type
+ * @template V - Metadata type
+ * @template F - Repository flags
+ * @template C - Context type
+ * @example
+ * // Create a registry and register a handler
+ * const registry = new OperationsRegistry();
+ * registry.register(myHandler, OperationKeys.CREATE, targetModel, 'propertyName');
  *
- * @see OperationHandler
+ * // Get handlers for a specific operation
+ * const handlers = registry.get(targetModel.constructor.name, 'propertyName', 'onCreate');
  *
- * @category Operations
+ * @mermaid
+ * classDiagram
+ *   class OperationsRegistry {
+ *     -cache: Record~string, Record~string|symbol, Record~string, Record~string, OperationHandler~~~~
+ *     +get(target, propKey, operation, accum)
+ *     +register(handler, operation, target, propKey)
+ *   }
  */
 export declare class OperationsRegistry {
     private readonly cache;
     /**
-     * @summary retrieves an {@link OperationHandler} if it exists
-     * @param {string} target
-     * @param {string} propKey
-     * @param {string} operation
-     * @param accum
-     * @return {OperationHandler | undefined}
+     * @description Retrieves operation handlers for a specific target and operation
+     * @summary Finds all registered handlers for a given target, property, and operation, including from parent classes
+     * @template M - Model type extending Model
+     * @template R - Repository type extending IRepository
+     * @template V - Metadata type
+     * @template F - Repository flags extending RepositoryFlags
+     * @template C - Context type extending Context<F>
+     * @param {string | Record<string, any>} target - The target class name or object
+     * @param {string} propKey - The property key to get handlers for
+     * @param {string} operation - The operation key to get handlers for
+     * @param {OperationHandler[]} [accum] - Accumulator for recursive calls
+     * @return {OperationHandler[] | undefined} Array of handlers or undefined if none found
      */
     get<M extends Model, R extends IRepository<M, F, C>, V, F extends RepositoryFlags, C extends Context<F>>(target: string | Record<string, any>, propKey: string, operation: string, accum?: OperationHandler<M, R, V, F, C>[]): OperationHandler<M, R, V, F, C>[] | undefined;
     /**
-     * @summary Registers an {@link OperationHandler}
-     * @param {OperationHandler} handler
-     * @param {string} operation
-     * @param {{}} target
-     * @param {string | symbol} propKey
+     * @description Registers an operation handler for a specific target and operation
+     * @summary Stores a handler in the registry for a given target, property, and operation
+     * @template M - Model type extending Model
+     * @template R - Repository type extending IRepository
+     * @template V - Metadata type
+     * @template F - Repository flags extending RepositoryFlags
+     * @template C - Context type extending Context<F>
+     * @param {OperationHandler} handler - The handler function to register
+     * @param {OperationKeys} operation - The operation key to register the handler for
+     * @param {M} target - The target model instance
+     * @param {string | symbol} propKey - The property key to register the handler for
+     * @return {void}
      */
     register<M extends Model, R extends IRepository<M, F, C>, V, F extends RepositoryFlags, C extends Context<F>>(handler: OperationHandler<M, R, V, F, C>, operation: OperationKeys, target: M, propKey: string | symbol): void;
 }

package/lib/esm/operations/OperationsRegistry.js

@@ -1,25 +1,46 @@
-import { Operations } from "./Operations";
+import { Operations } from "./Operations.js";
 /**
- * @summary Holds the registered operation handlers
- *
+ * @description Registry for database operation handlers
+ * @summary Manages and stores operation handlers for different model properties and operations
  * @class OperationsRegistry
- * @implements IRegistry<OperationHandler<any>>
+ * @template M - Model type
+ * @template R - Repository type
+ * @template V - Metadata type
+ * @template F - Repository flags
+ * @template C - Context type
+ * @example
+ * // Create a registry and register a handler
+ * const registry = new OperationsRegistry();
+ * registry.register(myHandler, OperationKeys.CREATE, targetModel, 'propertyName');
  *
- * @see OperationHandler
+ * // Get handlers for a specific operation
+ * const handlers = registry.get(targetModel.constructor.name, 'propertyName', 'onCreate');
  *
- * @category Operations
+ * @mermaid
+ * classDiagram
+ *   class OperationsRegistry {
+ *     -cache: Record~string, Record~string|symbol, Record~string, Record~string, OperationHandler~~~~
+ *     +get(target, propKey, operation, accum)
+ *     +register(handler, operation, target, propKey)
+ *   }
  */
 export class OperationsRegistry {
     constructor() {
         this.cache = {};
     }
     /**
-     * @summary retrieves an {@link OperationHandler} if it exists
-     * @param {string} target
-     * @param {string} propKey
-     * @param {string} operation
-     * @param accum
-     * @return {OperationHandler | undefined}
+     * @description Retrieves operation handlers for a specific target and operation
+     * @summary Finds all registered handlers for a given target, property, and operation, including from parent classes
+     * @template M - Model type extending Model
+     * @template R - Repository type extending IRepository
+     * @template V - Metadata type
+     * @template F - Repository flags extending RepositoryFlags
+     * @template C - Context type extending Context<F>
+     * @param {string | Record<string, any>} target - The target class name or object
+     * @param {string} propKey - The property key to get handlers for
+     * @param {string} operation - The operation key to get handlers for
+     * @param {OperationHandler[]} [accum] - Accumulator for recursive calls
+     * @return {OperationHandler[] | undefined} Array of handlers or undefined if none found
      */
     get(target, propKey, operation, accum) {
         accum = accum || [];
@@ -41,11 +62,18 @@ export class OperationsRegistry {
         return this.get(proto, propKey, operation, accum);
     }
     /**
-     * @summary Registers an {@link OperationHandler}
-     * @param {OperationHandler} handler
-     * @param {string} operation
-     * @param {{}} target
-     * @param {string | symbol} propKey
+     * @description Registers an operation handler for a specific target and operation
+     * @summary Stores a handler in the registry for a given target, property, and operation
+     * @template M - Model type extending Model
+     * @template R - Repository type extending IRepository
+     * @template V - Metadata type
+     * @template F - Repository flags extending RepositoryFlags
+     * @template C - Context type extending Context<F>
+     * @param {OperationHandler} handler - The handler function to register
+     * @param {OperationKeys} operation - The operation key to register the handler for
+     * @param {M} target - The target model instance
+     * @param {string | symbol} propKey - The property key to register the handler for
+     * @return {void}
      */
     register(handler, operation, target, propKey) {
         const name = target.constructor.name;
@@ -61,4 +89,4 @@ export class OperationsRegistry {
         this.cache[name][propKey][operation][handlerName] = handler;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"OperationsRegistry.js","sourceRoot":"","sources":["../../../src/operations/OperationsRegistry.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,wBAAqB;AAK1C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,OAAO,kBAAkB;IAA/B;QACmB,UAAK,GAMlB,EAAE,CAAC;IAuFT,CAAC;IArFC;;;;;;;;;;;;;OAaG;IACH,GAAG,CAOD,MAAoC,EACpC,OAAe,EACf,SAAiB,EACjB,KAAyC;QAEzC,KAAK,GAAG,KAAK,IAAI,EAAE,CAAC;QACpB,IAAI,IAAI,CAAC;QACT,IAAI,CAAC;YACH,IAAI,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC;YACrE,KAAK,CAAC,OAAO,CACX,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAC7D,CAAC;YACF,6DAA6D;QAC/D,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,IACE,OAAO,MAAM,KAAK,QAAQ;gBAC1B,MAAM,KAAK,MAAM,CAAC,SAAS;gBAC3B,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC,SAAS;gBAElD,OAAO,KAAK,CAAC;QACjB,CAAC;QAED,IAAI,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QAC1C,IAAI,KAAK,CAAC,WAAW,CAAC,IAAI,KAAK,IAAI;YAAE,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAE1E,OAAO,IAAI,CAAC,GAAG,CAAgB,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IACnE,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAON,OAAwC,EACxC,SAAwB,EACxB,MAAS,EACT,OAAwB;QAExB,MAAM,IAAI,GAAG,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC;QACrC,MAAM,WAAW,GAAG,UAAU,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAEvD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;YAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7C,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC;YAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC;QAC/D,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC;YACvC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC;QAC5C,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,WAAW,CAAC;YAAE,OAAO;QAC9D,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC;IAC9D,CAAC;CACF","sourcesContent":["import { OperationHandler } from \"./types\";\nimport { OperationKeys } from \"./constants\";\nimport { IRepository } from \"../interfaces/IRepository\";\nimport { Operations } from \"./Operations\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { Context } from \"../repository\";\nimport { RepositoryFlags } from \"../repository/types\";\n\n/**\n * @description Registry for database operation handlers\n * @summary Manages and stores operation handlers for different model properties and operations\n * @class OperationsRegistry\n * @template M - Model type\n * @template R - Repository type\n * @template V - Metadata type\n * @template F - Repository flags\n * @template C - Context type\n * @example\n * // Create a registry and register a handler\n * const registry = new OperationsRegistry();\n * registry.register(myHandler, OperationKeys.CREATE, targetModel, 'propertyName');\n *\n * // Get handlers for a specific operation\n * const handlers = registry.get(targetModel.constructor.name, 'propertyName', 'onCreate');\n *\n * @mermaid\n * classDiagram\n *   class OperationsRegistry {\n *     -cache: Record~string, Record~string|symbol, Record~string, Record~string, OperationHandler~~~~\n *     +get(target, propKey, operation, accum)\n *     +register(handler, operation, target, propKey)\n *   }\n */\nexport class OperationsRegistry {\n  private readonly cache: Record<\n    string,\n    Record<\n      string | symbol,\n      Record<string, Record<string, OperationHandler<any, any, any, any, any>>>\n    >\n  > = {};\n\n  /**\n   * @description Retrieves operation handlers for a specific target and operation\n   * @summary Finds all registered handlers for a given target, property, and operation, including from parent classes\n   * @template M - Model type extending Model\n   * @template R - Repository type extending IRepository\n   * @template V - Metadata type\n   * @template F - Repository flags extending RepositoryFlags\n   * @template C - Context type extending Context<F>\n   * @param {string | Record<string, any>} target - The target class name or object\n   * @param {string} propKey - The property key to get handlers for\n   * @param {string} operation - The operation key to get handlers for\n   * @param {OperationHandler[]} [accum] - Accumulator for recursive calls\n   * @return {OperationHandler[] | undefined} Array of handlers or undefined if none found\n   */\n  get<\n    M extends Model,\n    R extends IRepository<M, F, C>,\n    V,\n    F extends RepositoryFlags,\n    C extends Context<F>,\n  >(\n    target: string | Record<string, any>,\n    propKey: string,\n    operation: string,\n    accum?: OperationHandler<M, R, V, F, C>[]\n  ): OperationHandler<M, R, V, F, C>[] | undefined {\n    accum = accum || [];\n    let name;\n    try {\n      name = typeof target === \"string\" ? target : target.constructor.name;\n      accum.unshift(\n        ...Object.values(this.cache[name][propKey][operation] || [])\n      );\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: unknown) {\n      if (\n        typeof target === \"string\" ||\n        target === Object.prototype ||\n        Object.getPrototypeOf(target) === Object.prototype\n      )\n        return accum;\n    }\n\n    let proto = Object.getPrototypeOf(target);\n    if (proto.constructor.name === name) proto = Object.getPrototypeOf(proto);\n\n    return this.get<M, R, V, F, C>(proto, propKey, operation, accum);\n  }\n\n  /**\n   * @description Registers an operation handler for a specific target and operation\n   * @summary Stores a handler in the registry for a given target, property, and operation\n   * @template M - Model type extending Model\n   * @template R - Repository type extending IRepository\n   * @template V - Metadata type\n   * @template F - Repository flags extending RepositoryFlags\n   * @template C - Context type extending Context<F>\n   * @param {OperationHandler} handler - The handler function to register\n   * @param {OperationKeys} operation - The operation key to register the handler for\n   * @param {M} target - The target model instance\n   * @param {string | symbol} propKey - The property key to register the handler for\n   * @return {void}\n   */\n  register<\n    M extends Model,\n    R extends IRepository<M, F, C>,\n    V,\n    F extends RepositoryFlags,\n    C extends Context<F>,\n  >(\n    handler: OperationHandler<M, R, V, F, C>,\n    operation: OperationKeys,\n    target: M,\n    propKey: string | symbol\n  ): void {\n    const name = target.constructor.name;\n    const handlerName = Operations.getHandlerName(handler);\n\n    if (!this.cache[name]) this.cache[name] = {};\n    if (!this.cache[name][propKey]) this.cache[name][propKey] = {};\n    if (!this.cache[name][propKey][operation])\n      this.cache[name][propKey][operation] = {};\n    if (this.cache[name][propKey][operation][handlerName]) return;\n    this.cache[name][propKey][operation][handlerName] = handler;\n  }\n}\n"]}

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

@@ -1,8 +1,9 @@
 /**
- * @summary Set of constants to define db CRUD operations and their equivalent 'on' and 'after' phases
- * @const OperationKeys
- *
- * @memberOf module:db-decorators.Operations
+ * @description Database operation key constants
+ * @summary Enum defining CRUD operations and their lifecycle phases
+ * @enum {string}
+ * @readonly
+ * @memberOf module:db-decorators
  */
 export declare enum OperationKeys {
     REFLECT = "decaf.model.db.operations.",
@@ -13,12 +14,37 @@ export declare enum OperationKeys {
     ON = "on.",
     AFTER = "after."
 }
+/**
+ * @description Type for basic CRUD operations
+ * @summary Union type of the four basic database operations: create, read, update, delete
+ * @typedef {string} CrudOperations
+ * @memberOf module:db-decorators
+ */
 export type CrudOperations = OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE;
 /**
+ * @description Bulk database operation key constants
+ * @summary Enum defining bulk CRUD operations for handling multiple records at once
+ * @enum {string}
+ * @readonly
+ * @memberOf module:db-decorators
+ */
+export declare enum BulkCrudOperationKeys {
+    CREATE_ALL = "createAll",
+    READ_ALL = "readAll",
+    UPDATE_ALL = "updateAll",
+    DELETE_ALL = "deleteAll"
+}
+/**
+ * @description Type for bulk CRUD operations
+ * @summary Union type of the four bulk database operations for handling multiple records at once
+ * @typedef {string} BulkCrudOperations
+ * @memberOf module:db-decorators
+ */
+export type BulkCrudOperations = BulkCrudOperationKeys.CREATE_ALL | BulkCrudOperationKeys.READ_ALL | BulkCrudOperationKeys.UPDATE_ALL | BulkCrudOperationKeys.DELETE_ALL;
+/**
+ * @description Grouped CRUD operations for decorator mapping
  * @summary Maps out groups of CRUD operations for easier mapping of decorators
- *
- * @constant DBOperations
- *
- * @memberOf module:db-decorators.Operations
+ * @const DBOperations
+ * @memberOf module:db-decorators
  */
 export declare const DBOperations: Record<string, CrudOperations[]>;

package/lib/esm/operations/constants.js

@@ -1,8 +1,9 @@
 /**
- * @summary Set of constants to define db CRUD operations and their equivalent 'on' and 'after' phases
- * @const OperationKeys
- *
- * @memberOf module:db-decorators.Operations
+ * @description Database operation key constants
+ * @summary Enum defining CRUD operations and their lifecycle phases
+ * @enum {string}
+ * @readonly
+ * @memberOf module:db-decorators
  */
 export var OperationKeys;
 (function (OperationKeys) {
@@ -15,11 +16,24 @@ export var OperationKeys;
     OperationKeys["AFTER"] = "after.";
 })(OperationKeys || (OperationKeys = {}));
 /**
+ * @description Bulk database operation key constants
+ * @summary Enum defining bulk CRUD operations for handling multiple records at once
+ * @enum {string}
+ * @readonly
+ * @memberOf module:db-decorators
+ */
+export var BulkCrudOperationKeys;
+(function (BulkCrudOperationKeys) {
+    BulkCrudOperationKeys["CREATE_ALL"] = "createAll";
+    BulkCrudOperationKeys["READ_ALL"] = "readAll";
+    BulkCrudOperationKeys["UPDATE_ALL"] = "updateAll";
+    BulkCrudOperationKeys["DELETE_ALL"] = "deleteAll";
+})(BulkCrudOperationKeys || (BulkCrudOperationKeys = {}));
+/**
+ * @description Grouped CRUD operations for decorator mapping
  * @summary Maps out groups of CRUD operations for easier mapping of decorators
- *
- * @constant DBOperations
- *
- * @memberOf module:db-decorators.Operations
+ * @const DBOperations
+ * @memberOf module:db-decorators
  */
 export const DBOperations = {
     CREATE: [OperationKeys.CREATE],
@@ -35,4 +49,4 @@ export const DBOperations = {
         OperationKeys.DELETE,
     ],
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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