@zdavison/matador 4.0.3 → 4.2.0

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

@@ -1,232 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test';
-import { LocalTransportNoActiveSubscriberError } from '../../errors/index.js';
-import { createEnvelope } from '../../types/index.js';
-import { LocalTransport } from './local-transport.js';
-describe('LocalTransport', () => {
-    let transport;
-    beforeEach(() => {
-        transport = new LocalTransport();
-    });
-    describe('connection', () => {
-        it('should start disconnected', () => {
-            expect(transport.isConnected()).toBe(false);
-        });
-        it('should connect successfully', async () => {
-            await transport.connect();
-            expect(transport.isConnected()).toBe(true);
-        });
-        it('should disconnect successfully', async () => {
-            await transport.connect();
-            await transport.disconnect();
-            expect(transport.isConnected()).toBe(false);
-        });
-    });
-    describe('capabilities', () => {
-        it('should report correct capabilities', () => {
-            expect(transport.name).toBe('local');
-            expect(transport.capabilities.deliveryModes).toContain('at-least-once');
-            expect(transport.capabilities.delayedMessages).toBe(true);
-            expect(transport.capabilities.deadLetterRouting).toBe('manual');
-        });
-    });
-    describe('send and receive', () => {
-        beforeEach(async () => {
-            await transport.connect();
-            // A no-op subscriber makes 'test-queue' deliverable; LocalTransport now
-            // rejects sends to queues with no active subscriber in this process.
-            await transport.subscribe('test-queue', async () => { });
-        });
-        it('should throw when sending while disconnected', async () => {
-            await transport.disconnect();
-            const envelope = createTestEnvelope();
-            await expect(transport.send('test-queue', envelope)).rejects.toThrow('is not connected');
-        });
-        it('should throw when sending to a queue with no active subscriber', async () => {
-            const envelope = createTestEnvelope();
-            await expect(transport.send('unsubscribed-queue', envelope)).rejects.toThrow(LocalTransportNoActiveSubscriberError);
-        });
-        it('should send and receive a message', async () => {
-            const envelope = createTestEnvelope();
-            await transport.send('test-queue', envelope);
-            const received = await transport.receiveOne('test-queue');
-            expect(received).not.toBeNull();
-            expect(received?.envelope.id).toBe(envelope.id);
-            expect(received?.envelope.data).toEqual({ test: 'data' });
-        });
-        it('should track queue size correctly', async () => {
-            expect(transport.getQueueSize('test-queue')).toBe(0);
-            await transport.send('test-queue', createTestEnvelope());
-            expect(transport.getQueueSize('test-queue')).toBe(1);
-            await transport.send('test-queue', createTestEnvelope());
-            expect(transport.getQueueSize('test-queue')).toBe(2);
-        });
-        it('should complete messages and remove from queue', async () => {
-            const envelope = createTestEnvelope();
-            await transport.send('test-queue', envelope);
-            const received = await transport.receiveOne('test-queue');
-            if (!received)
-                throw new Error('expected received message');
-            await transport.complete(received.receipt);
-            expect(transport.getQueueSize('test-queue')).toBe(0);
-            expect(transport.getCompleted()).toHaveLength(1);
-        });
-        it('should return null when queue is empty', async () => {
-            const received = await transport.receiveOne('empty-queue');
-            expect(received).toBeNull();
-        });
-        it('should preserve FIFO order of pending messages', async () => {
-            const envelopes = [0, 1, 2].map((seq) => createEnvelope({
-                eventKey: 'test.event',
-                targetSubscriber: 'test-subscriber',
-                data: { seq },
-                importance: 'should-investigate',
-            }));
-            for (const envelope of envelopes) {
-                await transport.send('test-queue', envelope);
-            }
-            expect(transport.getPendingMessages('test-queue').map((e) => e.data)).toEqual([{ seq: 0 }, { seq: 1 }, { seq: 2 }]);
-            for (const envelope of envelopes) {
-                const received = await transport.receiveOne('test-queue');
-                expect(received?.envelope.id).toBe(envelope.id);
-                if (received)
-                    await transport.complete(received.receipt);
-            }
-        });
-    });
-    describe('subscriptions', () => {
-        beforeEach(async () => {
-            await transport.connect();
-        });
-        it('should throw when subscribing while disconnected', async () => {
-            await transport.disconnect();
-            await expect(transport.subscribe('test-queue', async () => { })).rejects.toThrow('is not connected');
-        });
-        it('should deliver messages to subscribers', async () => {
-            const receivedMessages = [];
-            await transport.subscribe('test-queue', async (envelope) => {
-                receivedMessages.push(envelope);
-            });
-            const envelope = createTestEnvelope();
-            await transport.send('test-queue', envelope);
-            expect(receivedMessages).toHaveLength(1);
-            expect(receivedMessages[0].id).toBe(envelope.id);
-        });
-        it('should redeliver pending (uncompleted) messages to a newly attached subscriber', async () => {
-            const firstSubscriberMessages = [];
-            const firstSubscription = await transport.subscribe('test-queue', async (envelope) => {
-                firstSubscriberMessages.push(envelope);
-            });
-            const envelope = createTestEnvelope();
-            await transport.send('test-queue', envelope);
-            expect(firstSubscriberMessages).toHaveLength(1);
-            // First subscriber never completed the message before going away.
-            await firstSubscription.unsubscribe();
-            const secondSubscriberMessages = [];
-            await transport.subscribe('test-queue', async (env) => {
-                secondSubscriberMessages.push(env);
-            });
-            expect(secondSubscriberMessages).toHaveLength(1);
-        });
-        it('should stop delivering after unsubscribe', async () => {
-            const receivedMessages = [];
-            const subscription = await transport.subscribe('test-queue', async (envelope) => {
-                receivedMessages.push(envelope);
-            });
-            await transport.send('test-queue', createTestEnvelope());
-            expect(receivedMessages).toHaveLength(1);
-            await subscription.unsubscribe();
-            expect(subscription.isActive).toBe(false);
-        });
-    });
-    describe('dead letter queue', () => {
-        beforeEach(async () => {
-            await transport.connect();
-            await transport.subscribe('test-queue', async () => { });
-        });
-        it('should send messages to dead letter queue', async () => {
-            const envelope = createTestEnvelope();
-            await transport.send('test-queue', envelope);
-            const received = await transport.receiveOne('test-queue');
-            if (!received)
-                throw new Error('expected received message');
-            await transport.sendToDeadLetter(received.receipt, 'dlq', envelope, 'test error');
-            expect(transport.getQueueSize('test-queue')).toBe(0);
-            expect(transport.getQueueSize('test-queue.dlq')).toBe(1);
-        });
-    });
-    describe('topology', () => {
-        it('should apply topology and create queues', async () => {
-            const topology = {
-                namespace: 'test',
-                queues: [{ name: 'events' }, { name: 'notifications' }],
-                deadLetter: {
-                    unhandled: { enabled: true },
-                    undeliverable: { enabled: true },
-                },
-                retry: {
-                    enabled: true,
-                    defaultDelayMs: 1000,
-                    maxDelayMs: 30000,
-                },
-            };
-            await transport.connect();
-            await transport.applyTopology(topology);
-            // Queues should be created
-            expect(transport.getQueueSize('test.events')).toBe(0);
-            expect(transport.getQueueSize('test.notifications')).toBe(0);
-        });
-    });
-    describe('clear', () => {
-        it('should reset all state', async () => {
-            await transport.connect();
-            await transport.subscribe('test-queue', async () => { });
-            await transport.send('test-queue', createTestEnvelope());
-            const received = await transport.receiveOne('test-queue');
-            if (!received)
-                throw new Error('expected received message');
-            await transport.complete(received.receipt);
-            transport.clear();
-            expect(transport.getQueueSize('test-queue')).toBe(0);
-            expect(transport.getCompleted()).toHaveLength(0);
-        });
-    });
-    describe('delayed messages', () => {
-        beforeEach(async () => {
-            await transport.connect();
-            await transport.subscribe('test-queue', async () => { });
-        });
-        it('should return immediately and delay message delivery', async () => {
-            const envelope = createTestEnvelope();
-            // Send returns immediately (non-blocking)
-            await transport.send('test-queue', envelope, {
-                delay: 100,
-            });
-            // Message should not be in queue immediately
-            expect(transport.getQueueSize('test-queue')).toBe(0);
-            // Wait for the delay to pass
-            await new Promise((resolve) => setTimeout(resolve, 150));
-            // Message should now be in queue
-            expect(transport.getQueueSize('test-queue')).toBe(1);
-        });
-        it('should cancel delayed messages on disconnect', async () => {
-            const envelope = createTestEnvelope();
-            await transport.send('test-queue', envelope, {
-                delay: 100,
-            });
-            // Disconnect before delay expires
-            await transport.disconnect();
-            // Wait past the original delay
-            await new Promise((resolve) => setTimeout(resolve, 150));
-            // Message should never have been delivered
-            expect(transport.getQueueSize('test-queue')).toBe(0);
-        });
-    });
-});
-function createTestEnvelope() {
-    return createEnvelope({
-        eventKey: 'test.event',
-        targetSubscriber: 'test-subscriber',
-        data: { test: 'data' },
-        importance: 'should-investigate',
-    });
-}

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

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

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

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

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

