@zdavison/matador 2.0.9 → 2.0.11

package/dist/transport/connection-manager.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Connection state machine states.
+ */
+export type ConnectionState = {
+    readonly status: 'disconnected';
+} | {
+    readonly status: 'connecting';
+    readonly attempt: number;
+} | {
+    readonly status: 'connected';
+} | {
+    readonly status: 'reconnecting';
+    readonly attempt: number;
+    readonly lastError: Error;
+} | {
+    readonly status: 'failed';
+    readonly error: Error;
+};
+/**
+ * Configuration for the connection manager.
+ */
+export interface ConnectionManagerConfig {
+    /** Maximum reconnection attempts before giving up (0 = infinite) */
+    readonly maxReconnectAttempts: number;
+    /** Initial delay between reconnection attempts (ms) */
+    readonly initialReconnectDelay: number;
+    /** Maximum delay between reconnection attempts (ms) */
+    readonly maxReconnectDelay: number;
+    /** Backoff multiplier for reconnection delay */
+    readonly backoffMultiplier: number;
+    /** Heartbeat interval for connection health (ms), optional */
+    readonly heartbeatInterval?: number;
+}
+/**
+ * Default configuration values.
+ */
+export declare const defaultConnectionConfig: ConnectionManagerConfig;
+/**
+ * Callback for state change notifications.
+ */
+export type StateChangeCallback = (state: ConnectionState) => void;
+/**
+ * Function that performs the actual connection.
+ */
+export type ConnectFn = () => Promise<void>;
+/**
+ * Function that performs disconnection.
+ */
+export type DisconnectFn = () => Promise<void>;
+/**
+ * Manages connection lifecycle with automatic reconnection.
+ */
+export declare class ConnectionManager {
+    private readonly connectFn;
+    private readonly disconnectFn;
+    private _state;
+    private readonly listeners;
+    private reconnectTimer;
+    private readonly config;
+    constructor(connectFn: ConnectFn, disconnectFn: DisconnectFn, config?: Partial<ConnectionManagerConfig>);
+    /**
+     * Current connection state.
+     */
+    get state(): ConnectionState;
+    /**
+     * Whether currently connected.
+     */
+    isConnected(): boolean;
+    /**
+     * Register a callback for connection state changes.
+     */
+    onStateChange(callback: StateChangeCallback): () => void;
+    /**
+     * Attempt to establish connection.
+     */
+    connect(): Promise<void>;
+    /**
+     * Gracefully disconnect.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Called by transport when connection is lost unexpectedly.
+     */
+    handleConnectionLost(error: Error): Promise<void>;
+    /**
+     * Calculate delay for a given attempt using exponential backoff.
+     */
+    calculateDelay(attempt: number): number;
+    private setState;
+    private handleConnectionFailure;
+    private shouldGiveUp;
+    private attemptReconnect;
+    private clearReconnectTimer;
+}
+//# sourceMappingURL=connection-manager.d.ts.map

package/dist/transport/connection-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-manager.d.ts","sourceRoot":"","sources":["../../src/transport/connection-manager.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;CAAE,GACnC;IAAE,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;CAAE,GAChC;IACE,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC;CAC3B,GACD;IAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,oEAAoE;IACpE,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IAEtC,uDAAuD;IACvD,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IAEvC,uDAAuD;IACvD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IAEnC,gDAAgD;IAChD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IAEnC,8DAA8D;IAC9D,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CACrC;AAED;;GAEG;AACH,eAAO,MAAM,uBAAuB,EAAE,uBAKrC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;AAEnE;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAE5C;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAE/C;;GAEG;AACH,qBAAa,iBAAiB;IAO1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAP/B,OAAO,CAAC,MAAM,CAA+C;IAC7D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuC;IACjE,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;gBAG9B,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,YAAY,EAC3C,MAAM,GAAE,OAAO,CAAC,uBAAuB,CAAM;IAK/C;;OAEG;IACH,IAAI,KAAK,IAAI,eAAe,CAE3B;IAED;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,mBAAmB,GAAG,MAAM,IAAI;IAKxD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB9B;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAcjC;;OAEG;IACG,oBAAoB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IASvD;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAOvC,OAAO,CAAC,QAAQ;YAWF,uBAAuB;IAiBrC,OAAO,CAAC,YAAY;YAON,gBAAgB;IAoB9B,OAAO,CAAC,mBAAmB;CAM5B"}

package/dist/transport/connection-manager.js

