@zdavison/matador 3.0.8 → 4.0.0

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

@@ -1,4 +1,5 @@
 import { describe, expect, it, mock } from 'bun:test';
+import { TopologyBuilder } from '../../topology/index.js';
 import { RabbitMQTransport, redactAmqpUrl } from './rabbitmq-transport.js';
 describe('redactAmqpUrl', () => {
     it('should redact username and password with 4 asterisks', () => {
@@ -98,3 +99,132 @@ describe('RabbitMQTransport', () => {
         });
     });
 });
+describe('dead-letter and retry queue naming under withNaming', () => {
+    // A v1-style naming strategy: a migrating deployment keeps Matador v1's
+    // `matador.{ns}.{queue}` names so DLQ/retry resources stay identifiable.
+    const NS = 'myapp';
+    const v1Naming = {
+        queue: (ns, q) => `matador.${ns}.${q}`,
+        mainExchange: (ns) => `matador.${ns}`,
+        dlxExchange: (ns) => `matador.${ns}.dlx-undeliverable`,
+        dlxExchangeType: 'topic',
+    };
+    function buildTopology() {
+        return TopologyBuilder.create()
+            .withNamespace(NS)
+            .withNaming(v1Naming)
+            .addQueue('events')
+            .build();
+    }
+    function createRecordingChannel() {
+        const assertQueueCalls = [];
+        const bindQueueCalls = [];
+        const channel = {
+            assertQueue: (name, options) => {
+                assertQueueCalls.push({ name, options });
+                return Promise.resolve({ queue: name });
+            },
+            bindQueue: (queue, exchange, routingKey) => {
+                bindQueueCalls.push({ queue, exchange, routingKey });
+                return Promise.resolve({});
+            },
+        };
+        return { channel, assertQueueCalls, bindQueueCalls };
+    }
+    function createTransport() {
+        return new RabbitMQTransport({
+            url: 'amqp://localhost:5672',
+            connectionName: 'test',
+        });
+    }
+    it('derives the retry queue name through the naming strategy', async () => {
+        const transport = createTransport();
+        const topology = buildTopology();
+        const queueDef = topology.queues[0];
+        const { channel, assertQueueCalls, bindQueueCalls } = createRecordingChannel();
+        await transport.assertRetryQueue(channel, topology, queueDef);
+        expect(assertQueueCalls.map((c) => c.name)).toEqual([
+            'matador.myapp.events.retry',
+        ]);
+        // Retry queue dead-letters back to the (overridden) main exchange using the
+        // resolved work-queue name as the routing key.
+        const retryOptions = assertQueueCalls[0]?.options;
+        expect(retryOptions.arguments['x-dead-letter-exchange']).toBe('matador.myapp');
+        expect(retryOptions.arguments['x-dead-letter-routing-key']).toBe('matador.myapp.events');
+        expect(bindQueueCalls).toEqual([
+            {
+                queue: 'matador.myapp.events.retry',
+                exchange: 'matador.myapp',
+                routingKey: 'matador.myapp.events.retry',
+            },
+        ]);
+    });
+    it('derives DLQ names through the naming strategy and binds them to the overridden DLX', async () => {
+        const transport = createTransport();
+        const topology = buildTopology();
+        const { channel, assertQueueCalls, bindQueueCalls } = createRecordingChannel();
+        const assertDeadLetterQueues = transport.assertDeadLetterQueues.bind(transport);
+        await assertDeadLetterQueues(channel, topology, 'unhandled');
+        await assertDeadLetterQueues(channel, topology, 'undeliverable');
+        expect(assertQueueCalls.map((c) => c.name)).toEqual([
+            'matador.myapp.events.unhandled',
+            'matador.myapp.events.undeliverable',
+        ]);
+        expect(bindQueueCalls).toEqual([
+            {
+                queue: 'matador.myapp.events.unhandled',
+                exchange: 'matador.myapp.dlx-undeliverable',
+                routingKey: 'matador.myapp.events.unhandled',
+            },
+            {
+                queue: 'matador.myapp.events.undeliverable',
+                exchange: 'matador.myapp.dlx-undeliverable',
+                routingKey: 'matador.myapp.events.undeliverable',
+            },
+        ]);
+    });
+});
+describe('confirmPublish', () => {
+    function createTransport(publishTimeoutMs) {
+        return new RabbitMQTransport({
+            url: 'amqp://localhost:5672',
+            connectionName: 'test',
+            ...(publishTimeoutMs !== undefined ? { publishTimeoutMs } : {}),
+        });
+    }
+    function callConfirmPublish(transport, publish) {
+        const fakeChannel = {
+            publish: (_exchange, _routingKey, _buffer, _options, cb) => {
+                publish(cb);
+                return true;
+            },
+        };
+        return transport.confirmPublish(fakeChannel, 'ex', 'queue', Buffer.from('x'), {});
+    }
+    it('resolves when the broker confirms the publish', async () => {
+        const transport = createTransport();
+        await callConfirmPublish(transport, (cb) => cb(null));
+    });
+    it('rejects with TransportSendError when the broker nacks', async () => {
+        const transport = createTransport();
+        await expect(callConfirmPublish(transport, (cb) => cb(new Error('nacked')))).rejects.toMatchObject({
+            name: 'TransportSendError',
+            queue: 'queue',
+        });
+    });
+    it('rejects when the broker never confirms within the timeout', async () => {
+        const transport = createTransport(50);
+        await expect(callConfirmPublish(transport, () => {
+            // Broker never calls back.
+        })).rejects.toMatchObject({ name: 'TransportSendError' });
+    });
+    it('ignores a late confirm after the timeout already rejected', async () => {
+        const transport = createTransport(50);
+        let lateCallback;
+        await expect(callConfirmPublish(transport, (cb) => {
+            lateCallback = cb;
+        })).rejects.toMatchObject({ name: 'TransportSendError' });
+        // Late confirm must not throw or double-settle.
+        lateCallback?.(null);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zdavison/matador",
-  "version": "3.0.8",
+  "version": "4.0.0",
   "description": "A batteries-included event system.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -67,5 +67,9 @@
   "files": [
     "dist",
     "cli.ts"
-  ]
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/meetsmore/matador.git"
+  }
 }