typebus-cqrs/dist/core/TypeBus.d.ts

Simple, type-safe CQRS library with auto-registration and minimal boilerplate (typebus-cqrs)

import { IMessageBus, IMessageHandler, IMiddleware, CommandType, QueryType, EventType, CommandData, CommandResult, QueryParams, QueryResult, EventData, TypeBusConfig } from '../types';
/**
 * Main class of the TypeBus-CQRS library. Implements the IMessageBus interface.
 * Handles registration and execution of commands, queries, and events with middleware support.
 * @template TCommandMap - Command map type
 * @template TQueryMap - Query map type
 * @template TEventMap - Event map type
 * @implements {IMessageBus<TCommandMap, TQueryMap, TEventMap>}
 */
export declare class TypeBus<TCommandMap extends Record<string, any> = any, TQueryMap extends Record<string, any> = any, TEventMap extends Record<string, any> = any> implements IMessageBus<TCommandMap, TQueryMap, TEventMap> {
    private commandHandlers;
    private queryHandlers;
    private eventHandlers;
    private middlewares;
    private messageFactory;
    private config;
    /**
     * Creates a new TypeBus instance.
     * @param {TypeBusConfig} [config]
     */
    constructor(config?: TypeBusConfig);
    /**
     * Registers a middleware to the bus.
     * @param {IMiddleware} middleware
     */
    use(middleware: IMiddleware): void;
    /**
     * Registers a command handler for a specific command type.
     * @template T
     * @param {T} commandType
     * @param {IMessageHandler<any, CommandResult<TCommandMap, T>>} handler
     */
    registerCommandHandler<T extends CommandType<TCommandMap>>(commandType: T, handler: IMessageHandler<any, CommandResult<TCommandMap, T>>): void;
    /**
     * Registers a query handler for a specific query type.
     * @template T
     * @param {T} queryType
     * @param {IMessageHandler<any, QueryResult<TQueryMap, T>>} handler
     */
    registerQueryHandler<T extends QueryType<TQueryMap>>(queryType: T, handler: IMessageHandler<any, QueryResult<TQueryMap, T>>): void;
    /**
     * Registers an event handler for a specific event type.
     * @template T
     * @param {T} eventType
     * @param {IMessageHandler<any, void>} handler
     */
    registerEventHandler<T extends EventType<TEventMap>>(eventType: T, handler: IMessageHandler<any, void>): void;
    /**
     * Executes a command message.
     * @template T
     * @param {T} type
     * @param {CommandData<TCommandMap, T>} data
     * @param {string} aggregateId
     * @param {Record<string, any>} [metadata]
     * @returns {Promise<CommandResult<TCommandMap, T>>}
     */
    executeCommand<T extends CommandType<TCommandMap>>(type: T, data: CommandData<TCommandMap, T>, aggregateId: string, metadata?: Record<string, any>): Promise<CommandResult<TCommandMap, T>>;
    /**
     * Executes a query message.
     * @template T
     * @param {T} type
     * @param {QueryParams<TQueryMap, T>} params
     * @param {Record<string, any>} [metadata]
     * @returns {Promise<QueryResult<TQueryMap, T>>}
     */
    executeQuery<T extends QueryType<TQueryMap>>(type: T, params: QueryParams<TQueryMap, T>, metadata?: Record<string, any>): Promise<QueryResult<TQueryMap, T>>;
    /**
     * Publishes an event message to all registered handlers.
     * @template T
     * @param {T} type
     * @param {EventData<TEventMap, T>} data
     * @param {string} aggregateId
     * @param {number} version
     * @param {Record<string, any>} [metadata]
     * @returns {Promise<void>}
     */
    publishEvent<T extends EventType<TEventMap>>(type: T, data: EventData<TEventMap, T>, aggregateId: string, version: number, metadata?: Record<string, any>): Promise<void>;
    /**
     * Executes a message through the middleware pipeline.
     * @template T, R
     * @param {T} message
     * @param {IMessageHandler<T, R>} handler
     * @param {number} timeout
     * @returns {Promise<R>}
     */
    private executeWithMiddleware;
    /**
     * Executes a promise with a timeout.
     * @template T
     * @param {Promise<T>} promise
     * @param {number} timeoutMs
     * @param {string} operationType
     * @returns {Promise<T>}
     */
    private withTimeout;
    /**
     * Clears all registered handlers and middleware.
     */
    clear(): void;
    /**
     * Gets statistics about the bus.
     * @returns {object}
     */
    getStats(): {
        commandHandlers: number;
        queryHandlers: number;
        eventHandlers: number;
        middleware: number;
        totalHandlers: number;
    };
    /**
     * Gets all registered handlers.
     * @returns {object}
     */
    getRegisteredHandlers(): {
        commands: string[];
        queries: string[];
        events: string[];
    };
}
//# sourceMappingURL=TypeBus.d.ts.map