@@ -0,0 +1,144 @@
+/**
+ * Default configuration values.
+ */
+export const defaultConnectionConfig = {
+    maxReconnectAttempts: 0, // Infinite
+    initialReconnectDelay: 1000,
+    maxReconnectDelay: 30000,
+    backoffMultiplier: 2,
+};
+/**
+ * Manages connection lifecycle with automatic reconnection.
+ */
+export class ConnectionManager {
+    connectFn;
+    disconnectFn;
+    _state = { status: 'disconnected' };
+    listeners = new Set();
+    reconnectTimer = null;
+    config;
+    constructor(connectFn, disconnectFn, config = {}) {
+        this.connectFn = connectFn;
+        this.disconnectFn = disconnectFn;
+        this.config = { ...defaultConnectionConfig, ...config };
+    }
+    /**
+     * Current connection state.
+     */
+    get state() {
+        return this._state;
+    }
+    /**
+     * Whether currently connected.
+     */
+    isConnected() {
+        return this._state.status === 'connected';
+    }
+    /**
+     * Register a callback for connection state changes.
+     */
+    onStateChange(callback) {
+        this.listeners.add(callback);
+        return () => this.listeners.delete(callback);
+    }
+    /**
+     * Attempt to establish connection.
+     */
+    async connect() {
+        if (this._state.status === 'connected') {
+            return;
+        }
+        this.setState({ status: 'connecting', attempt: 1 });
+        try {
+            await this.connectFn();
+            this.setState({ status: 'connected' });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            await this.handleConnectionFailure(err, 1);
+        }
+    }
+    /**
+     * Gracefully disconnect.
+     */
+    async disconnect() {
+        this.clearReconnectTimer();
+        if (this._state.status === 'disconnected') {
+            return;
+        }
+        try {
+            await this.disconnectFn();
+        }
+        finally {
+            this.setState({ status: 'disconnected' });
+        }
+    }
+    /**
+     * Called by transport when connection is lost unexpectedly.
+     */
+    async handleConnectionLost(error) {
+        if (this._state.status === 'disconnected') {
+            return;
+        }
+        this.setState({ status: 'reconnecting', attempt: 1, lastError: error });
+        await this.attemptReconnect(1);
+    }
+    /**
+     * Calculate delay for a given attempt using exponential backoff.
+     */
+    calculateDelay(attempt) {
+        const delay = this.config.initialReconnectDelay *
+            Math.pow(this.config.backoffMultiplier, attempt - 1);
+        return Math.min(delay, this.config.maxReconnectDelay);
+    }
+    setState(state) {
+        this._state = state;
+        for (const listener of this.listeners) {
+            try {
+                listener(state);
+            }
+            catch {
+                // Ignore listener errors
+            }
+        }
+    }
+    async handleConnectionFailure(error, attempt) {
+        if (this.shouldGiveUp(attempt)) {
+            this.setState({ status: 'failed', error });
+            throw error;
+        }
+        this.setState({
+            status: 'reconnecting',
+            attempt: attempt + 1,
+            lastError: error,
+        });
+        await this.attemptReconnect(attempt + 1);
+    }
+    shouldGiveUp(attempt) {
+        return (this.config.maxReconnectAttempts > 0 &&
+            attempt >= this.config.maxReconnectAttempts);
+    }
+    async attemptReconnect(attempt) {
+        const delay = this.calculateDelay(attempt);
+        await new Promise((resolve) => {
+            this.reconnectTimer = setTimeout(resolve, delay);
+        });
+        if (this._state.status === 'disconnected') {
+            return;
+        }
+        try {
+            await this.connectFn();
+            this.setState({ status: 'connected' });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            await this.handleConnectionFailure(err, attempt);
+        }
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer !== null) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+}

package/dist/transport/index.d.ts

