@zdavison/matador 2.0.8 → 2.0.9

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

@@ -1,541 +0,0 @@
-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';
-/**
- * Redacts credentials from an AMQP URL.
- * Replaces username and password with '****' regardless of their length.
- *
- * @example
- * redactAmqpUrl('amqp://user:pass@host:5672') // 'amqp://****:****@host:5672'
- */
-export function redactAmqpUrl(url) {
-    const regex = /^(amqps?:\/\/)[^:]+:[^@]+@/;
-    return url.replace(regex, '$1****:****@');
-}
-/**
- * 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,
-            connectionName: config.connectionName,
-            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() {
-        this.logger.info(`[Matador] ⏳ Connecting to RabbitMQ at '${redactAmqpUrl(this.config.url)}'.`);
-        const connection = await amqplib.connect(this.config.url, {
-            clientProperties: { connection_name: this.config.connectionName },
-        });
-        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 rabbitmqOptions = queueDef.transport?.rabbitmq?.options;
-        // If user provided exact RabbitMQ options, use them directly (replaces all defaults)
-        if (rabbitmqOptions) {
-            await channel.assertQueue(queueName, rabbitmqOptions);
-        }
-        else {
-            // Use computed defaults
-            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/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,100 +0,0 @@
-import { describe, expect, it, mock } from 'bun:test';
-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'.");
-        });
-    });
-});