@zdavison/matador 2.0.1

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

@@ -0,0 +1,518 @@
+import amqplib from 'amqplib';
+import { RabbitMQCodec } from '../../codec/rabbitmq-codec.js';
+import { DelayedMessagesNotSupportedError, TransportNotConnectedError, } from '../../errors/index.js';
+import { consoleLogger } from '../../hooks/index.js';
+import { ConnectionManager, } from '../connection-manager.js';
+/**
+ * RabbitMQ transport implementation using amqplib.
+ */
+export class RabbitMQTransport {
+    name = 'rabbitmq';
+    _capabilities = {
+        deliveryModes: ['at-least-once'],
+        delayedMessages: false,
+        deadLetterRouting: 'native',
+        attemptTracking: true,
+        concurrencyModel: 'prefetch',
+        ordering: 'none',
+        priorities: true,
+    };
+    get capabilities() {
+        return this._capabilities;
+    }
+    connection = null;
+    publishChannel = null;
+    connectionManager;
+    queueChannels = new Map();
+    topology = null;
+    codec = new RabbitMQCodec();
+    config;
+    logger;
+    delayedExchangeAvailable = false;
+    constructor(config) {
+        this.logger = config.logger ?? consoleLogger;
+        this.config = {
+            url: config.url,
+            connection: config.connection ?? {},
+            quorumQueues: config.quorumQueues ?? true,
+            defaultPrefetch: config.defaultPrefetch ?? 10,
+            enableDelayedMessages: config.enableDelayedMessages ?? true,
+        };
+        this.connectionManager = new ConnectionManager(() => this.doConnect(), () => this.doDisconnect(), this.config.connection);
+    }
+    async connect() {
+        await this.connectionManager.connect();
+    }
+    async disconnect() {
+        await this.connectionManager.disconnect();
+    }
+    isConnected() {
+        return this.connectionManager.isConnected();
+    }
+    async applyTopology(topology) {
+        this.topology = topology;
+        if (!this.publishChannel) {
+            throw new TransportNotConnectedError(this.name, 'applyTopology');
+        }
+        const channel = this.publishChannel;
+        // Create the main exchange for routing messages to queues
+        const mainExchange = this.getMainExchangeName(topology.namespace);
+        await channel.assertExchange(mainExchange, 'direct', { durable: true });
+        // Create dead-letter exchange if DLQ is enabled
+        const dlxExchange = this.getDLXExchangeName(topology.namespace);
+        if (topology.deadLetter.unhandled.enabled ||
+            topology.deadLetter.undeliverable.enabled) {
+            await channel.assertExchange(dlxExchange, 'direct', { durable: true });
+        }
+        // Check for delayed message exchange plugin
+        if (this.config.enableDelayedMessages) {
+            await this.setupDelayedExchange(topology.namespace);
+        }
+        // Create work queues
+        for (const queueDef of topology.queues) {
+            await this.assertWorkQueue(channel, topology, queueDef);
+        }
+        // Create DLQs
+        if (topology.deadLetter.unhandled.enabled) {
+            await this.assertDeadLetterQueues(channel, topology, 'unhandled');
+        }
+        if (topology.deadLetter.undeliverable.enabled) {
+            await this.assertDeadLetterQueues(channel, topology, 'undeliverable');
+        }
+    }
+    async send(queue, envelope, options) {
+        if (!this.publishChannel || !this.topology) {
+            throw new TransportNotConnectedError(this.name, 'send');
+        }
+        const encoded = this.codec.encode(envelope);
+        const buffer = Buffer.from(encoded.body);
+        const publishOptions = {
+            persistent: true,
+            contentType: encoded.contentType,
+            messageId: envelope.id,
+            timestamp: Date.now(),
+            headers: encoded.headers,
+        };
+        if (options?.priority !== undefined) {
+            publishOptions.priority = options.priority;
+        }
+        // Handle delayed messages
+        if (options?.delay !== undefined && options.delay > 0) {
+            if (!this.delayedExchangeAvailable) {
+                throw new DelayedMessagesNotSupportedError(this.name);
+            }
+            const delayedExchange = this.getDelayedExchangeName(this.topology.namespace);
+            publishOptions.headers = {
+                ...publishOptions.headers,
+                'x-delay': options.delay,
+            };
+            this.publishChannel.publish(delayedExchange, queue, buffer, publishOptions);
+            return this.name;
+        }
+        // Transport-specific options
+        if (options?.transport?.rabbitmq?.expiration !== undefined) {
+            publishOptions.expiration = String(options.transport.rabbitmq.expiration);
+        }
+        if (options?.transport?.rabbitmq?.persistent !== undefined) {
+            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);
+        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 queueChannel = await this.getOrCreateQueueChannel(queue, options);
+        const { channel } = queueChannel;
+        const consumer = {
+            consumerTag: '',
+            queue,
+            active: true,
+        };
+        const { consumerTag } = await channel.consume(queue, async (msg) => {
+            if (!msg || !consumer.active)
+                return;
+            const attemptNumber = this.getAttemptNumber(msg);
+            const receipt = {
+                handle: { channel, msg },
+                redelivered: msg.fields.redelivered,
+                attemptNumber,
+                deliveryCount: this.getDeliveryCount(msg, attemptNumber),
+                sourceQueue: queue,
+                sourceTransport: this.name,
+            };
+            try {
+                const headers = (msg.properties.headers ?? {});
+                const envelope = this.codec.decode(new Uint8Array(msg.content), headers);
+                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;
+            },
+        };
+    }
+    async complete(receipt) {
+        const { channel, msg } = receipt.handle;
+        try {
+            channel.ack(msg);
+        }
+        catch {
+            // Channel may be closed, ignore
+        }
+    }
+    async sendToDeadLetter(receipt, dlqName, envelope, reason) {
+        if (!this.publishChannel || !this.topology) {
+            throw new TransportNotConnectedError(this.name, 'sendToDeadLetter');
+        }
+        // Add error info to envelope
+        const dlqEnvelope = {
+            ...envelope,
+            docket: {
+                ...envelope.docket,
+                lastError: reason,
+                firstError: envelope.docket.firstError ?? reason,
+                originalQueue: receipt.sourceQueue,
+            },
+        };
+        const encoded = this.codec.encode(dlqEnvelope);
+        const buffer = Buffer.from(encoded.body);
+        const dlxExchange = this.getDLXExchangeName(this.topology.namespace);
+        const dlqQueueName = `${receipt.sourceQueue}.${dlqName}`;
+        const publishOptions = {
+            persistent: true,
+            contentType: encoded.contentType,
+            messageId: envelope.id,
+            timestamp: Date.now(),
+            headers: {
+                ...encoded.headers,
+                'x-matador-dead-letter-reason': reason,
+            },
+        };
+        this.publishChannel.publish(dlxExchange, dlqQueueName, buffer, publishOptions);
+        // Complete the original message
+        await this.complete(receipt);
+    }
+    // Private methods
+    /**
+     * Gets or creates a dedicated channel for a queue subscription.
+     *
+     * We create separate channels per subscribed queue to enable independent
+     * prefetch/concurrency control.
+     */
+    async getOrCreateQueueChannel(queue, options) {
+        const existing = this.queueChannels.get(queue);
+        if (existing) {
+            return existing;
+        }
+        if (!this.connection) {
+            throw new TransportNotConnectedError(this.name, 'getOrCreateQueueChannel');
+        }
+        // Create a dedicated channel for this queue to control prefetch independently
+        const channel = await this.connection.createChannel();
+        const prefetch = options.transport?.rabbitmq?.prefetch ??
+            options.concurrency ??
+            this.config.defaultPrefetch ??
+            10;
+        await channel.prefetch(prefetch);
+        const queueChannel = {
+            channel,
+            consumers: [],
+        };
+        this.queueChannels.set(queue, queueChannel);
+        return queueChannel;
+    }
+    async doConnect() {
+        const connection = await amqplib.connect(this.config.url);
+        this.connection = connection;
+        // Handle connection errors - let ConnectionManager handle reconnection
+        connection.on('error', (err) => {
+            this.logger.error('[Matador] 🔴 RabbitMQ connection error', err);
+        });
+        connection.on('close', () => {
+            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();
+        // Handle publish channel errors to prevent unhandled error events
+        this.publishChannel.on('error', (err) => {
+            this.logger.error('[Matador] 🔴 RabbitMQ publish channel error', err);
+        });
+        // Re-apply topology if we have one (reconnection scenario)
+        if (this.topology) {
+            await this.applyTopology(this.topology);
+        }
+    }
+    async doDisconnect() {
+        // Cancel all consumers and close queue channels
+        for (const queueChannel of this.queueChannels.values()) {
+            for (const consumer of queueChannel.consumers) {
+                consumer.active = false;
+                try {
+                    await queueChannel.channel.cancel(consumer.consumerTag);
+                }
+                catch {
+                    // Ignore errors during cleanup
+                }
+            }
+            try {
+                await queueChannel.channel.close();
+            }
+            catch {
+                // Ignore
+            }
+        }
+        this.queueChannels.clear();
+        // Close publish channel
+        if (this.publishChannel) {
+            try {
+                await this.publishChannel.close();
+            }
+            catch {
+                // Ignore
+            }
+            this.publishChannel = null;
+        }
+        // Close connection
+        if (this.connection) {
+            try {
+                await this.connection.close();
+            }
+            catch {
+                // Ignore
+            }
+            this.connection = null;
+        }
+        // Reset capabilities
+        this.delayedExchangeAvailable = false;
+        this._capabilities = {
+            ...this._capabilities,
+            delayedMessages: false,
+        };
+    }
+    async setupDelayedExchange(namespace) {
+        if (!this.connection) {
+            return;
+        }
+        // Default to disabled
+        this.delayedExchangeAvailable = false;
+        const delayedExchange = this.getDelayedExchangeName(namespace);
+        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
+        return new Promise((resolve) => {
+            let resolved = false;
+            const safeResolve = () => {
+                if (!resolved) {
+                    resolved = true;
+                    resolve();
+                }
+            };
+            connection
+                .createChannel()
+                .then((probeChannel) => {
+                // Handle channel errors - this fires when RabbitMQ closes the channel
+                probeChannel.on('error', () => {
+                    safeResolve();
+                });
+                // Handle channel close
+                probeChannel.on('close', () => {
+                    safeResolve();
+                });
+                // Try to declare a delayed exchange
+                // This will fail if the plugin is not installed
+                probeChannel
+                    .assertExchange(delayedExchange, 'x-delayed-message', {
+                    durable: true,
+                    arguments: { 'x-delayed-type': 'direct' },
+                })
+                    .then(() => {
+                    this.delayedExchangeAvailable = true;
+                    this._capabilities = {
+                        ...this._capabilities,
+                        delayedMessages: true,
+                    };
+                    this.logger.debug('[Matador] 🔌 Delayed message exchange plugin detected');
+                    // Close the probe channel gracefully
+                    probeChannel.close().catch(() => { });
+                    safeResolve();
+                })
+                    .catch(() => {
+                    // assertExchange failed - plugin not available
+                    // Channel is already closed by RabbitMQ, no need to close
+                    this.logger.warn('[Matador] 🟡 RabbitMQ delayed message exchange plugin not available. ' +
+                        'Delayed messages will not be supported.');
+                    safeResolve();
+                });
+            })
+                .catch(() => {
+                // Failed to create channel - shouldn't happen but handle it
+                safeResolve();
+            });
+        });
+    }
+    async assertWorkQueue(channel, topology, queueDef) {
+        const queueName = queueDef.exact
+            ? queueDef.name
+            : `${topology.namespace}.${queueDef.name}`;
+        const queueOptions = {
+            durable: true,
+            arguments: {},
+        };
+        // Use quorum queues for durability
+        if (this.config.quorumQueues && !queueDef.exact) {
+            queueOptions.arguments['x-queue-type'] = 'quorum';
+        }
+        // Set up dead-letter exchange routing
+        const dlxExchange = this.getDLXExchangeName(topology.namespace);
+        if (topology.deadLetter.unhandled.enabled ||
+            topology.deadLetter.undeliverable.enabled) {
+            queueOptions.arguments['x-dead-letter-exchange'] = dlxExchange;
+        }
+        // Enable priority if requested
+        if (queueDef.priorities) {
+            queueOptions.arguments['x-max-priority'] = 10;
+        }
+        // Set consumer timeout if specified
+        if (queueDef.consumerTimeout) {
+            queueOptions.arguments['x-consumer-timeout'] = queueDef.consumerTimeout;
+        }
+        await channel.assertQueue(queueName, queueOptions);
+        // Bind queue to main exchange
+        const mainExchange = this.getMainExchangeName(topology.namespace);
+        await channel.bindQueue(queueName, mainExchange, queueName);
+        // Bind to delayed exchange if available
+        if (this.delayedExchangeAvailable) {
+            const delayedExchange = this.getDelayedExchangeName(topology.namespace);
+            await channel.bindQueue(queueName, delayedExchange, queueName);
+        }
+        // Create retry queue if retry is enabled
+        if (topology.retry.enabled) {
+            await this.assertRetryQueue(channel, topology, queueName);
+        }
+    }
+    async assertRetryQueue(channel, topology, workQueueName) {
+        const retryQueueName = `${workQueueName}.retry`;
+        const mainExchange = this.getMainExchangeName(topology.namespace);
+        const retryQueueOptions = {
+            durable: true,
+            arguments: {
+                'x-dead-letter-exchange': mainExchange,
+                'x-dead-letter-routing-key': workQueueName,
+                'x-message-ttl': topology.retry.defaultDelayMs,
+            },
+        };
+        if (this.config.quorumQueues) {
+            retryQueueOptions.arguments['x-queue-type'] = 'quorum';
+        }
+        await channel.assertQueue(retryQueueName, retryQueueOptions);
+        await channel.bindQueue(retryQueueName, mainExchange, retryQueueName);
+    }
+    async assertDeadLetterQueues(channel, topology, dlqType) {
+        const dlxExchange = this.getDLXExchangeName(topology.namespace);
+        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 dlqOptions = {
+                durable: true,
+                arguments: {},
+            };
+            if (dlConfig.maxLength) {
+                dlqOptions.arguments['x-max-length'] = dlConfig.maxLength;
+            }
+            // DLQs use classic queues (not quorum) for simplicity
+            await channel.assertQueue(dlqName, dlqOptions);
+            await channel.bindQueue(dlqName, dlxExchange, dlqName);
+        }
+    }
+    getMainExchangeName(namespace) {
+        return `${namespace}.exchange`;
+    }
+    getDLXExchangeName(namespace) {
+        return `${namespace}.dlx`;
+    }
+    getDelayedExchangeName(namespace) {
+        return `${namespace}.delayed`;
+    }
+    getAttemptNumber(msg) {
+        const headerValue = msg.properties.headers?.['x-matador-attempts'];
+        if (typeof headerValue === 'number') {
+            return headerValue;
+        }
+        // Check for x-death header (native DLX redelivery count)
+        const xDeath = msg.properties.headers?.['x-death'];
+        if (Array.isArray(xDeath) && xDeath.length > 0) {
+            const deathCount = xDeath.reduce((sum, death) => sum + (death.count ?? 0), 0);
+            return deathCount + 1;
+        }
+        return 1;
+    }
+    /**
+     * Gets the native delivery count for poison message detection.
+     * This tracks how many times the message was delivered without acknowledgment,
+     * which helps detect crash loops.
+     */
+    getDeliveryCount(msg, attemptNumber) {
+        // Check for explicit delivery count header (some RabbitMQ setups track this)
+        const deliveryCount = msg.properties.headers?.['x-delivery-count'];
+        if (typeof deliveryCount === 'number') {
+            return deliveryCount;
+        }
+        // Check x-death header for dead-letter redelivery count
+        const xDeath = msg.properties.headers?.['x-death'];
+        if (Array.isArray(xDeath) && xDeath.length > 0) {
+            const deathCount = xDeath.reduce((sum, death) => sum + (death.count ?? 0), 0);
+            // Add 1 because we're currently being delivered again
+            return deathCount + 1;
+        }
+        // If redelivered flag is set but no other tracking, count as 2 (first + this delivery)
+        if (msg.fields.redelivered) {
+            return Math.max(2, attemptNumber);
+        }
+        // Default to attempt number
+        return attemptNumber;
+    }
+}

package/dist/transport/transport.d.ts

@@ -0,0 +1,152 @@
+import type { Topology } from '../topology/types.js';
+import type { Envelope } from '../types/index.js';
+import type { TransportCapabilities } from './capabilities.js';
+/**
+ * Transport-specific send options.
+ * Each transport can define its own options under its transport name key.
+ */
+export interface TransportSendOptions {
+    /** RabbitMQ-specific send options */
+    readonly rabbitmq?: RabbitMQSendOptions | undefined;
+}
+/**
+ * RabbitMQ-specific options for sending messages.
+ */
+export interface RabbitMQSendOptions {
+    /** Message expiration in milliseconds */
+    readonly expiration?: number | undefined;
+    /** Message persistence mode */
+    readonly persistent?: boolean | undefined;
+    /** Routing key override */
+    readonly routingKey?: string | undefined;
+}
+/**
+ * Options for sending a message.
+ */
+export interface SendOptions {
+    /** Delay delivery by this many milliseconds */
+    readonly delay?: number | undefined;
+    /** Priority level (0-255, higher = more important) */
+    readonly priority?: number | undefined;
+    /** Transport-specific options */
+    readonly transport?: TransportSendOptions | undefined;
+}
+/**
+ * Transport-specific subscribe options.
+ * Each transport can define its own options under its transport name key.
+ */
+export interface TransportSubscribeOptions {
+    /** RabbitMQ-specific subscribe options */
+    readonly rabbitmq?: RabbitMQSubscribeOptions | undefined;
+}
+/**
+ * RabbitMQ-specific options for subscribing.
+ */
+export interface RabbitMQSubscribeOptions {
+    /** Consumer tag */
+    readonly consumerTag?: string | undefined;
+    /** Prefetch count (overrides concurrency option) */
+    readonly prefetch?: number | undefined;
+    /** Exclusive consumer */
+    readonly exclusive?: boolean | undefined;
+}
+/**
+ * Options for subscribing to a queue.
+ */
+export interface SubscribeOptions {
+    /** Concurrency hint (number of concurrent handlers) */
+    readonly concurrency?: number | undefined;
+    /** Override default delivery semantics */
+    readonly deliveryMode?: 'at-least-once' | 'at-most-once' | undefined;
+    /** Transport-specific options */
+    readonly transport?: TransportSubscribeOptions | undefined;
+}
+/**
+ * Receipt for a received message, used for acknowledgment.
+ */
+export interface MessageReceipt {
+    /** Opaque handle for the transport to identify the message */
+    readonly handle: unknown;
+    /** True if this is a redelivery (transport-reported if capable) */
+    readonly redelivered: boolean;
+    /** 1-based attempt number (transport-reported if capable, else from envelope) */
+    readonly attemptNumber: number;
+    /**
+     * Native delivery count from the transport.
+     * Tracks how many times this specific message was delivered without acknowledgment.
+     * Used for poison message detection to prevent crash loops.
+     * For transports that don't track this, defaults to attemptNumber.
+     */
+    readonly deliveryCount: number;
+    /** Original queue/topic the message came from */
+    readonly sourceQueue: string;
+    /**
+     * The name of the transport that received this message (e.g., 'local', 'rabbitmq').
+     * For MultiTransport, this is the actual underlying transport, not the wrapper name.
+     */
+    readonly sourceTransport: string;
+}
+/**
+ * Handler function for processing received messages.
+ */
+export type MessageHandler = (envelope: Envelope, receipt: MessageReceipt) => Promise<void>;
+/**
+ * Subscription handle for managing active subscriptions.
+ */
+export interface Subscription {
+    /** Cancels the subscription */
+    unsubscribe(): Promise<void>;
+    /** Whether the subscription is currently active */
+    readonly isActive: boolean;
+}
+/**
+ * Transport interface - the minimal abstraction for message delivery.
+ * Transports handle only I/O; all business logic lives in Matador core.
+ */
+export interface Transport {
+    /** Transport identifier */
+    readonly name: string;
+    /** Capabilities supported by this transport */
+    readonly capabilities: TransportCapabilities;
+    /**
+     * Establishes connection to the message broker.
+     * Should handle initial connection with retries.
+     */
+    connect(): Promise<void>;
+    /**
+     * Gracefully disconnects from the message broker.
+     * Should close all consumers before connection.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Returns whether the transport is currently connected.
+     */
+    isConnected(): boolean;
+    /**
+     * Translates and applies the generic topology to the transport.
+     * Creates necessary queues, exchanges, topics, etc.
+     */
+    applyTopology(topology: Topology): Promise<void>;
+    /**
+     * Sends a message to the specified queue.
+     * @returns The name of the transport that was used (useful for MultiTransport)
+     */
+    send(queue: string, envelope: Envelope, options?: SendOptions): Promise<Transport['name']>;
+    /**
+     * Subscribes to messages on the specified queue.
+     * The handler receives decoded envelopes and receipts.
+     */
+    subscribe(queue: string, handler: MessageHandler, options?: SubscribeOptions): Promise<Subscription>;
+    /**
+     * Acknowledges/completes a message.
+     * Called after processing is done (success, retry scheduled, or dead-lettered).
+     */
+    complete(receipt: MessageReceipt): Promise<void>;
+    /**
+     * Sends a message to the dead-letter queue.
+     * For transports with native DL routing, may use native mechanism.
+     * For others, sends to DLQ then completes original.
+     */
+    sendToDeadLetter?(receipt: MessageReceipt, dlqName: string, envelope: Envelope, reason: string): Promise<void>;
+}
+//# sourceMappingURL=transport.d.ts.map

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

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

package/dist/transport/transport.js

@@ -0,0 +1 @@
+export {};