@zdavison/matador 4.0.3 → 4.2.0

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

@@ -1,149 +0,0 @@
-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;
-// close() call count per connection, indexed by creation order.
-const connectionCloseCounts = [];
-// Set to a connection index to make that connection's createConfirmChannel throw.
-let failConfirmChannelOnConnection = -1;
-function resetMockState() {
-    closeHandlers.length = 0;
-    consumeCallCount = 0;
-    connectionCloseCounts.length = 0;
-    failConfirmChannelOnConnection = -1;
-}
-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 index = connectionCloseCounts.length;
-    connectionCloseCounts.push(0);
-    const channel = makeMockChannel();
-    const connectionCloseListeners = [];
-    const connection = {
-        on: (event, handler) => {
-            if (event === 'close') {
-                connectionCloseListeners.push(handler);
-                closeHandlers.push(handler);
-            }
-        },
-        createChannel: async () => channel,
-        createConfirmChannel: async () => {
-            if (failConfirmChannelOnConnection === index) {
-                throw new Error('simulated channel creation failure');
-            }
-            return channel;
-        },
-        close: async () => {
-            if (connectionCloseCounts[index] !== undefined) {
-                connectionCloseCounts[index]++;
-            }
-        },
-    };
-    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));
-        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);
-        });
-        const triggerClose = closeHandlers[0];
-        if (!triggerClose)
-            throw new Error('no close handler captured from mock connection');
-        triggerClose();
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        expect(consumeCallCount).toBe(2);
-    });
-    it('closes the previous (dead) connection before opening a new one', async () => {
-        await transport.subscribe('test.events', async () => { });
-        // Trigger a new connect (private method)
-        // biome-ignore lint/complexity/useLiteralKeys: private method
-        await transport['doConnect']();
-        // doConnect() must call close() on the stale first connection before
-        // creating a new one, so broker resources are not leaked.
-        expect(connectionCloseCounts[0]).toBe(1);
-    });
-    it('closes the new connection when post-connect setup fails during reconnect', async () => {
-        await transport.subscribe('test.events', async () => { });
-        // Make the second connection's confirm channel creation fail.
-        // ConnectionManager will retry; the third connection succeeds.
-        failConfirmChannelOnConnection = 1;
-        const triggerClose = closeHandlers[0];
-        if (!triggerClose)
-            throw new Error('no close handler captured from mock connection');
-        triggerClose();
-        // Wait for the failed attempt (~10 ms) + successful retry (~10 ms) + margin.
-        await new Promise((resolve) => setTimeout(resolve, 150));
-        // The failed connection (index 1) must be closed by the catch block so it
-        // does not leak as an open broker connection while the retry loop continues.
-        expect(connectionCloseCounts[1]).toBe(1);
-        // The successful retry (connection index 2) recreates the consumer.
-        expect(consumeCallCount).toBe(2);
-    });
-});

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

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

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

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

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