@@ -1,322 +0,0 @@
-import { beforeEach, describe, expect, it, mock } from 'bun:test';
-import { createEnvelope } from '../../types/index.js';
-import { LocalTransport } from '../local/local-transport.js';
-import { MultiTransport } from './multi-transport.js';
-describe('MultiTransport', () => {
-    let primary;
-    let secondary;
-    let transport;
-    beforeEach(() => {
-        primary = new LocalTransport();
-        secondary = new LocalTransport();
-        transport = new MultiTransport({
-            transports: [primary, secondary],
-        });
-    });
-    describe('constructor', () => {
-        it('should throw if no transports provided', () => {
-            expect(() => new MultiTransport({ transports: [] })).toThrow('At least one transport is required');
-        });
-        it('should set name based on transport names', () => {
-            expect(transport.name).toBe('multi(local,local)');
-        });
-        it('should use primary transport capabilities', () => {
-            expect(transport.capabilities).toBe(primary.capabilities);
-        });
-        it('should expose primary transport', () => {
-            expect(transport.primary).toBe(primary);
-        });
-        it('should expose all transports', () => {
-            expect(transport.transports).toEqual([primary, secondary]);
-        });
-        it('should default fallbackEnabled to true', () => {
-            expect(transport.fallbackEnabled).toBe(true);
-        });
-        it('should allow disabling fallback', () => {
-            const noFallback = new MultiTransport({
-                transports: [primary, secondary],
-                fallbackEnabled: false,
-            });
-            expect(noFallback.fallbackEnabled).toBe(false);
-        });
-    });
-    describe('connection', () => {
-        it('should start disconnected', () => {
-            expect(transport.isConnected()).toBe(false);
-        });
-        it('should connect all transports', async () => {
-            await transport.connect();
-            expect(transport.isConnected()).toBe(true);
-            expect(primary.isConnected()).toBe(true);
-            expect(secondary.isConnected()).toBe(true);
-        });
-        it('should disconnect all transports', async () => {
-            await transport.connect();
-            await transport.disconnect();
-            expect(transport.isConnected()).toBe(false);
-            expect(primary.isConnected()).toBe(false);
-            expect(secondary.isConnected()).toBe(false);
-        });
-    });
-    describe('topology', () => {
-        it('should apply topology to all transports', async () => {
-            const topology = {
-                namespace: 'test',
-                queues: [{ name: 'events' }],
-                deadLetter: {
-                    unhandled: { enabled: true },
-                    undeliverable: { enabled: true },
-                },
-                retry: {
-                    enabled: true,
-                    defaultDelayMs: 1000,
-                    maxDelayMs: 30000,
-                },
-            };
-            await transport.connect();
-            await transport.applyTopology(topology);
-            // Both transports should have the queue
-            expect(primary.getQueueSize('test.events')).toBe(0);
-            expect(secondary.getQueueSize('test.events')).toBe(0);
-        });
-    });
-    describe('send - primary success', () => {
-        beforeEach(async () => {
-            await transport.connect();
-            await transport.subscribe('test-queue', async () => { });
-        });
-        it('should send to primary transport when it succeeds', async () => {
-            const envelope = createTestEnvelope();
-            await transport.send('test-queue', envelope);
-            expect(primary.getQueueSize('test-queue')).toBe(1);
-            expect(secondary.getQueueSize('test-queue')).toBe(0);
-        });
-        it('should not call onEnqueueFallback when primary succeeds', async () => {
-            const onEnqueueFallback = mock(() => { });
-            const transportWithCallback = new MultiTransport({ transports: [primary, secondary] }, { onEnqueueFallback });
-            await transportWithCallback.connect();
-            const envelope = createTestEnvelope();
-            await transportWithCallback.send('test-queue', envelope);
-            expect(onEnqueueFallback).not.toHaveBeenCalled();
-        });
-    });
-    describe('send - fallback', () => {
-        beforeEach(async () => {
-            await transport.connect();
-            await transport.subscribe('test-queue', async () => { });
-        });
-        it('should fallback when primary fails', async () => {
-            // Make primary fail
-            await primary.disconnect();
-            const envelope = createTestEnvelope();
-            await transport.send('test-queue', envelope);
-            expect(secondary.getQueueSize('test-queue')).toBe(1);
-        });
-        it('should call onEnqueueFallback when fallback is used', async () => {
-            const fallbackContexts = [];
-            const transportWithCallback = new MultiTransport({ transports: [primary, secondary] }, { onEnqueueFallback: (ctx) => fallbackContexts.push(ctx) });
-            await transportWithCallback.connect();
-            // Make primary fail
-            await primary.disconnect();
-            const envelope = createTestEnvelope();
-            await transportWithCallback.send('test-queue', envelope);
-            expect(fallbackContexts).toHaveLength(1);
-            const ctx = fallbackContexts[0];
-            if (!ctx)
-                throw new Error('expected fallback context');
-            expect(ctx.failedTransport).toBe('local');
-            expect(ctx.nextTransport).toBe('local');
-            expect(ctx.queue).toBe('test-queue');
-            expect(ctx.envelope).toBe(envelope);
-            expect(ctx.error.message).toContain('is not connected');
-        });
-        it('should throw when all transports fail', async () => {
-            await primary.disconnect();
-            await secondary.disconnect();
-            const envelope = createTestEnvelope();
-            await expect(transport.send('test-queue', envelope)).rejects.toThrow('All transports failed');
-        });
-        it('should try transports in order', async () => {
-            const third = new LocalTransport();
-            const multiTransport = new MultiTransport({
-                transports: [primary, secondary, third],
-            });
-            await multiTransport.connect();
-            await third.subscribe('test-queue', async () => { });
-            // Make primary and secondary fail
-            await primary.disconnect();
-            await secondary.disconnect();
-            const envelope = createTestEnvelope();
-            await multiTransport.send('test-queue', envelope);
-            expect(third.getQueueSize('test-queue')).toBe(1);
-        });
-        it('should not fallback when fallbackEnabled is false', async () => {
-            const noFallback = new MultiTransport({
-                transports: [primary, secondary],
-                fallbackEnabled: false,
-            });
-            await noFallback.connect();
-            // Make primary fail
-            await primary.disconnect();
-            const envelope = createTestEnvelope();
-            await expect(noFallback.send('test-queue', envelope)).rejects.toThrow('is not connected');
-            // Secondary should not have received the message
-            expect(secondary.getQueueSize('test-queue')).toBe(0);
-        });
-        it('should send to primary when fallbackEnabled is false and primary succeeds', async () => {
-            const noFallback = new MultiTransport({
-                transports: [primary, secondary],
-                fallbackEnabled: false,
-            });
-            await noFallback.connect();
-            const envelope = createTestEnvelope();
-            await noFallback.send('test-queue', envelope);
-            expect(primary.getQueueSize('test-queue')).toBe(1);
-            expect(secondary.getQueueSize('test-queue')).toBe(0);
-        });
-    });
-    describe('subscribe', () => {
-        beforeEach(async () => {
-            await transport.connect();
-        });
-        it('should receive messages from primary transport', async () => {
-            const receivedMessages = [];
-            await transport.subscribe('test-queue', async (envelope) => {
-                receivedMessages.push(envelope);
-            });
-            // Send directly to primary (simulating normal operation)
-            await primary.send('test-queue', createTestEnvelope());
-            expect(receivedMessages).toHaveLength(1);
-        });
-        it('should receive messages that fell back to secondary transport', async () => {
-            const receivedMessages = [];
-            // Subscribe through MultiTransport
-            await transport.subscribe('test-queue', async (envelope) => {
-                receivedMessages.push(envelope);
-            });
-            // Make primary fail for sends
-            await primary.disconnect();
-            // Send through MultiTransport - should fall back to secondary
-            const envelope = createTestEnvelope();
-            await transport.send('test-queue', envelope);
-            // Message went to secondary transport, subscriber should still receive it
-            expect(receivedMessages).toHaveLength(1);
-            expect(receivedMessages[0].id).toBe(envelope.id);
-        });
-        it('should leave sub-transports subscribed when pauseForShutdown is a no-op', async () => {
-            const receivedMessages = [];
-            const subscription = await transport.subscribe('test-queue', async (envelope) => {
-                receivedMessages.push(envelope);
-            });
-            // Both primary and secondary here are LocalTransport, whose
-            // pauseForShutdown is a no-op — pausing the aggregate must leave both
-            // underlying subscriptions untouched.
-            await subscription.pauseForShutdown?.();
-            await primary.send('test-queue', createTestEnvelope());
-            expect(receivedMessages).toHaveLength(1);
-        });
-        it('should call pauseForShutdown on sub-transports that implement it', async () => {
-            const externalPauseForShutdown = mock(async () => { });
-            const externalMock = {
-                name: 'rabbitmq',
-                capabilities: {
-                    deliveryModes: ['at-least-once'],
-                    delayedMessages: false,
-                    deadLetterRouting: 'native',
-                    attemptTracking: true,
-                    concurrencyModel: 'prefetch',
-                    ordering: 'none',
-                    priorities: false,
-                },
-                isConnected: () => true,
-                connect: mock(async () => { }),
-                disconnect: mock(async () => { }),
-                send: mock(async () => 'rabbitmq'),
-                subscribe: mock(async () => ({
-                    unsubscribe: mock(async () => { }),
-                    pauseForShutdown: externalPauseForShutdown,
-                    isActive: true,
-                })),
-                applyTopology: mock(async () => { }),
-                complete: mock(async () => { }),
-            };
-            const multiWithExternal = new MultiTransport({
-                transports: [externalMock, primary],
-            });
-            await multiWithExternal.connect();
-            const subscription = await multiWithExternal.subscribe('test-queue', async () => { });
-            await subscription.pauseForShutdown?.();
-            expect(externalPauseForShutdown).toHaveBeenCalledTimes(1);
-        });
-        it('should fall back to unsubscribe for sub-transports without pauseForShutdown', async () => {
-            const externalUnsubscribe = mock(async () => { });
-            const externalMock = {
-                name: 'rabbitmq',
-                capabilities: {
-                    deliveryModes: ['at-least-once'],
-                    delayedMessages: false,
-                    deadLetterRouting: 'native',
-                    attemptTracking: true,
-                    concurrencyModel: 'prefetch',
-                    ordering: 'none',
-                    priorities: false,
-                },
-                isConnected: () => true,
-                connect: mock(async () => { }),
-                disconnect: mock(async () => { }),
-                send: mock(async () => 'rabbitmq'),
-                subscribe: mock(async () => ({
-                    unsubscribe: externalUnsubscribe,
-                    isActive: true,
-                })),
-                applyTopology: mock(async () => { }),
-                complete: mock(async () => { }),
-            };
-            const multiWithExternal = new MultiTransport({
-                transports: [externalMock, primary],
-            });
-            await multiWithExternal.connect();
-            const subscription = await multiWithExternal.subscribe('test-queue', async () => { });
-            await subscription.pauseForShutdown?.();
-            expect(externalUnsubscribe).toHaveBeenCalledTimes(1);
-        });
-    });
-    describe('complete', () => {
-        beforeEach(async () => {
-            await transport.connect();
-            await primary.subscribe('test-queue', async () => { });
-        });
-        it('should complete using primary transport', async () => {
-            await primary.send('test-queue', createTestEnvelope());
-            const received = await primary.receiveOne('test-queue');
-            if (!received)
-                throw new Error('expected received message');
-            await transport.complete(received.receipt);
-            expect(primary.getCompleted()).toHaveLength(1);
-        });
-    });
-    describe('sendToDeadLetter', () => {
-        beforeEach(async () => {
-            await transport.connect();
-            await primary.subscribe('test-queue', async () => { });
-        });
-        it('should send to dead letter using primary transport', async () => {
-            const envelope = createTestEnvelope();
-            await primary.send('test-queue', envelope);
-            const received = await primary.receiveOne('test-queue');
-            if (!received)
-                throw new Error('expected received message');
-            await transport.sendToDeadLetter(received.receipt, 'dlq', envelope, 'test error');
-            expect(primary.getQueueSize('test-queue')).toBe(0);
-            expect(primary.getQueueSize('test-queue.dlq')).toBe(1);
-        });
-    });
-});
-function createTestEnvelope() {
-    return createEnvelope({
-        eventKey: 'test.event',
-        targetSubscriber: 'test-subscriber',
-        data: { test: 'data' },
-        importance: 'should-investigate',
-    });
-}

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

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

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

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