rabbitmq-with-retry-and-dlq 1.0.24 → 1.0.26

package/dist/consumerMq.js

@@ -59,6 +59,8 @@ class RabbitMQConsumer extends events_1.EventEmitter {
         super(); // Initialize EventEmitter
         this.isConnected = false;
         this.activeQueues = [];
+        // Store retry configurations for each queue (queue-level config, not message-level)
+        this.queueRetryConfigs = new Map();
         // Support both string URL (backward compatible) and options object
         if (typeof options === 'string') {
             this.rabbitUrl = options;
@@ -67,8 +69,10 @@ class RabbitMQConsumer extends events_1.EventEmitter {
         }
         else {
             this.rabbitUrl = options?.url || 'amqp://localhost';
-            this.reconnectIntervalSeconds = options?.reconnectIntervalSeconds || types_1.RECONNECT_INTERVAL_SECONDS;
-            this.connectionTimeoutMs = options?.connectionTimeoutMs || types_1.CONNECTION_TIMEOUT_MS;
+            this.reconnectIntervalSeconds =
+                options?.reconnectIntervalSeconds || types_1.RECONNECT_INTERVAL_SECONDS;
+            this.connectionTimeoutMs =
+                options?.connectionTimeoutMs || types_1.CONNECTION_TIMEOUT_MS;
         }
     }
     /**
@@ -197,8 +201,16 @@ class RabbitMQConsumer extends events_1.EventEmitter {
         // Auto-connect on first use (lazy loading)
         await this.ensureConnection();
         // Normalize to array
-        const exchanges = Array.isArray(exchangeNames) ? exchangeNames : [exchangeNames];
+        const exchanges = Array.isArray(exchangeNames)
+            ? exchangeNames
+            : [exchangeNames];
         const { exchangeType = 'direct', durable = true } = options;
+        // Validate exchange names
+        for (const exchangeName of exchanges) {
+            if (!exchangeName || exchangeName.trim() === '') {
+                throw new Error('Exchange name cannot be empty');
+            }
+        }
         try {
             await this.channel.addSetup(async (ch) => {
                 for (const exchangeName of exchanges) {
@@ -229,8 +241,11 @@ class RabbitMQConsumer extends events_1.EventEmitter {
      * await consumer.assertQueues(['orders-worker', 'payments-worker']);
      *
      * @example
-     * // Assert queue with DLQ setup
+     * // Assert queue with exchange binding and retry config
      * await consumer.assertQueues('orders-worker', {
+     *   exchangeName: 'orders',
+     *   exchangeType: 'direct',
+     *   routingKey: 'order.created',
      *   retryConfig: { maxRetries: 3, retryDelayMs: 5000 }
      * });
      */
@@ -239,21 +254,51 @@ class RabbitMQConsumer extends events_1.EventEmitter {
         await this.ensureConnection();
         // Normalize to array
         const queues = Array.isArray(queueNames) ? queueNames : [queueNames];
-        const { durable = true, exclusive = false, autoDelete = false, retryConfig, } = options;
+        const { durable = true, exclusive = false, autoDelete = false, exchangeName, exchangeType = 'direct', routingKey, retryConfig, } = options;
+        // Validate queue names
+        for (const queueName of queues) {
+            if (!queueName || queueName.trim() === '') {
+                throw new Error('Queue name cannot be empty');
+            }
+        }
+        // Validate exchange name if provided
+        if (exchangeName && exchangeName.trim() === '') {
+            throw new Error('Exchange name cannot be empty');
+        }
+        // Note: If exchangeName is provided without routingKey, queueName will be used as routingKey for each queue
         // Validate retry configuration if provided
         if (retryConfig) {
             (0, validation_1.validateRetryConfig)(retryConfig);
         }
         try {
+            const defaultExchange = '';
+            const dlxName = exchangeName
+                ? `${exchangeName}${types_1.DLX_SUFFIX}`
+                : `default${types_1.DLX_SUFFIX}`;
+            const effectiveExchange = exchangeName || defaultExchange;
+            const effectiveRoutingKey = routingKey || (queues.length === 1 ? queues[0] : '');
+            // Assert all queues
             await this.channel.addSetup(async (ch) => {
+                // Assert exchange if provided
+                if (exchangeName) {
+                    await ch.assertExchange(exchangeName, exchangeType, { durable });
+                    console.log(`✓ Exchange asserted: ${exchangeName} (${exchangeType})`);
+                }
                 for (const queueName of queues) {
                     const queueArgs = {};
+                    const effectiveKey = routingKey || queueName;
                     // Setup DLQ arguments if retry config is provided
                     if (retryConfig && retryConfig.maxRetries > 0) {
-                        // Messages that fail will be sent to retry queue
-                        queueArgs['x-dead-letter-exchange'] = '';
-                        queueArgs['x-dead-letter-routing-key'] = `${queueName}.retry`;
+                        // With retry: failed messages go to retry queue first
+                        queueArgs['x-dead-letter-exchange'] = effectiveExchange;
+                        queueArgs['x-dead-letter-routing-key'] = `${effectiveKey}${types_1.RETRY_QUEUE_SUFFIX}`;
+                    }
+                    else if (retryConfig) {
+                        // No retry (maxRetries = 0): go directly to DLQ
+                        queueArgs['x-dead-letter-exchange'] = dlxName;
+                        queueArgs['x-dead-letter-routing-key'] = `${effectiveKey}${types_1.DLQ_SUFFIX}`;
                     }
+                    // Assert queue (idempotent - RabbitMQ won't recreate if exists with same params)
                     await ch.assertQueue(queueName, {
                         durable,
                         exclusive,
@@ -261,12 +306,23 @@ class RabbitMQConsumer extends events_1.EventEmitter {
                         arguments: Object.keys(queueArgs).length > 0 ? queueArgs : undefined,
                     });
                     console.log(`✓ Queue asserted: ${queueName}`);
-                    // Setup retry and DLQ queues if retry config is provided
-                    if (retryConfig) {
-                        await this.setupRetryAndDLQQueues(ch, queueName, retryConfig);
+                    // Bind queue to exchange if exchangeName is provided (idempotent operation)
+                    if (exchangeName) {
+                        await ch.bindQueue(queueName, exchangeName, effectiveKey);
+                        console.log(`✓ Queue bound to exchange: ${queueName} -> ${exchangeName} (${effectiveKey})`);
                     }
                 }
             });
+            // Setup DLQ infrastructure for all queues if retry config is provided
+            if (retryConfig) {
+                for (const queueName of queues) {
+                    // Store retry config for this queue (infrastructure-level configuration)
+                    this.queueRetryConfigs.set(queueName, retryConfig);
+                    // Use provided exchange/routingKey or defaults
+                    const effectiveKey = routingKey || queueName;
+                    await this.setupDLQInfrastructure(queueName, effectiveExchange, effectiveKey, retryConfig);
+                }
+            }
             console.log(`✓ Successfully asserted ${queues.length} queue(s)`);
         }
         catch (error) {
@@ -275,30 +331,135 @@ class RabbitMQConsumer extends events_1.EventEmitter {
         }
     }
     /**
-     * Setup retry queue and DLQ for a main queue
+     * Delete queues (Best Practice for cleanup/testing)
+     * Can be called with a single queue name or multiple queue names
+     * Also deletes associated retry and DLQ queues if they exist
+     *
+     * @param queueNames - Single queue name (string) or array of queue names
+     * @param options - Delete options (includeRetry, includeDLQ)
+     *
+     * @example
+     * // Delete a single queue
+     * await consumer.deleteQueues('orders');
+     *
+     * @example
+     * // Delete multiple queues
+     * await consumer.deleteQueues(['orders', 'payments', 'notifications']);
+     *
+     * @example
+     * // Delete queue without retry/DLQ queues
+     * await consumer.deleteQueues('orders', {
+     *   includeRetry: false,
+     *   includeDLQ: false
+     * });
      */
-    async setupRetryAndDLQQueues(ch, queueName, retryConfig) {
-        const retryQueueName = `${queueName}.retry`;
-        const dlqName = `${queueName}.dlq`;
-        // Create retry queue (messages come back to main queue after TTL)
-        if (retryConfig.maxRetries > 0) {
-            await ch.assertQueue(retryQueueName, {
+    async deleteQueues(queueNames, options = {}) {
+        // Auto-connect on first use (lazy loading)
+        await this.ensureConnection();
+        // Normalize to array
+        const queues = Array.isArray(queueNames) ? queueNames : [queueNames];
+        const { includeRetry = true, includeDLQ = true } = options;
+        try {
+            let deletedCount = 0;
+            // Delete all queues
+            await this.channel.addSetup(async (ch) => {
+                for (const queueName of queues) {
+                    // Delete main queue
+                    try {
+                        await ch.deleteQueue(queueName, { ifEmpty: false });
+                        console.log(`✓ Deleted queue: ${queueName}`);
+                        deletedCount++;
+                    }
+                    catch (error) {
+                        // Queue doesn't exist or already deleted
+                        if (error.code !== 404) {
+                            console.warn(`Warning: Could not delete queue ${queueName}:`, error.message);
+                        }
+                    }
+                    // Delete retry queue if requested
+                    if (includeRetry) {
+                        try {
+                            await ch.deleteQueue(`${queueName}${types_1.RETRY_QUEUE_SUFFIX}`, {
+                                ifEmpty: false,
+                            });
+                            console.log(`✓ Deleted retry queue: ${queueName}${types_1.RETRY_QUEUE_SUFFIX}`);
+                            deletedCount++;
+                        }
+                        catch (error) {
+                            // Retry queue doesn't exist, skip
+                            if (error.code !== 404) {
+                                console.warn(`Warning: Could not delete retry queue ${queueName}${types_1.RETRY_QUEUE_SUFFIX}:`, error.message);
+                            }
+                        }
+                    }
+                    // Delete DLQ if requested
+                    if (includeDLQ) {
+                        try {
+                            await ch.deleteQueue(`${queueName}${types_1.DLQ_SUFFIX}`, {
+                                ifEmpty: false,
+                            });
+                            console.log(`✓ Deleted DLQ: ${queueName}${types_1.DLQ_SUFFIX}`);
+                            deletedCount++;
+                        }
+                        catch (error) {
+                            // DLQ doesn't exist, skip
+                            if (error.code !== 404) {
+                                console.warn(`Warning: Could not delete DLQ ${queueName}${types_1.DLQ_SUFFIX}:`, error.message);
+                            }
+                        }
+                    }
+                }
+            });
+            console.log(`✓ Successfully deleted ${deletedCount} queue(s)`);
+        }
+        catch (error) {
+            console.error('Failed to delete queues:', error);
+            throw error;
+        }
+    }
+    /**
+     * Setup Dead Letter Queue (DLQ) infrastructure for a queue with retry mechanism
+     */
+    async setupDLQInfrastructure(queueName, exchangeName, routingKey, retryConfig) {
+        await this.channel.addSetup(async (ch) => {
+            const dlxName = `${exchangeName}${types_1.DLX_SUFFIX}`;
+            const dlqName = `${queueName}${types_1.DLQ_SUFFIX}`;
+            const retryQueueName = `${queueName}${types_1.RETRY_QUEUE_SUFFIX}`;
+            // 1. Create Dead Letter Exchange (DLX) - only if exchangeName is not empty
+            if (exchangeName) {
+                await ch.assertExchange(dlxName, 'direct', { durable: true });
+            }
+            // 2. Create Dead Letter Queue (DLQ) - Final resting place for failed messages
+            // assertQueue is idempotent - won't recreate if exists with same params
+            await ch.assertQueue(dlqName, {
                 durable: true,
                 arguments: {
-                    'x-dead-letter-exchange': '',
-                    'x-dead-letter-routing-key': queueName,
+                    'x-queue-mode': 'lazy', // Better for long-term storage, saves memory
                 },
             });
-            console.log(`✓ Retry queue asserted: ${retryQueueName}`);
-        }
-        // Create DLQ (final resting place for failed messages)
-        await ch.assertQueue(dlqName, {
-            durable: true,
-            arguments: {
-                'x-queue-mode': 'lazy',
-            },
+            // Bind DLQ to DLX if exchange is used
+            if (exchangeName) {
+                await ch.bindQueue(dlqName, dlxName, `${routingKey}${types_1.DLQ_SUFFIX}`);
+            }
+            console.log(`✓ DLQ asserted: ${dlqName}`);
+            // 3. Create Retry Queue (if retry is enabled)
+            if (retryConfig && retryConfig.maxRetries > 0) {
+                // assertQueue is idempotent - won't recreate if exists with same params
+                await ch.assertQueue(retryQueueName, {
+                    durable: true,
+                    arguments: {
+                        // NO fixed TTL - we use per-message expiration for exponential backoff
+                        'x-dead-letter-exchange': exchangeName || '', // Send back to main exchange after TTL
+                        'x-dead-letter-routing-key': routingKey, // Use original routing key
+                    },
+                });
+                console.log(`✓ Retry queue asserted: ${retryQueueName}`);
+                console.log(`DLQ infrastructure setup complete for queue: ${queueName} (max retries: ${retryConfig.maxRetries}, exponential backoff enabled)`);
+            }
+            else {
+                console.log(`DLQ infrastructure setup complete for queue: ${queueName} (no retries)`);
+            }
         });
-        console.log(`✓ DLQ asserted: ${dlqName}`);
     }
     /**
      * Bind a queue to an exchange with a routing key (Best Practice for Consumers)
@@ -327,6 +488,16 @@ class RabbitMQConsumer extends events_1.EventEmitter {
         // Auto-connect on first use (lazy loading)
         await this.ensureConnection();
         const { exchangeType, durable = true } = options;
+        // Validate inputs
+        if (!queueName || queueName.trim() === '') {
+            throw new Error('Queue name cannot be empty');
+        }
+        if (!exchangeName || exchangeName.trim() === '') {
+            throw new Error('Exchange name cannot be empty');
+        }
+        if (!routingKey || routingKey.trim() === '') {
+            throw new Error('Routing key cannot be empty');
+        }
         try {
             await this.channel.addSetup(async (ch) => {
                 // If exchangeType is provided, assert the exchange first (idempotent)
@@ -390,7 +561,7 @@ class RabbitMQConsumer extends events_1.EventEmitter {
                 const queueArgs = {};
                 if (retryConfig && retryConfig.maxRetries > 0) {
                     queueArgs['x-dead-letter-exchange'] = '';
-                    queueArgs['x-dead-letter-routing-key'] = `${queueName}.retry`;
+                    queueArgs['x-dead-letter-routing-key'] = `${queueName}${types_1.RETRY_QUEUE_SUFFIX}`;
                 }
                 // 3. Assert queue
                 await ch.assertQueue(queueName, {
@@ -402,8 +573,10 @@ class RabbitMQConsumer extends events_1.EventEmitter {
                 console.log(`✓ Queue asserted: ${queueName}`);
                 // 4. Setup retry and DLQ queues if retry config is provided
                 if (retryConfig) {
-                    const retryQueueName = `${queueName}.retry`;
-                    const dlqName = `${queueName}.dlq`;
+                    // Store retry config for this queue (infrastructure-level configuration)
+                    this.queueRetryConfigs.set(queueName, retryConfig);
+                    const retryQueueName = `${queueName}${types_1.RETRY_QUEUE_SUFFIX}`;
+                    const dlqName = `${queueName}${types_1.DLQ_SUFFIX}`;
                     if (retryConfig.maxRetries > 0) {
                         await ch.assertQueue(retryQueueName, {
                             durable: true,
@@ -504,16 +677,50 @@ class RabbitMQConsumer extends events_1.EventEmitter {
     }
     /**
      * Consume messages from a queue with automatic retry and DLQ handling
+     *
+     * Note: Queue should be set up separately before consuming:
+     * - Use assertQueues() to create queue with exchange binding
+     * - Use setupQueue() for complete setup with multiple routing keys
+     * - Use bindQueue() to add additional routing key bindings
+     *
+     * @example
+     * // Step 1: Setup queue with exchange and routing keys
+     * await consumer.setupQueue({
+     *   queueName: 'orders',
+     *   exchangeName: 'orders',
+     *   exchangeType: 'topic',
+     *   routingKeys: ['order.created', 'order.updated'],
+     *   retryConfig: { maxRetries: 5 }
+     * });
+     *
+     * // Step 2: Consume (queue already set up)
+     * await consumer.consumeQueue({
+     *   queueName: 'orders',
+     *   onMessage: async (message) => {
+     *     await processOrder(message);
+     *   }
+     * });
+     *
+     * @example
+     * // Direct queue consumption (no exchange)
+     * await consumer.assertQueues('simple-queue');
+     * await consumer.consumeQueue({
+     *   queueName: 'simple-queue',
+     *   onMessage: async (message) => { ... }
+     * });
      */
     async consumeQueue(config) {
         // Auto-connect on first use (lazy loading)
         await this.ensureConnection();
         try {
-            console.log('Consuming queue:', config);
-            const { queueName, exchangeName, exchangeType = 'direct', routingKey, onMessage, options = {} } = config;
-            const { durable = true, prefetch = types_1.DEFAULT_PREFETCH_COUNT, noAck = false, exclusive = false, autoDelete = false } = options;
+            const { queueName, onMessage, options = {} } = config;
+            const { durable = true, prefetch = types_1.DEFAULT_PREFETCH_COUNT, noAck = false, exclusive = false, autoDelete = false, } = options;
+            // Validate inputs
+            if (!queueName || queueName.trim() === '') {
+                throw new Error('Queue name cannot be empty');
+            }
             await this.channel.addSetup(async (ch) => {
-                // Set prefetch count
+                // Set prefetch count (critical for flow control)
                 await ch.prefetch(prefetch);
                 // Check if queue exists (passive check - doesn't modify queue properties)
                 try {
@@ -521,16 +728,9 @@ class RabbitMQConsumer extends events_1.EventEmitter {
                 }
                 catch (error) {
                     // Queue doesn't exist, create it without DLQ config (for simple cases)
-                    // If using with retry/DLQ, publisher should create the queue first
+                    // For production, use assertQueues() or setupQueue() first
                     await ch.assertQueue(queueName, { durable, exclusive, autoDelete });
-                }
-                // If exchange is specified, assert exchange and bind queue
-                if (exchangeName && routingKey) {
-                    await ch.assertExchange(exchangeName, exchangeType, { durable });
-                    // Bind queue to exchange (idempotent operation)
-                    await ch.bindQueue(queueName, exchangeName, routingKey);
-                    // Also bind the retry routing key
-                    await ch.bindQueue(queueName, exchangeName, `${routingKey}.retry`);
+                    console.warn(`Queue ${queueName} was auto-created. Consider using assertQueues() or setupQueue() for proper setup.`);
                 }
                 // Start consuming
                 await ch.consume(queueName, async (msg) => {
@@ -539,18 +739,33 @@ class RabbitMQConsumer extends events_1.EventEmitter {
                     try {
                         const content = JSON.parse(msg.content.toString());
                         const headers = msg.properties.headers || {};
-                        // Extract retry information from headers (only what's needed for success path)
+                        // Get retry config from queue setup (infrastructure-level config)
+                        const queueRetryConfig = this.queueRetryConfigs.get(queueName);
+                        // Extract retry information from headers OR use queue config (on first attempt)
                         const currentRetryCount = headers['x-retry-count'] || 0;
-                        const maxRetries = headers['x-max-retries'] || 0;
+                        const maxRetries = headers['x-max-retries'] !== undefined
+                            ? headers['x-max-retries']
+                            : (queueRetryConfig?.maxRetries || 0);
+                        const baseRetryDelay = headers['x-base-retry-delay'] !== undefined
+                            ? headers['x-base-retry-delay']
+                            : (queueRetryConfig?.retryDelayMs || types_1.DEFAULT_RETRY_DELAY_MS);
+                        const backoffStrategy = headers['x-backoff-strategy']
+                            || (queueRetryConfig?.backoffStrategy || 'exponential');
+                        const maxDelayMs = headers['x-max-delay']
+                            || (queueRetryConfig?.maxDelayMs || types_1.DEFAULT_MAX_DELAY_MS);
+                        const jitterMs = headers['x-jitter']
+                            || (queueRetryConfig?.jitterMs || 0);
                         const firstPublished = headers['x-first-published'] || new Date().toISOString();
                         const messageInfo = {
                             fields: msg.fields,
                             properties: msg.properties,
                             content: msg.content,
-                            originalMessage: msg
+                            originalMessage: msg,
                         };
                         let timestamp = new Date().toISOString();
-                        const retryInfo = maxRetries > 0 ? ` (attempt ${currentRetryCount + 1}/${maxRetries + 1})` : '';
+                        const retryInfo = maxRetries > 0
+                            ? ` (attempt ${currentRetryCount + 1}/${maxRetries + 1})`
+                            : '';
                         console.log(`[${timestamp}] Processing from ${queueName}${retryInfo}:`, content);
                         // Try to process the message
                         await onMessage(content, messageInfo);
@@ -567,33 +782,47 @@ class RabbitMQConsumer extends events_1.EventEmitter {
                         const errorMessage = error instanceof Error ? error.message : String(error);
                         console.error(`[${timestamp}] ✗ Failed from ${queueName}:`, errorMessage);
                         if (!noAck) {
+                            // Re-extract retry config for error handling (same as in try block)
                             const headers = msg.properties.headers || {};
+                            const queueRetryConfig = this.queueRetryConfigs.get(queueName);
                             const currentRetryCount = headers['x-retry-count'] || 0;
-                            const maxRetries = headers['x-max-retries'] || 0;
-                            const baseRetryDelay = headers['x-base-retry-delay'] || types_1.DEFAULT_RETRY_DELAY_MS;
-                            const backoffStrategy = headers['x-backoff-strategy'] || 'exponential';
-                            const maxDelayMs = headers['x-max-delay'] || types_1.DEFAULT_MAX_DELAY_MS;
-                            const jitterMs = headers['x-jitter'] || 0;
-                            // Check if we should retry
+                            const maxRetries = headers['x-max-retries'] !== undefined
+                                ? headers['x-max-retries']
+                                : (queueRetryConfig?.maxRetries || 0);
+                            const baseRetryDelay = headers['x-base-retry-delay'] !== undefined
+                                ? headers['x-base-retry-delay']
+                                : (queueRetryConfig?.retryDelayMs || types_1.DEFAULT_RETRY_DELAY_MS);
+                            const backoffStrategy = headers['x-backoff-strategy']
+                                || (queueRetryConfig?.backoffStrategy || 'exponential');
+                            const maxDelayMs = headers['x-max-delay']
+                                || (queueRetryConfig?.maxDelayMs || types_1.DEFAULT_MAX_DELAY_MS);
+                            const jitterMs = headers['x-jitter']
+                                || (queueRetryConfig?.jitterMs || 0);
+                            const firstPublished = headers['x-first-published'] || new Date().toISOString();
+                            // Check if we should retry (using queue-level config)
                             if (currentRetryCount < maxRetries) {
                                 const nextRetryCount = currentRetryCount + 1;
                                 // Calculate delay with backoff strategy
-                                const actualDelay = this.calculateRetryDelay(baseRetryDelay, // Use base delay, not the previous calculated delay
-                                currentRetryCount, backoffStrategy, maxDelayMs, jitterMs);
+                                const actualDelay = this.calculateRetryDelay(baseRetryDelay, currentRetryCount, backoffStrategy, maxDelayMs, jitterMs);
                                 const timestamp = new Date().toISOString();
                                 console.log(`[${timestamp}] 🔄 Retry ${nextRetryCount}/${maxRetries} in ${actualDelay}ms`);
                                 // Publish to retry queue with updated retry count
-                                const retryQueueName = `${queueName}.retry`;
+                                const retryQueueName = `${queueName}${types_1.RETRY_QUEUE_SUFFIX}`;
                                 try {
                                     await ch.sendToQueue(retryQueueName, msg.content, {
                                         ...msg.properties,
-                                        expiration: actualDelay.toString(), // Set per-message TTL for exponential backoff
+                                        expiration: actualDelay.toString(),
                                         headers: {
                                             ...headers,
                                             'x-retry-count': nextRetryCount,
                                             'x-retry-timestamp': new Date().toISOString(),
-                                            'x-base-retry-delay': baseRetryDelay, // Store the BASE delay (don't compound!)
-                                        }
+                                            'x-base-retry-delay': baseRetryDelay,
+                                            'x-max-retries': maxRetries,
+                                            'x-backoff-strategy': backoffStrategy,
+                                            'x-max-delay': maxDelayMs,
+                                            'x-jitter': jitterMs,
+                                            'x-first-published': firstPublished,
+                                        },
                                     });
                                     // Acknowledge original message after successful retry queue publish
                                     ch.ack(msg);
@@ -624,7 +853,7 @@ class RabbitMQConsumer extends events_1.EventEmitter {
                                 const timestamp = new Date().toISOString();
                                 console.log(`[${timestamp}] 💀 Max retries exceeded, moving to DLQ`);
                                 // Manually send to DLQ (can't rely on nack because main queue's DLX routes to retry)
-                                const dlqName = `${queueName}.dlq`;
+                                const dlqName = `${queueName}${types_1.DLQ_SUFFIX}`;
                                 // Extract error code for categorization
                                 const errorCode = this.extractErrorCode(error);
                                 try {
@@ -636,8 +865,10 @@ class RabbitMQConsumer extends events_1.EventEmitter {
                                             'x-death-timestamp': new Date().toISOString(),
                                             'x-last-error': errorMessage,
                                             'x-last-error-code': errorCode,
-                                            'x-is-retryable': this.isRetryableError(errorCode) ? 'true' : 'false',
-                                        }
+                                            'x-is-retryable': this.isRetryableError(errorCode)
+                                                ? 'true'
+                                                : 'false',
+                                        },
                                     });
                                     // Acknowledge original message after successful DLQ send
                                     ch.ack(msg);
@@ -681,17 +912,34 @@ class RabbitMQConsumer extends events_1.EventEmitter {
     }
     /**
      * Consume from multiple queues with the same connection
+     * Note: Queues should be set up separately before consuming
+     *
+     * @example
+     * // Setup queues first
+     * await consumer.setupQueue({ queueName: 'orders', ... });
+     * await consumer.setupQueue({ queueName: 'payments', ... });
+     *
+     * // Then consume from all
+     * await consumer.consumeMultipleQueues({
+     *   queues: [
+     *     {
+     *       queueName: 'orders',
+     *       onMessage: async (msg) => { ... }
+     *     },
+     *     {
+     *       queueName: 'payments',
+     *       onMessage: async (msg) => { ... }
+     *     }
+     *   ]
+     * });
      */
     async consumeMultipleQueues(config) {
         const { queues, options = {} } = config;
         for (const queueConfig of queues) {
             await this.consumeQueue({
                 queueName: queueConfig.queueName,
-                exchangeName: queueConfig.exchangeName,
-                exchangeType: queueConfig.exchangeType,
-                routingKey: queueConfig.routingKey,
                 onMessage: queueConfig.onMessage,
-                options
+                options,
             });
         }
     }
@@ -723,7 +971,7 @@ class RabbitMQConsumer extends events_1.EventEmitter {
                             fields: msg.fields,
                             properties: msg.properties,
                             content: msg.content,
-                            originalMessage: msg
+                            originalMessage: msg,
                         };
                         await onMessage(content, routingKey, messageInfo);
                         ch.ack(msg);
@@ -751,7 +999,7 @@ class RabbitMQConsumer extends events_1.EventEmitter {
     getConsumerStats() {
         return {
             rabbitUrl: this.rabbitUrl,
-            activeQueues: [...this.activeQueues]
+            activeQueues: [...this.activeQueues],
         };
     }
     /**
@@ -763,7 +1011,7 @@ class RabbitMQConsumer extends events_1.EventEmitter {
             if (this.channel) {
                 // Give time for in-flight messages to complete processing
                 // In production, you might want to implement a more sophisticated drain mechanism
-                await new Promise(resolve => setTimeout(resolve, 1000));
+                await new Promise((resolve) => setTimeout(resolve, 1000));
                 await this.channel.close();
                 this.channel = undefined;
             }