@@ -1,230 +0,0 @@
-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', () => {
-        const url = 'amqp://myuser:mypassword@localhost:5672';
-        const redacted = redactAmqpUrl(url);
-        expect(redacted).toBe('amqp://****:****@localhost:5672');
-    });
-    it('should redact credentials in amqps URLs', () => {
-        const url = 'amqps://admin:secret123@rabbitmq.example.com:5671';
-        const redacted = redactAmqpUrl(url);
-        expect(redacted).toBe('amqps://****:****@rabbitmq.example.com:5671');
-    });
-    it('should redact long credentials to exactly 4 asterisks', () => {
-        const url = 'amqp://verylongusername:verylongpassword@rabbitmq-cluster.svc.local:5672';
-        const redacted = redactAmqpUrl(url);
-        expect(redacted).toBe('amqp://****:****@rabbitmq-cluster.svc.local:5672');
-    });
-    it('should redact short credentials to exactly 4 asterisks', () => {
-        const url = 'amqp://a:b@host:5672';
-        const redacted = redactAmqpUrl(url);
-        expect(redacted).toBe('amqp://****:****@host:5672');
-    });
-    it('should preserve vhost in URL', () => {
-        const url = 'amqp://user:pass@host:5672/myvhost';
-        const redacted = redactAmqpUrl(url);
-        expect(redacted).toBe('amqp://****:****@host:5672/myvhost');
-    });
-    it('should not modify URL without credentials', () => {
-        const url = 'amqp://localhost:5672';
-        const redacted = redactAmqpUrl(url);
-        expect(redacted).toBe('amqp://localhost:5672');
-    });
-    it('should not modify URL with only username (no password)', () => {
-        const url = 'amqp://guest@localhost:5672';
-        const redacted = redactAmqpUrl(url);
-        expect(redacted).toBe('amqp://guest@localhost:5672');
-    });
-    it('should handle URL-encoded credentials', () => {
-        // URL-encoded @ in password: p%40ssword
-        const url = 'amqp://user:p%40ssword@host:5672';
-        const redacted = redactAmqpUrl(url);
-        expect(redacted).toBe('amqp://****:****@host:5672');
-    });
-});
-describe('RabbitMQTransport', () => {
-    describe('connection logging', () => {
-        it('should log redacted connection URL when connecting', async () => {
-            const mockLogger = {
-                debug: mock(() => { }),
-                info: mock(() => { }),
-                warn: mock(() => { }),
-                error: mock(() => { }),
-            };
-            const transport = new RabbitMQTransport({
-                url: 'amqp://testuser:testpass@localhost:5672',
-                connectionName: 'test-connection',
-                logger: mockLogger,
-                connection: {
-                    maxReconnectAttempts: 1, // Only try once to avoid long retries
-                    initialReconnectDelay: 10,
-                },
-            });
-            // Attempt to connect - it will fail since there's no RabbitMQ server
-            // but the log should still be emitted before the connection attempt
-            try {
-                await transport.connect();
-            }
-            catch {
-                // Expected to fail - no RabbitMQ server running
-            }
-            // Verify the log was called with the redacted URL
-            expect(mockLogger.info).toHaveBeenCalledWith("[Matador] \u23F3 Connecting to RabbitMQ at 'amqp://****:****@localhost:5672'.");
-        });
-        it('should log connection URL as-is when no credentials provided', async () => {
-            const mockLogger = {
-                debug: mock(() => { }),
-                info: mock(() => { }),
-                warn: mock(() => { }),
-                error: mock(() => { }),
-            };
-            const transport = new RabbitMQTransport({
-                url: 'amqp://localhost:5672',
-                connectionName: 'test-connection',
-                logger: mockLogger,
-                connection: {
-                    maxReconnectAttempts: 1,
-                    initialReconnectDelay: 10,
-                },
-            });
-            try {
-                await transport.connect();
-            }
-            catch {
-                // Expected to fail
-            }
-            expect(mockLogger.info).toHaveBeenCalledWith("[Matador] \u23F3 Connecting to RabbitMQ at 'amqp://localhost:5672'.");
-        });
-    });
-});
-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/dist/types/event.test.d.ts

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

package/dist/types/event.test.d.ts.map

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

package/dist/types/event.test.js

