@zdavison/matador 3.0.6 → 4.0.0

package/dist/transport/rabbitmq/rabbitmq-transport-reconnection.test.js

@@ -0,0 +1,110 @@
+import { beforeEach, describe, expect, it, mock } from 'bun:test';
+import { TopologyBuilder } from '../../topology/index.js';
+// Hoisted by Bun before static imports are resolved.
+// Keeps amqplib out of the other rabbitmq-transport.test.ts which relies on
+// real connection failures for its logging assertions.
+mock.module('amqplib', () => {
+    return { default: { connect: mockConnect } };
+});
+// ─── Shared mock state ────────────────────────────────────────────────────────
+// Handlers registered by doConnect() for the 'close' event on the connection.
+// Index 0 = first (initial) connection, index 1 = second (post-reconnect), …
+const closeHandlers = [];
+// Total number of times channel.consume() has been called across all connections.
+let consumeCallCount = 0;
+function resetMockState() {
+    closeHandlers.length = 0;
+    consumeCallCount = 0;
+}
+function makeMockChannel() {
+    return {
+        on: () => { },
+        assertExchange: async () => { },
+        assertQueue: async (_name) => ({ queue: _name }),
+        bindQueue: async () => { },
+        prefetch: async () => { },
+        consume: async (_queue, _handler) => {
+            consumeCallCount++;
+            return { consumerTag: `consumer-${consumeCallCount}` };
+        },
+        cancel: async () => { },
+        close: async () => { },
+        // ConfirmChannel publish — immediately acks
+        publish: (_exchange, _routingKey, _buffer, _options, cb) => {
+            cb(null);
+            return true;
+        },
+    };
+}
+function mockConnect() {
+    const channel = makeMockChannel();
+    const connectionCloseListeners = [];
+    const connection = {
+        on: (event, handler) => {
+            if (event === 'close') {
+                connectionCloseListeners.push(handler);
+                closeHandlers.push(handler);
+            }
+        },
+        createChannel: async () => channel,
+        createConfirmChannel: async () => channel,
+        close: async () => { },
+    };
+    return Promise.resolve(connection);
+}
+// ─── Tests ────────────────────────────────────────────────────────────────────
+import { RabbitMQTransport } from './rabbitmq-transport.js';
+const topology = TopologyBuilder.create()
+    .withNamespace('test')
+    .addQueue('events')
+    .build();
+describe('RabbitMQTransport – consumer recreation on reconnect', () => {
+    let transport;
+    beforeEach(async () => {
+        resetMockState();
+        transport = new RabbitMQTransport({
+            url: 'amqp://localhost:5672',
+            connectionName: 'test',
+            connection: {
+                initialReconnectDelay: 10,
+                maxReconnectDelay: 10,
+            },
+        });
+        await transport.connect();
+        await transport.applyTopology(topology);
+    });
+    it('registers one consumer per queue on initial connect', async () => {
+        await transport.subscribe('test.events', async () => { });
+        expect(consumeCallCount).toBe(1);
+    });
+    it('recreates consumers after the connection drops and reconnects', async () => {
+        await transport.subscribe('test.events', async () => { });
+        expect(consumeCallCount).toBe(1);
+        // Simulate an unexpected connection close.
+        // doConnect() registered a 'close' listener that calls
+        // connectionManager.handleConnectionLost(), which triggers reconnection.
+        const triggerClose = closeHandlers[0];
+        if (!triggerClose)
+            throw new Error('no close handler captured from mock connection');
+        triggerClose();
+        // Give the ConnectionManager time to reconnect (initialReconnectDelay = 10 ms).
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        // After reconnect, doConnect() runs again and re-applies topology and recreates consumers.
+        expect(consumeCallCount).toBe(2);
+    });
+    it('delivers messages to the handler after reconnect', async () => {
+        const received = [];
+        await transport.subscribe('test.events', async (envelope) => {
+            received.push(envelope);
+        });
+        // Trigger reconnect
+        const triggerClose = closeHandlers[0];
+        if (!triggerClose)
+            throw new Error('no close handler captured from mock connection');
+        triggerClose();
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        // After reconnect the consumer should be active. Simulate message delivery
+        // by invoking the consume callback captured in the mock.
+        expect(consumeCallCount).toBe(2);
+    });
+});

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

