@zdavison/matador 2.0.8 → 2.0.9

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

@@ -1,192 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test';
-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();
-        });
-        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 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');
-            expect(received).not.toBeNull();
-            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();
-        });
-    });
-    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 deliver pending messages when subscribing', async () => {
-            const envelope = createTestEnvelope();
-            await transport.send('test-queue', envelope);
-            const receivedMessages = [];
-            await transport.subscribe('test-queue', async (env) => {
-                receivedMessages.push(env);
-            });
-            expect(receivedMessages).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();
-        });
-        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');
-            expect(received).not.toBeNull();
-            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.send('test-queue', createTestEnvelope());
-            const received = await transport.receiveOne('test-queue');
-            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();
-        });
-        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.d.ts

@@ -1,94 +0,0 @@
-import type { TransportFallbackContext } 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';
-/**
- * Configuration for MultiTransport.
- */
-export interface MultiTransportConfig {
-    /**
-     * Ordered list of transports.
-     * First transport is primary, rest are used as fallbacks when primary fails
-     * (if fallback is enabled), or can be explicitly selected via the getDesiredBackend hook.
-     */
-    readonly transports: readonly Transport[];
-    /**
-     * Whether to automatically try fallback transports when the primary/selected fails.
-     * When true (default), send() will try each transport in order until one succeeds.
-     * When false, send() will only use the selected transport and throw immediately on failure.
-     *
-     * @default true
-     */
-    readonly fallbackEnabled?: boolean;
-}
-/**
- * Hooks for MultiTransport.
- */
-export interface MultiTransportHooks {
-    /**
-     * Hook to dynamically select which backend to use.
-     * Return the transport name (e.g., 'local', 'rabbitmq') or undefined to use primary.
-     *
-     * @example
-     * ```typescript
-     * getDesiredBackend: async () => {
-     *   if (process.env.SANDBOX === 'true') return 'local';
-     *   const backend = await runtimeConfig.get('events.backend');
-     *   return backend || 'rabbitmq';
-     * }
-     * ```
-     */
-    readonly getDesiredBackend?: () => string | undefined | Promise<string | undefined>;
-    /**
-     * Called when a fallback transport is used successfully after the selected one fails.
-     * Only called when fallbackEnabled is true.
-     */
-    readonly onEnqueueFallback?: (context: TransportFallbackContext) => void;
-}
-/**
- * A transport wrapper that manages multiple transports.
- *
- * Features:
- * - All transports are connected upfront
- * - send() tries transports in order until one succeeds (fallback behavior)
- * - Specific transport can be selected via getDesiredBackend hook
- * - Subscriptions are created on ALL transports
- *
- * @example
- * ```typescript
- * const transport = new MultiTransport(
- *   { transports: [rabbitMQTransport, localTransport] },
- *   { onEnqueueFallback: (ctx) => console.warn(`Fallback to ${ctx.nextTransport}`) },
- * );
- * ```
- */
-export declare class MultiTransport implements Transport {
-    readonly name: string;
-    readonly capabilities: TransportCapabilities;
-    readonly primary: Transport;
-    /** All available transports, in order of preference (primary first). */
-    readonly transports: readonly Transport[];
-    /** Whether fallback to secondary transports is enabled. */
-    readonly fallbackEnabled: boolean;
-    private readonly hooks;
-    private connected;
-    constructor(config: MultiTransportConfig, hooks?: MultiTransportHooks);
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    applyTopology(topology: Topology): Promise<void>;
-    send(queue: string, envelope: Envelope, options?: SendOptions): Promise<Transport['name']>;
-    /**
-     * Selects the transport to use based on the getDesiredBackend hook.
-     */
-    private selectTransport;
-    /**
-     * Returns transports in order, with the selected transport first.
-     */
-    private getTransportOrder;
-    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>;
-}
-//# sourceMappingURL=multi-transport.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"multi-transport.d.ts","sourceRoot":"","sources":["../../../src/transport/multi/multi-transport.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AACrE,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;AAgBzB;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAE1C;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MACzB,MAAM,GACN,SAAS,GACT,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAEhC;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,wBAAwB,KAAK,IAAI,CAAC;CAC1E;AAmBD;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAe,YAAW,SAAS;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,qBAAqB,CAAC;IAC7C,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAE5B,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAE1C,2DAA2D;IAC3D,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAElC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsB;IAC5C,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,oBAAoB,EAAE,KAAK,GAAE,mBAAwB;IAcnE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAMxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAMjC,WAAW,IAAI,OAAO;IAKhB,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAKhD,IAAI,CACR,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAyC7B;;OAEG;YACW,eAAe;IAwB7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IASnB,SAAS,CACb,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,YAAY,CAAC;IA0BlB,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAKhD,gBAAgB,CACpB,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;CAOjB"}

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