@@ -0,0 +1,11 @@
+export type { TransportCapabilities } from './capabilities.js';
+export { hasNativeDeadLetter, supportsDeliveryMode, supportsDelayedMessages, } from './capabilities.js';
+export type { MessageHandler, MessageReceipt, RabbitMQSendOptions, RabbitMQSubscribeOptions, SendOptions, SubscribeOptions, Subscription, Transport, TransportSendOptions, TransportSubscribeOptions, } from './transport.js';
+export type { ConnectFn, ConnectionManagerConfig, ConnectionState, DisconnectFn, StateChangeCallback, } from './connection-manager.js';
+export { ConnectionManager, defaultConnectionConfig, } from './connection-manager.js';
+export { LocalTransport } from './local/local-transport.js';
+export type { MultiTransportConfig, MultiTransportHooks, } from './multi/multi-transport.js';
+export { MultiTransport } from './multi/multi-transport.js';
+export type { RabbitMQTransportConfig } from './rabbitmq/rabbitmq-transport.js';
+export { RabbitMQTransport } from './rabbitmq/rabbitmq-transport.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/transport/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transport/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,cAAc,EACd,cAAc,EACd,mBAAmB,EACnB,wBAAwB,EACxB,WAAW,EACX,gBAAgB,EAChB,YAAY,EACZ,SAAS,EACT,oBAAoB,EACpB,yBAAyB,GAC1B,MAAM,gBAAgB,CAAC;AAExB,YAAY,EACV,SAAS,EACT,uBAAuB,EACvB,eAAe,EACf,YAAY,EACZ,mBAAmB,GACpB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D,YAAY,EACV,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D,YAAY,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AAChF,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/transport/index.js

@@ -0,0 +1,5 @@
+export { hasNativeDeadLetter, supportsDeliveryMode, supportsDelayedMessages, } from './capabilities.js';
+export { ConnectionManager, defaultConnectionConfig, } from './connection-manager.js';
+export { LocalTransport } from './local/local-transport.js';
+export { MultiTransport } from './multi/multi-transport.js';
+export { RabbitMQTransport } from './rabbitmq/rabbitmq-transport.js';

package/dist/transport/local/local-transport.d.ts

@@ -0,0 +1,62 @@
+import { type Logger } from '../../hooks/index.js';
+import type { Topology } from '../../topology/types.js';
+import type { Envelope } from '../../types/index.js';
+import type { TransportCapabilities } from '../capabilities.js';
+import type { MessageHandler, MessageReceipt, SendOptions, SubscribeOptions, Subscription, Transport } from '../transport.js';
+/**
+ * Local in-memory transport for testing and fallback.
+ * Messages are stored in memory and delivered synchronously.
+ */
+export declare class LocalTransport implements Transport {
+    readonly name = "local";
+    readonly capabilities: TransportCapabilities;
+    private connected;
+    private readonly queues;
+    private readonly subscriptions;
+    private readonly completedMessages;
+    private readonly delayedTimers;
+    private messageIdCounter;
+    private readonly logger;
+    constructor(logger?: Logger);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    applyTopology(topology: Topology): Promise<void>;
+    send(queue: string, envelope: Envelope, options?: SendOptions): Promise<Transport['name']>;
+    /**
+     * Schedules a message for delayed delivery.
+     * Returns immediately (non-blocking) to match real transport behavior.
+     */
+    private scheduleDelayedMessage;
+    private enqueue;
+    private deliverToSubscribers;
+    subscribe(queue: string, handler: MessageHandler, options?: SubscribeOptions): Promise<Subscription>;
+    complete(receipt: MessageReceipt): Promise<void>;
+    sendToDeadLetter(receipt: MessageReceipt, dlqName: string, envelope: Envelope, _reason: string): Promise<void>;
+    /**
+     * Gets the current size of a queue.
+     */
+    getQueueSize(queue: string): number;
+    /**
+     * Gets all completed message receipts.
+     */
+    getCompleted(): readonly MessageReceipt[];
+    /**
+     * Gets pending (uncompleted) messages from a queue.
+     */
+    getPendingMessages(queue: string): readonly Envelope[];
+    /**
+     * Clears all state (for test isolation).
+     */
+    clear(): void;
+    /**
+     * Receives one message from the queue without a subscription.
+     * Useful for testing.
+     */
+    receiveOne(queue: string): Promise<{
+        envelope: Envelope;
+        receipt: MessageReceipt;
+    } | null>;
+    private getOrCreateQueue;
+}
+//# sourceMappingURL=local-transport.d.ts.map