@@ -20,6 +20,15 @@ export interface RabbitMQTransportConfig {
     readonly defaultPrefetch?: number | undefined;
     /** Enable the delayed message exchange plugin if available (default: true) */
     readonly enableDelayedMessages?: boolean | undefined;
+    /**
+     * How long to wait for the broker to confirm a publish before failing,
+     * in milliseconds (default: 5000).
+     *
+     * Publishes use a confirm channel: `send()` resolves only once the broker
+     * acks the message, and rejects on nack or timeout, so callers can await
+     * delivery confirmation rather than treating publishes as fire-and-forget.
+     */
+    readonly publishTimeoutMs?: number | undefined;
     /** Logger for transport events (defaults to console) */
     readonly logger?: Logger | undefined;
 }
@@ -42,6 +51,7 @@ export declare class RabbitMQTransport implements Transport {
     private publishChannel;
     private readonly connectionManager;
     private readonly queueChannels;
+    private readonly subscriptionIntents;
     private topology;
     private readonly codec;
     private readonly config;
@@ -54,8 +64,22 @@ export declare class RabbitMQTransport implements Transport {
     applyTopology(topology: Topology): Promise<void>;
     send(queue: string, envelope: Envelope, options?: SendOptions): Promise<Transport['name']>;
     subscribe(queue: string, handler: MessageHandler, options?: SubscribeOptions): Promise<Subscription>;
+    /**
+     * Wires a single subscription intent to the current connection.
+     * Called once on subscribe() and again after each reconnect.
+     */
+    private activateIntent;
     complete(receipt: MessageReceipt): Promise<void>;
     sendToDeadLetter(receipt: MessageReceipt, dlqName: string, envelope: Envelope, reason: string): Promise<void>;
+    /**
+     * Publishes on the confirm channel and resolves once the broker
+     * acknowledges the message, rejecting on broker nack, channel error, or
+     * after `publishTimeoutMs` elapses without a confirm.
+     *
+     * Mirrors Matador v1's promise-wrapped amqplib publish callback to give
+     * callers confirmed (at-least-once) delivery semantics.
+     */
+    private confirmPublish;
     /**
      * Gets or creates a dedicated channel for a queue subscription.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"rabbitmq-transport.d.ts","sourceRoot":"","sources":["../../../src/transport/rabbitmq/rabbitmq-transport.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"rabbitmq-transport.d.ts","sourceRoot":"","sources":["../../../src/transport/rabbitmq/rabbitmq-transport.ts"],"names":[],"mappings":"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"}

package/dist/transport/rabbitmq/rabbitmq-transport.js

@@ -1,7 +1,8 @@
 import amqplib from 'amqplib';
 import { RabbitMQCodec } from '../../codec/rabbitmq-codec.js';
-import { DelayedMessagesNotSupportedError, TransportNotConnectedError, } from '../../errors/index.js';
+import { DelayedMessagesNotSupportedError, TransportNotConnectedError, TransportSendError, } from '../../errors/index.js';
 import { consoleLogger } from '../../hooks/index.js';
+import { applyPrefix, getDeadLetterQueueName, getRetryQueueName, resolveQueueName, } from '../../topology/types.js';
 import { ConnectionManager, } from '../connection-manager.js';
 /**
  * Redacts credentials from an AMQP URL.
@@ -35,6 +36,7 @@ export class RabbitMQTransport {
     publishChannel = null;
     connectionManager;
     queueChannels = new Map();
+    subscriptionIntents = [];
     topology = null;
     codec = new RabbitMQCodec();
     config;
@@ -49,6 +51,7 @@ export class RabbitMQTransport {
             quorumQueues: config.quorumQueues ?? true,
             defaultPrefetch: config.defaultPrefetch ?? 10,
             enableDelayedMessages: config.enableDelayedMessages ?? true,
+            publishTimeoutMs: config.publishTimeoutMs ?? 5000,
         };
         this.connectionManager = new ConnectionManager(() => this.doConnect(), () => this.doDisconnect(), this.config.connection);
     }
@@ -68,17 +71,17 @@ export class RabbitMQTransport {
         }
         const channel = this.publishChannel;
         // Create the main exchange for routing messages to queues
-        const mainExchange = this.getMainExchangeName(topology.namespace);
+        const mainExchange = this.getMainExchangeName(topology);
         await channel.assertExchange(mainExchange, 'direct', { durable: true });
         // Create dead-letter exchange if DLQ is enabled
-        const dlxExchange = this.getDLXExchangeName(topology.namespace);
+        const dlxExchange = this.getDLXExchangeName(topology);
         if (topology.deadLetter.unhandled.enabled ||
             topology.deadLetter.undeliverable.enabled) {
-            await channel.assertExchange(dlxExchange, 'direct', { durable: true });
+            await channel.assertExchange(dlxExchange, topology.naming?.dlxExchangeType ?? 'direct', { durable: true });
         }
         // Check for delayed message exchange plugin
         if (this.config.enableDelayedMessages) {
-            await this.setupDelayedExchange(topology.namespace);
+            await this.setupDelayedExchange(topology);
         }
         // Create work queues
         for (const queueDef of topology.queues) {
@@ -113,12 +116,12 @@ export class RabbitMQTransport {
             if (!this.delayedExchangeAvailable) {
                 throw new DelayedMessagesNotSupportedError(this.name);
             }
-            const delayedExchange = this.getDelayedExchangeName(this.topology.namespace);
+            const delayedExchange = this.getDelayedExchangeName(this.topology);
             publishOptions.headers = {
                 ...publishOptions.headers,
                 'x-delay': options.delay,
             };
-            this.publishChannel.publish(delayedExchange, queue, buffer, publishOptions);
+            await this.confirmPublish(this.publishChannel, delayedExchange, queue, buffer, publishOptions);
             return this.name;
         }
         // Transport-specific options
@@ -129,15 +132,67 @@ export class RabbitMQTransport {
             publishOptions.persistent = options.transport.rabbitmq.persistent;
         }
         const routingKey = options?.transport?.rabbitmq?.routingKey ?? queue;
-        const exchange = this.getMainExchangeName(this.topology.namespace);
-        this.publishChannel.publish(exchange, routingKey, buffer, publishOptions);
+        const exchange = this.getMainExchangeName(this.topology);
+        await this.confirmPublish(this.publishChannel, exchange, routingKey, buffer, publishOptions);
         return this.name;
     }
     async subscribe(queue, handler, options = {}) {
         if (!this.connection || !this.topology) {
             throw new TransportNotConnectedError(this.name, 'subscribe');
         }
-        // Get or create a dedicated channel for this queue
+        const intent = {
+            queue,
+            handler,
+            options,
+            active: true,
+            currentConsumer: null,
+        };
+        this.subscriptionIntents.push(intent);
+        await this.activateIntent(intent);
+        return {
+            unsubscribe: async () => {
+                intent.active = false;
+                const idx = this.subscriptionIntents.indexOf(intent);
+                if (idx !== -1)
+                    this.subscriptionIntents.splice(idx, 1);
+                const consumer = intent.currentConsumer;
+                if (consumer) {
+                    consumer.active = false;
+                    const queueChannel = this.queueChannels.get(queue);
+                    if (queueChannel) {
+                        try {
+                            await queueChannel.channel.cancel(consumer.consumerTag);
+                        }
+                        catch {
+                            // Channel may already be closed
+                        }
+                        const cIdx = queueChannel.consumers.indexOf(consumer);
+                        if (cIdx !== -1)
+                            queueChannel.consumers.splice(cIdx, 1);
+                        if (queueChannel.consumers.length === 0) {
+                            try {
+                                await queueChannel.channel.close();
+                            }
+                            catch {
+                                // Ignore
+                            }
+                            this.queueChannels.delete(queue);
+                        }
+                    }
+                    intent.currentConsumer = null;
+                }
+            },
+            get isActive() {
+                return intent.active;
+            },
+        };
+    }
+    /**
+     * Wires a single subscription intent to the current connection.
+     * Called once on subscribe() and again after each reconnect.
+     */
+    async activateIntent(intent) {
+        const { queue, handler, options } = intent;
         const queueChannel = await this.getOrCreateQueueChannel(queue, options);
         const { channel } = queueChannel;
         const consumer = {
@@ -163,43 +218,12 @@ export class RabbitMQTransport {
                 await handler(envelope, receipt);
             }
             catch (error) {
-                // Handler errors should be caught in the pipeline
                 this.logger.error('[Matador] 🔴 Handler error in message processing', error);
             }
         }, { noAck: false });
-        // Update the consumer tag
         consumer.consumerTag = consumerTag;
-        // Track the consumer
         queueChannel.consumers.push(consumer);
-        return {
-            unsubscribe: async () => {
-                consumer.active = false;
-                try {
-                    await channel.cancel(consumerTag);
-                }
-                catch {
-                    // Channel may already be closed
-                }
-                // Remove consumer from tracking
-                const idx = queueChannel.consumers.indexOf(consumer);
-                if (idx !== -1) {
-                    queueChannel.consumers.splice(idx, 1);
-                }
-                // Close channel if no more consumers on this queue
-                if (queueChannel.consumers.length === 0) {
-                    try {
-                        await channel.close();
-                    }
-                    catch {
-                        // Ignore
-                    }
-                    this.queueChannels.delete(queue);
-                }
-            },
-            get isActive() {
-                return consumer.active;
-            },
-        };
+        intent.currentConsumer = consumer;
     }
     async complete(receipt) {
         const { channel, msg } = receipt.handle;
@@ -226,7 +250,7 @@ export class RabbitMQTransport {
         };
         const encoded = this.codec.encode(dlqEnvelope);
         const buffer = Buffer.from(encoded.body);
-        const dlxExchange = this.getDLXExchangeName(this.topology.namespace);
+        const dlxExchange = this.getDLXExchangeName(this.topology);
         const dlqQueueName = `${receipt.sourceQueue}.${dlqName}`;
         const publishOptions = {
             persistent: true,
@@ -238,10 +262,41 @@ export class RabbitMQTransport {
                 'x-matador-dead-letter-reason': reason,
             },
         };
-        this.publishChannel.publish(dlxExchange, dlqQueueName, buffer, publishOptions);
+        await this.confirmPublish(this.publishChannel, dlxExchange, dlqQueueName, buffer, publishOptions);
         // Complete the original message
         await this.complete(receipt);
     }
+    /**
+     * Publishes on the confirm channel and resolves once the broker
+     * acknowledges the message, rejecting on broker nack, channel error, or
+     * after `publishTimeoutMs` elapses without a confirm.
+     *
+     * Mirrors Matador v1's promise-wrapped amqplib publish callback to give
+     * callers confirmed (at-least-once) delivery semantics.
+     */
+    confirmPublish(channel, exchange, routingKey, buffer, options) {
+        return new Promise((resolve, reject) => {
+            let timeout = setTimeout(() => {
+                timeout = null;
+                reject(new TransportSendError(routingKey, new Error(`Publish not confirmed by broker within ${this.config.publishTimeoutMs}ms`)));
+            }, this.config.publishTimeoutMs);
+            channel.publish(exchange, routingKey, buffer, options, (err) => {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                else {
+                    // Already timed out and rejected; nothing left to settle.
+                    return;
+                }
+                if (err) {
+                    reject(new TransportSendError(routingKey, err));
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
     // Private methods
     /**
      * Gets or creates a dedicated channel for a queue subscription.
@@ -272,6 +327,8 @@ export class RabbitMQTransport {
         return queueChannel;
     }
     async doConnect() {
+        // Drop stale channel objects so getOrCreateQueueChannel opens fresh ones
+        this.queueChannels.clear();
         this.logger.info(`[Matador] ⏳ Connecting to RabbitMQ at '${redactAmqpUrl(this.config.url)}'.`);
         const connection = await amqplib.connect(this.config.url, {
             clientProperties: { connection_name: this.config.connectionName },
@@ -282,13 +339,22 @@ export class RabbitMQTransport {
             this.logger.error('[Matador] 🔴 RabbitMQ connection error', err);
         });
         connection.on('close', () => {
+            // Immediately deactivate all live consumers so any buffered messages
+            // delivered on the dying connection are dropped rather than partially
+            // processed (handler fires but ack silently fails on the dead channel).
+            for (const queueChannel of this.queueChannels.values()) {
+                for (const consumer of queueChannel.consumers) {
+                    consumer.active = false;
+                }
+            }
             if (this.connectionManager.isConnected()) {
                 // Unexpected close, trigger reconnection
                 this.connectionManager.handleConnectionLost(new Error('Connection closed unexpectedly'));
             }
         });
-        // Create the publish channel
-        this.publishChannel = await connection.createChannel();
+        // Create the publish channel.
+        // A confirm channel so publishes can await broker acknowledgement.
+        this.publishChannel = await connection.createConfirmChannel();
         // Handle publish channel errors to prevent unhandled error events
         this.publishChannel.on('error', (err) => {
             this.logger.error('[Matador] 🔴 RabbitMQ publish channel error', err);
@@ -296,7 +362,12 @@ export class RabbitMQTransport {
         // Re-apply topology if we have one (reconnection scenario)
         if (this.topology) {
             await this.applyTopology(this.topology);
+            // Recreate consumers for every active subscription on the new connection.
+            for (const intent of this.subscriptionIntents) {
+                await this.activateIntent(intent);
+            }
         }
+        this.logger.info('[Matador] 🔌 Connected to RabbitMQ');
     }
     async doDisconnect() {
         // Cancel all consumers and close queue channels
@@ -345,13 +416,13 @@ export class RabbitMQTransport {
             delayedMessages: false,
         };
     }
-    async setupDelayedExchange(namespace) {
+    async setupDelayedExchange(topology) {
         if (!this.connection) {
             return;
         }
         // Default to disabled
         this.delayedExchangeAvailable = false;
-        const delayedExchange = this.getDelayedExchangeName(namespace);
+        const delayedExchange = this.getDelayedExchangeName(topology);
         const connection = this.connection;
         // Use a promise-based approach to ensure all error paths resolve cleanly
         // This prevents any error from propagating and affecting other channels
@@ -417,7 +488,7 @@ export class RabbitMQTransport {
         if (topology.deadLetter.unhandled.enabled ||
             topology.deadLetter.undeliverable.enabled) {
             queueOptions.arguments['x-dead-letter-exchange'] =
-                this.getDLXExchangeName(topology.namespace);
+                this.getDLXExchangeName(topology);
         }
         if (queueDef.priorities) {
             queueOptions.arguments['x-max-priority'] = 10;
@@ -428,18 +499,16 @@ export class RabbitMQTransport {
         return queueOptions;
     }
     async assertWorkQueue(channel, topology, queueDef) {
-        const queueName = queueDef.exact
-            ? queueDef.name
-            : `${topology.namespace}.${queueDef.name}`;
+        const queueName = resolveQueueName(topology.namespace, queueDef, topology.naming, topology.prefix);
         const rabbitmqOptions = queueDef.transport?.rabbitmq?.options;
         const queueOptions = rabbitmqOptions ?? this.buildWorkQueueOptions(topology, queueDef);
         await channel.assertQueue(queueName, queueOptions);
         // Bind queue to main exchange
-        const mainExchange = this.getMainExchangeName(topology.namespace);
+        const mainExchange = this.getMainExchangeName(topology);
         await channel.bindQueue(queueName, mainExchange, queueName);
         // Bind to delayed exchange if available
         if (this.delayedExchangeAvailable) {
-            const delayedExchange = this.getDelayedExchangeName(topology.namespace);
+            const delayedExchange = this.getDelayedExchangeName(topology);
             await channel.bindQueue(queueName, delayedExchange, queueName);
         }
         // Create retry queue if retry is enabled.
@@ -449,12 +518,13 @@ export class RabbitMQTransport {
         // namespaces share the broker and the queue. This mirrors the existing
         // `if (queueDef.exact) continue` guard in `assertDeadLetterQueues`.
         if (topology.retry.enabled && !queueDef.exact) {
-            await this.assertRetryQueue(channel, topology, queueName);
+            await this.assertRetryQueue(channel, topology, queueDef);
         }
     }
-    async assertRetryQueue(channel, topology, workQueueName) {
-        const retryQueueName = `${workQueueName}.retry`;
-        const mainExchange = this.getMainExchangeName(topology.namespace);
+    async assertRetryQueue(channel, topology, queueDef) {
+        const workQueueName = resolveQueueName(topology.namespace, queueDef, topology.naming, topology.prefix);
+        const retryQueueName = getRetryQueueName(topology.namespace, queueDef.name, topology.naming, topology.prefix);
+        const mainExchange = this.getMainExchangeName(topology);
         const retryQueueOptions = {
             durable: true,
             arguments: {
@@ -470,13 +540,12 @@ export class RabbitMQTransport {
         await channel.bindQueue(retryQueueName, mainExchange, retryQueueName);
     }
     async assertDeadLetterQueues(channel, topology, dlqType) {
-        const dlxExchange = this.getDLXExchangeName(topology.namespace);
+        const dlxExchange = this.getDLXExchangeName(topology);
         const dlConfig = topology.deadLetter[dlqType];
         for (const queueDef of topology.queues) {
             if (queueDef.exact)
                 continue;
-            const workQueueName = `${topology.namespace}.${queueDef.name}`;
-            const dlqName = `${workQueueName}.${dlqType}`;
+            const dlqName = getDeadLetterQueueName(topology.namespace, queueDef.name, dlqType, topology.naming, topology.prefix);
             const dlqOptions = {
                 durable: true,
                 arguments: {},
@@ -484,19 +553,27 @@ export class RabbitMQTransport {
             if (dlConfig.maxLength) {
                 dlqOptions.arguments['x-max-length'] = dlConfig.maxLength;
             }
-            // DLQs use classic queues (not quorum) for simplicity
+            // DLQs follow the same quorum setting as work and retry queues, so a
+            // broker node restart does not take the queue (and its messages) down
+            // with it.
+            if (this.config.quorumQueues) {
+                dlqOptions.arguments['x-queue-type'] = 'quorum';
+            }
             await channel.assertQueue(dlqName, dlqOptions);
             await channel.bindQueue(dlqName, dlxExchange, dlqName);
         }
     }
-    getMainExchangeName(namespace) {
-        return `${namespace}.exchange`;
+    getMainExchangeName(topology) {
+        return (topology.naming?.mainExchange?.(topology.namespace) ??
+            applyPrefix(topology.prefix, `${topology.namespace}.exchange`));
     }
-    getDLXExchangeName(namespace) {
-        return `${namespace}.dlx`;
+    getDLXExchangeName(topology) {
+        return (topology.naming?.dlxExchange?.(topology.namespace) ??
+            applyPrefix(topology.prefix, `${topology.namespace}.dlx`));
     }
-    getDelayedExchangeName(namespace) {
-        return `${namespace}.delayed`;
+    getDelayedExchangeName(topology) {
+        return (topology.naming?.delayedExchange?.(topology.namespace) ??
+            applyPrefix(topology.prefix, `${topology.namespace}.delayed`));
     }
     getAttemptNumber(msg) {
         const headerValue = msg.properties.headers?.['x-matador-attempts'];