@message-in-the-middle/core/dist/cjs/manager.d.ts

Framework-agnostic middleware pattern for message queue processing. Core package with all middlewares.

import { EventEmitter } from 'events';
import { HealthCheck, InboundMiddleware, ManagerStatistics, MessageContext, OutboundMiddleware } from './types';
export interface ManagerEvents<T = any> {
    'message:start': (context: MessageContext<T>) => void;
    'message:complete': (context: MessageContext<T>, duration: number) => void;
    'message:error': (error: Error, context: MessageContext<T>) => void;
    'middleware:before': (middlewareName: string, context: MessageContext<T>) => void;
    'middleware:after': (middlewareName: string, context: MessageContext<T>, duration: number) => void;
    'middleware:error': (middlewareName: string, error: Error, context: MessageContext<T>) => void;
    'slow:processing': (context: MessageContext<T>, duration: number) => void;
}
export interface ManagerOptions {
    maxMessageSize?: number;
    events?: {
        enabled?: boolean;
        emitMiddlewareEvents?: boolean;
        slowProcessingThreshold?: number;
    };
}
export declare class MessageMiddlewareManager<T = any> extends EventEmitter {
    private inboundPipeline;
    private outboundPipeline;
    private resources;
    private readonly maxMessageSize;
    private readonly eventsEnabled;
    private readonly emitMiddlewareEvents;
    private readonly slowProcessingThreshold;
    private readonly startedAt;
    private inboundProcessedCount;
    private outboundProcessedCount;
    private inboundErrorCount;
    private outboundErrorCount;
    private totalInboundProcessingTime;
    private totalOutboundProcessingTime;
    constructor(options?: ManagerOptions);
    emit<K extends keyof ManagerEvents<T>>(event: K, ...args: Parameters<ManagerEvents<T>[K]>): boolean;
    on<K extends keyof ManagerEvents<T>>(event: K, listener: ManagerEvents<T>[K]): this;
    once<K extends keyof ManagerEvents<T>>(event: K, listener: ManagerEvents<T>[K]): this;
    off<K extends keyof ManagerEvents<T>>(event: K, listener: ManagerEvents<T>[K]): this;
    use(middleware: InboundMiddleware<T> | OutboundMiddleware<T>): this;
    addInboundMiddleware(middleware: InboundMiddleware<T>): this;
    addOutboundMiddleware(middleware: OutboundMiddleware<T>): this;
    processInbound<R = any>(message: T, raw?: R, attributes?: Record<string, any>): Promise<MessageContext<T, R>>;
    processOutbound<R = any>(message: T, metadata?: Record<string, any>, attributes?: Record<string, any>): Promise<MessageContext<T, R>>;
    getMiddlewares(): {
        inbound: Array<{
            name?: string;
            metadata?: Record<string, any>;
        }>;
        outbound: Array<{
            name?: string;
            metadata?: Record<string, any>;
        }>;
    };
    getStats(): ManagerStatistics;
    getHealth(): Promise<HealthCheck>;
    private isHealthable;
    destroy(): Promise<void>;
}