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

package/dist/consumerMq.d.ts

@@ -76,8 +76,11 @@ declare class RabbitMQConsumer extends 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 }
      * });
      */
@@ -85,12 +88,44 @@ declare class RabbitMQConsumer extends EventEmitter {
         durable?: boolean;
         exclusive?: boolean;
         autoDelete?: boolean;
+        exchangeName?: string;
+        exchangeType?: 'direct' | 'topic' | 'fanout' | 'headers';
+        routingKey?: string;
         retryConfig?: RetryConfig;
     }): Promise<void>;
     /**
-     * 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
+     * });
+     */
+    deleteQueues(queueNames: string | string[], options?: {
+        /** Whether to delete associated retry queue (default: true) */
+        includeRetry?: boolean;
+        /** Whether to delete associated DLQ (default: true) */
+        includeDLQ?: boolean;
+    }): Promise<void>;
+    /**
+     * Setup Dead Letter Queue (DLQ) infrastructure for a queue with retry mechanism
      */
-    private setupRetryAndDLQQueues;
+    private setupDLQInfrastructure;
     /**
      * Bind a queue to an exchange with a routing key (Best Practice for Consumers)
      * Consumers decide which exchanges/routing keys they want to subscribe to
@@ -176,10 +211,61 @@ declare class RabbitMQConsumer extends EventEmitter {
     private calculateRetryDelay;
     /**
      * 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) => { ... }
+     * });
      */
     consumeQueue<T = any>(config: ConsumeConfig<T>): Promise<void>;
     /**
      * 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) => { ... }
+     *     }
+     *   ]
+     * });
      */
     consumeMultipleQueues<T = any>(config: MultiQueueConsumeConfig<T>): Promise<void>;
     /**

package/dist/consumerMq.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"consumerMq.d.ts","sourceRoot":"","sources":["../consumerMq.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"consumerMq.d.ts","sourceRoot":"","sources":["../consumerMq.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EASL,aAAa,EACb,WAAW,EACX,uBAAuB,EAIvB,iBAAiB,EACjB,WAAW,EACZ,MAAM,SAAS,CAAC;AAGjB,cAAM,gBAAiB,SAAQ,YAAY;IACzC,OAAO,CAAC,UAAU,CAAC,CAA6B;IAChD,OAAO,CAAC,OAAO,CAAC,CAAsB;IAC/B,SAAS,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,wBAAwB,CAAS;IACzC,OAAO,CAAC,mBAAmB,CAAS;IAEpC,OAAO,CAAC,qBAAqB,CAAC,CAAgB;IAE9C;;;;;;;;;;;;;;;OAeG;gBACS,OAAO,CAAC,EAAE,MAAM,GAAG,iBAAiB;IAiBhD;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAuFjC;;;;OAIG;YACW,gBAAgB;IAsB9B;;OAEG;IACH,mBAAmB,IAAI,OAAO;IAI9B;;;;;;;;;;;;;;OAcG;IACG,cAAc,CAClB,aAAa,EAAE,MAAM,GAAG,MAAM,EAAE,EAChC,OAAO,GAAE;QACP,YAAY,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;QACzD,OAAO,CAAC,EAAE,OAAO,CAAC;KACd,GACL,OAAO,CAAC,IAAI,CAAC;IAoChB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,YAAY,CAChB,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,EAC7B,OAAO,GAAE;QACP,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,YAAY,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;QACzD,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,WAAW,CAAC,EAAE,WAAW,CAAC;KACtB,GACL,OAAO,CAAC,IAAI,CAAC;IAgHhB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,YAAY,CAChB,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,EAC7B,OAAO,GAAE;QACP,+DAA+D;QAC/D,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,uDAAuD;QACvD,UAAU,CAAC,EAAE,OAAO,CAAC;KACjB,GACL,OAAO,CAAC,IAAI,CAAC;IA8EhB;;OAEG;YACW,sBAAsB;IAuDpC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,SAAS,CACb,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE;QACP,YAAY,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;QACzD,OAAO,CAAC,EAAE,OAAO,CAAC;KACd,GACL,OAAO,CAAC,IAAI,CAAC;IAoChB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,UAAU,CAAC,MAAM,EAAE;QACvB,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;QACxD,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;QAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,WAAW,CAAC,EAAE,WAAW,CAAC;KAC3B,GAAG,OAAO,CAAC,IAAI,CAAC;IAyFjB;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CA4B3C;IAEF;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAmCxB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA6B3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACG,YAAY,CAAC,CAAC,GAAG,GAAG,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAoPpE;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,qBAAqB,CAAC,CAAC,GAAG,GAAG,EACjC,MAAM,EAAE,uBAAuB,CAAC,CAAC,CAAC,GACjC,OAAO,CAAC,IAAI,CAAC;IAYhB;;OAEG;IACG,kBAAkB,CAAC,CAAC,GAAG,GAAG,EAC9B,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,CACT,OAAO,EAAE,CAAC,EACV,UAAU,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,WAAW,KACtB,OAAO,CAAC,IAAI,CAAC,EAClB,OAAO,GAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAO,GACrD,OAAO,CAAC,IAAI,CAAC;IAiEhB;;OAEG;IACH,gBAAgB,IAAI;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,EAAE,CAAA;KAAE;IAOjE;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CA4B7B;AAGD,OAAO,EAAE,gBAAgB,EAAE,CAAC;;AAC5B,wBAAsC"}

package/dist/consumerMq.js

@@ -67,8 +67,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 +199,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 +239,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 +252,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 +304,21 @@ 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) {
+                    // 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 +327,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 +484,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 +557,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 +569,8 @@ 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`;
+                    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 +671,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 +722,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) => {
@@ -547,10 +741,12 @@ class RabbitMQConsumer extends events_1.EventEmitter {
                             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);
@@ -583,7 +779,7 @@ class RabbitMQConsumer extends events_1.EventEmitter {
                                 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,
@@ -593,7 +789,7 @@ class RabbitMQConsumer extends events_1.EventEmitter {
                                             'x-retry-count': nextRetryCount,
                                             'x-retry-timestamp': new Date().toISOString(),
                                             'x-base-retry-delay': baseRetryDelay, // Store the BASE delay (don't compound!)
-                                        }
+                                        },
                                     });
                                     // Acknowledge original message after successful retry queue publish
                                     ch.ack(msg);
@@ -624,7 +820,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 +832,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 +879,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 +938,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 +966,7 @@ class RabbitMQConsumer extends events_1.EventEmitter {
     getConsumerStats() {
         return {
             rabbitUrl: this.rabbitUrl,
-            activeQueues: [...this.activeQueues]
+            activeQueues: [...this.activeQueues],
         };
     }
     /**
@@ -763,7 +978,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;
             }