@decaf-ts/db-decorators/lib/operations/OperationsRegistry.d.ts

Agnostic database decorators and repository

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;
}