@decaf-ts/db-decorators 0.16.0 → 0.17.0

package/lib/types/validation/index.d.cts

@@ -1,4 +1,4 @@
-export * from "./validators/index.cjs";
-export * from "./constants.cjs";
-export * from "./decorators.cjs";
-export * from "./validation.cjs";
+export * from "./validators/index.d.cts";
+export * from "./constants.d.cts";
+export * from "./decorators.d.cts";
+export * from "./validation.d.cts";

package/lib/types/validation/index.d.mts

@@ -1,4 +1,4 @@
-export * from "./validators/index.js";
-export * from "./constants.js";
-export * from "./decorators.js";
-export * from "./validation.js";
+export * from "./validators/index.d.mts";
+export * from "./constants.d.mts";
+export * from "./decorators.d.mts";
+export * from "./validation.d.mts";

package/lib/types/validation/validators/index.d.cts

@@ -1,3 +1,3 @@
-export * from "./ReadOnlyValidator.cjs";
-export * from "./TimestampValidator.cjs";
-export * from "./UpdateValidator.cjs";
+export * from "./ReadOnlyValidator.d.cts";
+export * from "./TimestampValidator.d.cts";
+export * from "./UpdateValidator.d.cts";

package/lib/types/validation/validators/index.d.mts

@@ -1,3 +1,3 @@
-export * from "./ReadOnlyValidator.js";
-export * from "./TimestampValidator.js";
-export * from "./UpdateValidator.js";
+export * from "./ReadOnlyValidator.d.mts";
+export * from "./TimestampValidator.d.mts";
+export * from "./UpdateValidator.d.mts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decaf-ts/db-decorators",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Agnostic database decorators and repository",
   "type": "module",
   "exports": {

package/lib/types/identity/decorators.d.ts

@@ -1,8 +0,0 @@
-/**
- * @description Decorator that marks a property as an ID field
- * @summary Creates a composite decorator that marks a property as required, readonly, and as the ID field for database operations
- * @return {PropertyDecorator} A decorator that can be applied to class properties
- * @function id
- * @category Property Decorators
- */
-export declare function id(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor | number) => void;

package/lib/types/identity/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * @description Exports for the identity module.
- * @summary This file exports all the necessary components for the identity functionality, including decorators.
- * @module db-decorators/identity
- */
-export * from "./decorators";

package/lib/types/index.d.ts

@@ -1,15 +0,0 @@
-export * from "./identity";
-export * from "./interfaces";
-export * from "./model";
-export * from "./operations";
-export * from "./overrides";
-export * from "./repository";
-export * from "./validation";
-/**
- * @description Current version of the reflection package
- * @summary Stores the semantic version number of the package
- * @const VERSION
- * @memberOf module:db-decorators
- */
-export declare const VERSION = "0.15.0";
-export declare const PACKAGE_NAME = "@decaf-ts/db-decorators";

package/lib/types/interfaces/BulkCrudOperator.d.ts

@@ -1,47 +0,0 @@
-import { CrudOperator } from "./CrudOperator";
-import { PrimaryKeyType } from "../repository/index";
-/**
- * @description Interface for bulk CRUD operations
- * @summary Extends the basic CRUD operations to support bulk operations on multiple models at once
- * @template M - The model type
- * @interface BulkCrudOperator
- * @memberOf module:db-decorators
- */
-export interface BulkCrudOperator<M> extends CrudOperator<M> {
-    /**
-     * @description Creates multiple model instances in the database
-     * @summary Bulk operation to create multiple models at once
-     * @template M - The model type
-     * @param {M[]} models - Array of model instances to create
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M[]>} Promise resolving to the created model instances
-     */
-    createAll(models: M[], ...args: any[]): Promise<M[]>;
-    /**
-     * @description Retrieves multiple model instances from the database by their keys
-     * @summary Bulk operation to read multiple models at once
-     * @template M - The model type
-     * @param {(PrimaryKeyType[])} keys - Array of primary keys to retrieve
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M[]>} Promise resolving to the retrieved model instances
-     */
-    readAll(keys: PrimaryKeyType[], ...args: any[]): Promise<M[]>;
-    /**
-     * @description Updates multiple model instances in the database
-     * @summary Bulk operation to update multiple models at once
-     * @template M - The model type
-     * @param {M[]} models - Array of model instances to update
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M[]>} Promise resolving to the updated model instances
-     */
-    updateAll(models: M[], ...args: any[]): Promise<M[]>;
-    /**
-     * @description Deletes multiple model instances from the database by their keys
-     * @summary Bulk operation to delete multiple models at once
-     * @template M - The model type
-     * @param {(PrimaryKeyType[])} keys - Array of primary keys to delete
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M[]>} Promise resolving to the deleted model instances
-     */
-    deleteAll(keys: PrimaryKeyType[], ...args: any[]): Promise<M[]>;
-}

package/lib/types/interfaces/Contextual.d.ts

@@ -1,23 +0,0 @@
-import { OperationKeys } from "../operations";
-import { Context } from "../repository";
-export type FlagsOf<C extends Context<any>> = C extends Context<infer T> ? T : never;
-/**
- * @description Interface for context-aware operations
- * @summary Provides context management for database operations
- * @template F - Type extending RepositoryFlags, defaults to RepositoryFlags
- * @template C - Type extending Context<F>, defaults to Context<F>
- * @interface Contextual
- * @memberOf module:db-decorators
- */
-export interface Contextual<C extends Context<any> = Context<any>> {
-    /**
-     * @description Creates a context for a specific operation
-     * @summary Generates an operation-specific context with custom flags
-     * @param {(OperationKeys.CREATE|OperationKeys.READ|OperationKeys.UPDATE|OperationKeys.DELETE)} operation - The operation type
-     * @template F - Type extending RepositoryFlags, defaults to RepositoryFlags
-     * @param {Partial<F>} overrides - Custom flag overrides for this context
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<C>} Promise resolving to the created context
-     */
-    context(operation: ((...args: any[]) => any) | OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE | string, overrides: Partial<FlagsOf<C>>, ...args: any[]): Promise<C>;
-}

package/lib/types/interfaces/CrudOperator.d.ts

@@ -1,46 +0,0 @@
-import { PrimaryKeyType } from "../repository/index";
-/**
- * @description Basic CRUD operations interface
- * @summary Exposes a standard Create, Read, Update, Delete API for database operations
- * @template M - The model type
- * @interface CrudOperator
- * @memberOf module:db-decorators
- */
-export interface CrudOperator<M> {
-    /**
-     * @description Creates a new model instance in the database
-     * @summary Create a new model
-     * @template M - The model type
-     * @param {M} model - The model instance to create
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M>} Promise resolving to the created model instance
-     */
-    create(model: M, ...args: any[]): Promise<M>;
-    /**
-     * @description Retrieves a model instance from the database by its key
-     * @summary Read a model
-     * @template M - The model type
-     * @param {PrimaryKeyType} key - The primary key of the model to retrieve
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M>} Promise resolving to the retrieved model instance
-     */
-    read(key: PrimaryKeyType, ...args: any[]): Promise<M>;
-    /**
-     * @description Updates a model instance in the database
-     * @summary Update a model
-     * @template M - The model type
-     * @param {M} model - The model instance to update
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M>} Promise resolving to the updated model instance
-     */
-    update(model: M, ...args: any[]): Promise<M>;
-    /**
-     * @description Deletes a model instance from the database by its key
-     * @summary Delete a model
-     * @template M - The model type
-     * @param {PrimaryKeyType} key - The primary key of the model to delete
-     * @param {...any[]} args - Additional arguments
-     * @return {Promise<M>} Promise resolving to the deleted model instance
-     */
-    delete(key: PrimaryKeyType, ...args: any[]): Promise<M>;
-}

package/lib/types/interfaces/IRepository.d.ts

@@ -1,19 +0,0 @@
-import { Model, ModelConstructor } from "@decaf-ts/decorator-validation";
-import { BulkCrudOperator } from "./BulkCrudOperator";
-import { Context, RepositoryFlags } from "../repository";
-/**
- * @description Repository interface for database operations
- * @summary Interface holding basic CRUD APIs for database models, providing standard operations and metadata
- * @template M - Type extending Model
- * @template F - Type extending RepositoryFlags, defaults to RepositoryFlags
- * @template C - Type extending Context<F>, defaults to Context<F>
- * @interface IRepository
- * @memberOf module:db-decorators
- */
-export interface IRepository<M extends Model<boolean>, C extends Context<any> = Context<RepositoryFlags>> extends BulkCrudOperator<M> {
-    /**
-     * @description The constructor of the model class
-     * @summary Reference to the model class constructor used to create new instances
-     */
-    readonly class: ModelConstructor<M>;
-}

package/lib/types/interfaces/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * @description Exports for the interfaces module.
- * @summary This file exports all the necessary components for the interfaces functionality, including BulkCrudOperator, Contextual, CrudOperator, and IRepository.
- * @module db-decorators/interfaces
- */
-export * from "./BulkCrudOperator";
-export * from "./Contextual";
-export * from "./CrudOperator";
-export * from "./IRepository";

package/lib/types/model/constants.d.ts

@@ -1,37 +0,0 @@
-/**
- * @description Database reflection keys
- * @summary Collection of keys used for reflection metadata in database operations
- * @const DBKeys
- * @memberOf module:db-decorators
- */
-export declare const DBKeys: {
-    REFLECT: string;
-    REPOSITORY: string;
-    CLASS: string;
-    ID: string;
-    INDEX: string;
-    UNIQUE: string;
-    SERIALIZE: string;
-    READONLY: string;
-    TIMESTAMP: string;
-    TRANSIENT: string;
-    HASH: string;
-    COMPOSED: string;
-    GENERATED: string;
-    VERSION: string;
-    ORIGINAL: string;
-};
-/**
- * @description Default separator character for composite indexes
- * @summary The default separator character used when concatenating multiple fields into a single index
- * @const DefaultSeparator
- * @memberOf module:db-decorators
- */
-export declare const DefaultSeparator = "_";
-/**
- * @description Default format for timestamp fields
- * @summary Standard date format string used for timestamp fields in database models
- * @const DEFAULT_TIMESTAMP_FORMAT
- * @memberOf module:db-decorators
- */
-export declare const DEFAULT_TIMESTAMP_FORMAT = "dd/MM/yyyy HH:mm:ss:S";

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

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

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

@@ -1,9 +0,0 @@
-/**
- * @description Exports for the model module.
- * @summary This file exports all the necessary components for the model functionality, including constants, decorators, and the model itself.
- * @module db-decorators/model
- */
-export * from "./constants";
-export * from "./decorators";
-export * from "./model";
-export * from "./validation";

package/lib/types/model/model.d.ts

@@ -1,6 +0,0 @@
-import { ConditionalAsync, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
-declare module "@decaf-ts/decorator-validation" {
-    interface Model<Async extends boolean = false> {
-        hasErrors(previousVersion?: Model | any, ...exclusions: any[]): ConditionalAsync<Async, ModelErrorDefinition | undefined>;
-    }
-}

package/lib/types/model/validation.d.ts

@@ -1,57 +0,0 @@
-import { ConditionalAsync, Model, ModelConditionalAsync } from "@decaf-ts/decorator-validation";
-/**
- * @description
- * Retrieves validation decorator definitions from a model for update operations, including
- * support for special handling of list decorators.
- *
- * @summary
- * Iterates over the model's own enumerable properties and filters out those specified in the
- * `propsToIgnore` array. For each remaining property, retrieves validation decorators specific
- * to update operations using the `UpdateValidationKeys.REFLECT` key. Additionally, it explicitly
- * checks for and appends any `LIST` type decorators to ensure proper validation of collection types.
- *
- * @template M - A generic parameter extending the `Model` class, representing the model type being inspected.
- *
- * @param {M} model - The model instance whose properties are being inspected for update-related validations.
- * @param {string[]} propsToIgnore - A list of property names to exclude from the validation decorator retrieval process.
- *
- * @return {ValidationPropertyDecoratorDefinition[]} An array of validation decorator definitions, including both
- * update-specific and list-type decorators, excluding those for ignored properties.
- *
- * @function getValidatableUpdateProps
- */
-export declare function getValidatableUpdateProps<M extends Model>(model: M, propsToIgnore: string[]): any[];
-export declare function validateDecorator<M extends Model, Async extends boolean = false>(newModel: M, oldModel: M, prop: string, decorator: any, async?: Async): ConditionalAsync<Async, string | undefined>;
-export declare function validateDecorators<M extends Model, Async extends boolean = false>(newModel: M, oldModel: M, prop: string, decorators: any, async?: Async): ConditionalAsync<Async, Record<string, string>> | undefined;
-/**
- * @description Validates changes between two model versions
- * @summary Compares an old and new model version to validate update operations
- * @template M - Type extending Model
- * @param {M} oldModel - The original model version
- * @param {M} newModel - The updated model version
- * @param {boolean} async - A flag indicating whether validation should be asynchronous.
- * @param {...string[]} propsToIgnore - Properties to exclude from validation
- * @return {ModelErrorDefinition|undefined} Error definition if validation fails, undefined otherwise
- * @function validateCompare
- * @memberOf module:db-decorators
- * @mermaid
- * sequenceDiagram
- *   participant Caller
- *   participant validateCompare
- *   participant Reflection
- *   participant Validation
- *
- *   Caller->>validateCompare: oldModel, newModel, propsToIgnore
- *   validateCompare->>Reflection: get decorated properties
- *   Reflection-->>validateCompare: property decorators
- *   loop For each decorated property
- *     validateCompare->>Validation: get validator
- *     Validation-->>validateCompare: validator
- *     validateCompare->>validateCompare: validate property update
- *   end
- *   loop For nested models
- *     validateCompare->>validateCompare: validate nested models
- *   end
- *   validateCompare-->>Caller: validation errors or undefined
- */
-export declare function validateCompare<M extends Model<any>>(oldModel: M, newModel: M, async: boolean, ...propsToIgnore: string[]): ModelConditionalAsync<M>;

package/lib/types/operations/Operations.d.ts

@@ -1,80 +0,0 @@
-import { Model } from "@decaf-ts/decorator-validation";
-import { OperationHandler } from "./types";
-import { OperationKeys } from "./constants";
-import { IRepository } from "../interfaces";
-/**
- * @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
- * @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');
- *
- * @mermaid
- * classDiagram
- *   class Operations {
- *     -registry: OperationsRegistry
- *     +getHandlerName(handler)
- *     +key(str)
- *     +get(targetName, propKey, operation)
- *     -getOpRegistry()
- *     +register(handler, operation, target, propKey)
- *   }
- *   Operations --> OperationsRegistry : uses
- */
-export declare class Operations {
-    private static registry;
-    private 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>} handler - The handler function to get the name for
-     * @return {string} The name of the handler or a generated hash
-     */
-    static getHandlerName(handler: OperationHandler<any, any, any>): any;
-    /**
-     * @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: string): string;
-    /**
-     * @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<M extends Model, R extends IRepository<M, any>, V = object>(targetName: string | Record<string, any>, propKey: string, operation: string): OperationHandler<M, R, V>[] | undefined;
-    /**
-     * @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
-     */
-    private static getOpRegistry;
-    /**
-     * @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<V extends Model>(handler: OperationHandler<V, any, any>, operation: OperationKeys, target: V, propKey: string | symbol): void;
-}

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

@@ -1,72 +0,0 @@
-import { OperationHandler } from "./types";
-import { OperationKeys } from "./constants";
-import { IRepository } from "../interfaces/IRepository";
-import { Model } from "@decaf-ts/decorator-validation";
-/**
- * @description Registry for database operation handlers
- * @summary Manages and stores operation handlers for different model properties and operations
- * @class OperationsRegistry
- * @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');
- *
- * // Get handlers for a specific operation
- * const handlers = registry.get(targetModel.constructor.name, 'propertyName', 'onCreate');
- *
- * @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;
-    /**
-     * @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
-     * @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, any>, V>(target: string | Record<string, any>, propKey: string, operation: string, accum?: OperationHandler<M, R, V>[]): OperationHandler<M, R, V>[] | undefined;
-    /**
-     * @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, any>, V>(handler: OperationHandler<M, R, V>, operation: OperationKeys, target: M, propKey: string | symbol): void;
-    private resolveOwner;
-    private resolveTargetName;
-    private resolveFlavour;
-    private selectHandlers;
-    private firstBucket;
-    /**
-     * @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>} handler - The handler function to get the name for
-     * @return {string} The name of the handler or a generated hash
-     */
-    static getHandlerName(handler: OperationHandler<any, any, any>): any;
-}