package/dist/transport/local/local-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-transport.d.ts","sourceRoot":"","sources":["../../../src/transport/local/local-transport.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAiB,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,KAAK,EACV,cAAc,EACd,cAAc,EACd,WAAW,EACX,gBAAgB,EAChB,YAAY,EACZ,SAAS,EACV,MAAM,iBAAiB,CAAC;AAiCzB;;;GAGG;AACH,qBAAa,cAAe,YAAW,SAAS;IAC9C,QAAQ,CAAC,IAAI,WAAW;IACxB,QAAQ,CAAC,YAAY,wBAAqB;IAE1C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsC;IAC7D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA2C;IACzE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAwB;IAC1D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA4C;IAC1E,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,MAAM,CAAC,EAAE,MAAM;IAIrB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBjC,WAAW,IAAI,OAAO;IAIhB,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBhD,IAAI,CACR,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAe7B;;;OAGG;IACH,OAAO,CAAC,sBAAsB;YAkBhB,OAAO;YAgBP,oBAAoB;IA+B5B,SAAS,CACb,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,cAAc,EACvB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,YAAY,CAAC;IAsClB,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAMhD,gBAAgB,CACpB,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC;IAQhB;;OAEG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAMnC;;OAEG;IACH,YAAY,IAAI,SAAS,cAAc,EAAE;IAIzC;;OAEG;IACH,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,QAAQ,EAAE;IAMtD;;OAEG;IACH,KAAK,IAAI,IAAI;IAYb;;;OAGG;IACG,UAAU,CACd,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC;QAAE,QAAQ,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,cAAc,CAAA;KAAE,GAAG,IAAI,CAAC;IAmBlE,OAAO,CAAC,gBAAgB;CAQzB"}

package/dist/transport/local/local-transport.js