@@ -1,184 +0,0 @@
-import { AllTransportsFailedError } from '../../errors/index.js';
-/**
- * Symbol key used to store the source transport on wrapped receipts.
- */
-const SOURCE_TRANSPORT = Symbol('sourceTransport');
-/**
- * Extracts the source transport from a tagged receipt.
- */
-function getSourceTransport(receipt) {
-    return receipt[SOURCE_TRANSPORT];
-}
-/**
- * Computes merged capabilities from multiple transports.
- * Uses the most restrictive/conservative interpretation.
- */
-function mergeCapabilities(transports) {
-    const primary = transports[0];
-    if (!primary) {
-        throw new Error('At least one transport is required');
-    }
-    // For multi-transport scenarios, we use primary's capabilities since that's
-    // what we'll use for subscriptions and most operations
-    return primary.capabilities;
-}
-/**
- * A transport wrapper that manages multiple transports.
- *
- * Features:
- * - All transports are connected upfront
- * - send() tries transports in order until one succeeds (fallback behavior)
- * - Specific transport can be selected via getDesiredBackend hook
- * - Subscriptions are created on ALL transports
- *
- * @example
- * ```typescript
- * const transport = new MultiTransport(
- *   { transports: [rabbitMQTransport, localTransport] },
- *   { onEnqueueFallback: (ctx) => console.warn(`Fallback to ${ctx.nextTransport}`) },
- * );
- * ```
- */
-export class MultiTransport {
-    name;
-    capabilities;
-    primary;
-    /** All available transports, in order of preference (primary first). */
-    transports;
-    /** Whether fallback to secondary transports is enabled. */
-    fallbackEnabled;
-    hooks;
-    connected = false;
-    constructor(config, hooks = {}) {
-        const primary = config.transports[0];
-        if (!primary) {
-            throw new Error('At least one transport is required');
-        }
-        this.primary = primary;
-        this.transports = config.transports;
-        this.fallbackEnabled = config.fallbackEnabled ?? true;
-        this.hooks = hooks;
-        this.name = `multi(${this.transports.map((t) => t.name).join(',')})`;
-        this.capabilities = mergeCapabilities(this.transports);
-    }
-    async connect() {
-        // Connect all transports in parallel
-        await Promise.all(this.transports.map((t) => t.connect()));
-        this.connected = true;
-    }
-    async disconnect() {
-        // Disconnect all transports in parallel
-        await Promise.all(this.transports.map((t) => t.disconnect()));
-        this.connected = false;
-    }
-    isConnected() {
-        // Consider connected if primary is connected
-        return this.connected && this.primary.isConnected();
-    }
-    async applyTopology(topology) {
-        // Apply topology to all transports so they're all ready
-        await Promise.all(this.transports.map((t) => t.applyTopology(topology)));
-    }
-    async send(queue, envelope, options) {
-        // Determine which transport to use
-        const selectedTransport = await this.selectTransport();
-        // If fallback is disabled, only use selected transport
-        if (!this.fallbackEnabled) {
-            return selectedTransport.send(queue, envelope, options);
-        }
-        // Build transport order: selected first, then others
-        const transportOrder = this.getTransportOrder(selectedTransport);
-        const errors = [];
-        for (let i = 0; i < transportOrder.length; i++) {
-            const transport = transportOrder[i];
-            try {
-                return await transport.send(queue, envelope, options);
-            }
-            catch (error) {
-                const err = error instanceof Error ? error : new Error(String(error));
-                errors.push(err);
-                // Notify about fallback before trying next transport
-                const nextTransport = transportOrder[i + 1];
-                if (nextTransport && this.hooks.onEnqueueFallback) {
-                    this.hooks.onEnqueueFallback({
-                        envelope,
-                        queue,
-                        failedTransport: transport.name,
-                        nextTransport: nextTransport.name,
-                        error: err,
-                    });
-                }
-                // Continue to next transport
-            }
-        }
-        // All transports failed
-        throw new AllTransportsFailedError(queue, errors);
-    }
-    /**
-     * Selects the transport to use based on the getDesiredBackend hook.
-     */
-    async selectTransport() {
-        if (!this.hooks.getDesiredBackend) {
-            return this.primary;
-        }
-        try {
-            const desiredBackend = await this.hooks.getDesiredBackend();
-            if (!desiredBackend) {
-                return this.primary;
-            }
-            const selected = this.transports.find((t) => t.name === desiredBackend);
-            if (selected) {
-                return selected;
-            }
-            // Desired backend not found, use primary
-            return this.primary;
-        }
-        catch {
-            // Hook threw, use primary
-            return this.primary;
-        }
-    }
-    /**
-     * Returns transports in order, with the selected transport first.
-     */
-    getTransportOrder(selected) {
-        if (selected === this.primary) {
-            return this.transports;
-        }
-        // Put selected first, then the rest (excluding selected)
-        return [selected, ...this.transports.filter((t) => t !== selected)];
-    }
-    async subscribe(queue, handler, options) {
-        // Subscribe on ALL transports so messages are processed regardless of
-        // which transport they were enqueued to
-        const subscriptions = await Promise.all(this.transports.map((transport) => {
-            // Wrap handler to tag receipts with source transport
-            const wrappedHandler = (envelope, receipt) => {
-                const taggedReceipt = Object.assign(receipt, {
-                    [SOURCE_TRANSPORT]: transport,
-                });
-                return handler(envelope, taggedReceipt);
-            };
-            return transport.subscribe(queue, wrappedHandler, options);
-        }));
-        return {
-            unsubscribe: async () => {
-                await Promise.all(subscriptions.map((s) => s.unsubscribe()));
-            },
-            get isActive() {
-                return subscriptions.some((s) => s.isActive);
-            },
-        };
-    }
-    async complete(receipt) {
-        const transport = getSourceTransport(receipt) ?? this.primary;
-        return transport.complete(receipt);
-    }
-    async sendToDeadLetter(receipt, dlqName, envelope, reason) {
-        const transport = getSourceTransport(receipt) ?? this.primary;
-        if (transport.sendToDeadLetter) {
-            return transport.sendToDeadLetter(receipt, dlqName, envelope, reason);
-        }
-        throw new Error('Transport does not support dead letter routing');
-    }
-}

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":""}