@@ -1,130 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { createEnvelope } from './envelope.js';
-import { MatadorEvent } from './event.js';
-class UserCreatedEvent extends MatadorEvent {
-    data;
-    static key = 'user.created';
-    static description = 'Fired when a new user is created';
-    constructor(data) {
-        super();
-        this.data = data;
-    }
-}
-class OrderPlacedEvent extends MatadorEvent {
-    data;
-    static key = 'order.placed';
-    static description = 'Fired when an order is placed';
-    static aliases = ['order.created'];
-    constructor(data) {
-        super();
-        this.data = data;
-    }
-}
-class MinimalEvent extends MatadorEvent {
-    data;
-    static key = 'minimal.event';
-    constructor(data) {
-        super();
-        this.data = data;
-    }
-}
-describe('Event', () => {
-    describe('static fields', () => {
-        it('should have static key field on class', () => {
-            expect(UserCreatedEvent.key).toBe('user.created');
-            expect(OrderPlacedEvent.key).toBe('order.placed');
-            expect(MinimalEvent.key).toBe('minimal.event');
-        });
-        it('should have static description field on class when defined', () => {
-            expect(UserCreatedEvent.description).toBe('Fired when a new user is created');
-            expect(OrderPlacedEvent.description).toBe('Fired when an order is placed');
-            expect(MinimalEvent.description).toBeUndefined();
-        });
-        it('should have static aliases field on class when defined', () => {
-            expect(UserCreatedEvent.aliases).toBeUndefined();
-            expect(OrderPlacedEvent.aliases).toEqual(['order.created']);
-            expect(MinimalEvent.aliases).toBeUndefined();
-        });
-    });
-    describe('instance data', () => {
-        it('should have instance data field', () => {
-            const event = new UserCreatedEvent({
-                userId: 'usr_001',
-                email: 'test@example.com',
-            });
-            expect(event.data).toEqual({
-                userId: 'usr_001',
-                email: 'test@example.com',
-            });
-        });
-    });
-});
-describe('Envelope with eventDescription', () => {
-    it('should include eventDescription in docket when provided', () => {
-        const event = new UserCreatedEvent({
-            userId: 'usr_123',
-            email: 'test@example.com',
-        });
-        const envelope = createEnvelope({
-            eventKey: UserCreatedEvent.key,
-            eventDescription: UserCreatedEvent.description,
-            targetSubscriber: 'test-subscriber',
-            data: event.data,
-            importance: 'should-investigate',
-        });
-        expect(envelope.docket.eventKey).toBe('user.created');
-        expect(envelope.docket.eventDescription).toBe('Fired when a new user is created');
-    });
-    it('should not include eventDescription in docket when undefined', () => {
-        const event = new MinimalEvent({ id: 'min_123' });
-        const envelope = createEnvelope({
-            eventKey: MinimalEvent.key,
-            eventDescription: MinimalEvent.description,
-            targetSubscriber: 'test-subscriber',
-            data: event.data,
-            importance: 'should-investigate',
-        });
-        expect(envelope.docket.eventKey).toBe('minimal.event');
-        expect(envelope.docket.eventDescription).toBeUndefined();
-    });
-    it('should serialize envelope with eventDescription for logging', () => {
-        const event = new OrderPlacedEvent({
-            orderId: 'ord_456',
-            amount: 99.99,
-        });
-        const envelope = createEnvelope({
-            eventKey: OrderPlacedEvent.key,
-            eventDescription: OrderPlacedEvent.description,
-            targetSubscriber: 'order-processor',
-            data: event.data,
-            importance: 'must-investigate',
-        });
-        const serialized = JSON.stringify(envelope);
-        const parsed = JSON.parse(serialized);
-        expect(parsed.docket.eventKey).toBe('order.placed');
-        expect(parsed.docket.eventDescription).toBe('Fired when an order is placed');
-        expect(parsed.data.orderId).toBe('ord_456');
-    });
-    it('should include eventDescription in hook logging context', () => {
-        const event = new UserCreatedEvent({
-            userId: 'usr_error',
-            email: 'error@example.com',
-        });
-        const envelope = createEnvelope({
-            eventKey: UserCreatedEvent.key,
-            eventDescription: UserCreatedEvent.description,
-            targetSubscriber: 'user-handler',
-            data: event.data,
-            importance: 'should-investigate',
-        });
-        // Simulating what would be logged in onEnqueueError hook
-        const errorLog = {
-            message: 'Failed to enqueue event',
-            eventKey: envelope.docket.eventKey,
-            eventDescription: envelope.docket.eventDescription,
-            data: envelope.data,
-        };
-        expect(errorLog.eventKey).toBe('user.created');
-        expect(errorLog.eventDescription).toBe('Fired when a new user is created');
-    });
-});