@@ -0,0 +1,241 @@
+import { TransportNotConnectedError } from '../../errors/index.js';
+import { consoleLogger } from '../../hooks/index.js';
+/**
+ * Capabilities of the LocalTransport.
+ */
+const localCapabilities = {
+    deliveryModes: ['at-least-once', 'at-most-once'],
+    delayedMessages: true, // Implemented with setTimeout
+    deadLetterRouting: 'manual',
+    attemptTracking: false,
+    concurrencyModel: 'none',
+    ordering: 'queue',
+    priorities: false,
+};
+/**
+ * Local in-memory transport for testing and fallback.
+ * Messages are stored in memory and delivered synchronously.
+ */
+export class LocalTransport {
+    name = 'local';
+    capabilities = localCapabilities;
+    connected = false;
+    queues = new Map();
+    subscriptions = new Map();
+    completedMessages = [];
+    delayedTimers = new Set();
+    messageIdCounter = 0;
+    logger;
+    constructor(logger) {
+        this.logger = logger ?? consoleLogger;
+    }
+    async connect() {
+        this.connected = true;
+    }
+    async disconnect() {
+        // Cancel all delayed message timers
+        for (const timer of this.delayedTimers) {
+            clearTimeout(timer);
+        }
+        this.delayedTimers.clear();
+        // Deactivate all subscriptions
+        for (const subs of this.subscriptions.values()) {
+            for (const sub of subs) {
+                sub.active = false;
+            }
+        }
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    async applyTopology(topology) {
+        if (!this.connected) {
+            throw new TransportNotConnectedError(this.name, 'applyTopology');
+        }
+        // Initialize queues for the topology.
+        // Note: Retry queues are not pre-created here because LocalTransport handles
+        // retries by re-enqueueing messages with a delay to the original queue, matching
+        // how the pipeline schedules retries via transport.send() with a delay option.
+        for (const queueDef of topology.queues) {
+            const queueName = `${topology.namespace}.${queueDef.name}`;
+            if (!this.queues.has(queueName)) {
+                this.queues.set(queueName, []);
+            }
+        }
+    }
+    async send(queue, envelope, options) {
+        if (!this.connected) {
+            throw new TransportNotConnectedError(this.name, 'send');
+        }
+        // Handle delayed messages (non-blocking, like real transports)
+        if (options?.delay !== undefined && options.delay > 0) {
+            this.scheduleDelayedMessage(queue, envelope, options.delay);
+            return this.name;
+        }
+        await this.enqueue(queue, envelope);
+        return this.name;
+    }
+    /**
+     * Schedules a message for delayed delivery.
+     * Returns immediately (non-blocking) to match real transport behavior.
+     */
+    scheduleDelayedMessage(queue, envelope, delayMs) {
+        const timer = setTimeout(() => {
+            this.delayedTimers.delete(timer);
+            // Fire and forget - errors are logged in enqueue/deliverToSubscribers
+            this.enqueue(queue, envelope).catch((error) => {
+                this.logger.error('[Matador] 🔴 Failed to enqueue delayed message', error);
+            });
+        }, delayMs);
+        this.delayedTimers.add(timer);
+    }
+    async enqueue(queue, envelope) {
+        const messages = this.getOrCreateQueue(queue);
+        const messageId = `${++this.messageIdCounter}`;
+        const queuedMessage = {
+            envelope,
+            id: messageId,
+            completed: false,
+        };
+        messages.push(queuedMessage);
+        // Deliver to any active subscriptions
+        await this.deliverToSubscribers(queue, queuedMessage);
+    }
+    async deliverToSubscribers(queue, message) {
+        const subs = this.subscriptions.get(queue);
+        if (!subs)
+            return;
+        for (const sub of subs) {
+            if (!sub.active || message.completed)
+                continue;
+            const receipt = {
+                handle: message,
+                redelivered: false,
+                attemptNumber: message.envelope.docket.attempts,
+                deliveryCount: message.envelope.docket.attempts,
+                sourceQueue: queue,
+                sourceTransport: this.name,
+            };
+            try {
+                await sub.handler(message.envelope, receipt);
+            }
+            catch (error) {
+                // Handler errors should be caught in the pipeline
+                this.logger.error('[Matador] 🔴 Handler error in message processing', error);
+            }
+        }
+    }
+    async subscribe(queue, handler, options = {}) {
+        if (!this.connected) {
+            throw new TransportNotConnectedError(this.name, 'subscribe');
+        }
+        const subscription = {
+            handler,
+            options,
+            active: true,
+        };
+        const subs = this.subscriptions.get(queue) ?? [];
+        subs.push(subscription);
+        this.subscriptions.set(queue, subs);
+        // Deliver any pending messages
+        const messages = this.queues.get(queue) ?? [];
+        for (const message of messages) {
+            if (message.completed)
+                continue;
+            await this.deliverToSubscribers(queue, message);
+        }
+        return {
+            unsubscribe: async () => {
+                subscription.active = false;
+                const remaining = subs.filter((s) => s !== subscription);
+                if (remaining.length > 0) {
+                    this.subscriptions.set(queue, remaining);
+                }
+                else {
+                    this.subscriptions.delete(queue);
+                }
+            },
+            get isActive() {
+                return subscription.active;
+            },
+        };
+    }
+    async complete(receipt) {
+        const message = receipt.handle;
+        message.completed = true;
+        this.completedMessages.push(receipt);
+    }
+    async sendToDeadLetter(receipt, dlqName, envelope, _reason) {
+        const dlqQueueName = `${receipt.sourceQueue}.${dlqName}`;
+        await this.enqueue(dlqQueueName, envelope);
+        await this.complete(receipt);
+    }
+    // Test helpers
+    /**
+     * Gets the current size of a queue.
+     */
+    getQueueSize(queue) {
+        const messages = this.queues.get(queue);
+        if (!messages)
+            return 0;
+        return messages.filter((m) => !m.completed).length;
+    }
+    /**
+     * Gets all completed message receipts.
+     */
+    getCompleted() {
+        return this.completedMessages;
+    }
+    /**
+     * Gets pending (uncompleted) messages from a queue.
+     */
+    getPendingMessages(queue) {
+        const messages = this.queues.get(queue);
+        if (!messages)
+            return [];
+        return messages.filter((m) => !m.completed).map((m) => m.envelope);
+    }
+    /**
+     * Clears all state (for test isolation).
+     */
+    clear() {
+        this.queues.clear();
+        this.subscriptions.clear();
+        this.completedMessages.length = 0;
+        this.messageIdCounter = 0;
+        for (const timer of this.delayedTimers) {
+            clearTimeout(timer);
+        }
+        this.delayedTimers.clear();
+    }
+    /**
+     * Receives one message from the queue without a subscription.
+     * Useful for testing.
+     */
+    async receiveOne(queue) {
+        const messages = this.queues.get(queue);
+        if (!messages)
+            return null;
+        const pending = messages.find((m) => !m.completed);
+        if (!pending)
+            return null;
+        const receipt = {
+            handle: pending,
+            redelivered: false,
+            attemptNumber: pending.envelope.docket.attempts,
+            deliveryCount: pending.envelope.docket.attempts,
+            sourceQueue: queue,
+            sourceTransport: this.name,
+        };
+        return { envelope: pending.envelope, receipt };
+    }
+    getOrCreateQueue(queue) {
+        let messages = this.queues.get(queue);
+        if (!messages) {
+            messages = [];
+            this.queues.set(queue, messages);
+        }
+        return messages;
+    }
+}

package/dist/transport/local/local-transport.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=local-transport.test.d.ts.map

package/dist/transport/local/local-transport.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-transport.test.d.ts","sourceRoot":"","sources":["../../../src/transport/local/local-transport.test.ts"],"names":[],"mappings":""}