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

package/README.md

@@ -20,6 +20,48 @@ npm install rabbitmq-with-retry-and-dlq
 
 ---
 
+## Quick Start (Best Practice)
+
+```typescript
+import {
+  initializeRabbitMQ,
+  publisher,
+  consumer,
+} from 'rabbitmq-with-retry-and-dlq';
+
+// 1. Initialize connection
+await initializeRabbitMQ('amqp://localhost:5672');
+
+// 2. Publisher: Assert exchange
+await publisher.assertExchange('orders', { exchangeType: 'topic' });
+
+// 3. Consumer: Setup queue with exchange and routing keys
+await consumer.setupQueue({
+  queueName: 'orders-processor',
+  exchangeName: 'orders',
+  exchangeType: 'topic',
+  routingKeys: ['order.created', 'order.updated'],
+  retryConfig: { maxRetries: 5, retryDelayMs: 2000 },
+});
+
+// 4. Consumer: Start consuming
+await consumer.consumeQueue({
+  queueName: 'orders-processor',
+  onMessage: async (message) => {
+    await processOrder(message);
+  },
+});
+
+// 5. Publisher: Publish messages
+await publisher.publishToExchange({
+  exchangeName: 'orders',
+  routingKey: 'order.created',
+  message: { orderId: 123 },
+});
+```
+
+---
+
 ## Usage
 
 ### 1. Initialize (Required - Call Once with Await)
@@ -27,7 +69,11 @@ npm install rabbitmq-with-retry-and-dlq
 **You must call `await initializeRabbitMQ()` once** in your application setup or helper file:
 
 ```typescript
-import { initializeRabbitMQ, isPublisherConnected, isConsumerConnected } from 'rabbitmq-with-retry-and-dlq';
+import {
+  initializeRabbitMQ,
+  isPublisherConnected,
+  isConsumerConnected,
+} from 'rabbitmq-with-retry-and-dlq';
 
 try {
   // Call once at application startup (in your helper/setup file)
@@ -36,7 +82,7 @@ try {
 
   // Check connection status (both should be true after await)
   console.log('Publisher connected:', isPublisherConnected()); // true
-  console.log('Consumer connected:', isConsumerConnected());   // true
+  console.log('Consumer connected:', isConsumerConnected()); // true
 } catch (error) {
   // Connection failed (wrong URL, RabbitMQ not running, timeout, etc.)
   console.error('Failed to connect to RabbitMQ:', error);
@@ -45,6 +91,7 @@ try {
 ```
 
 **Error Handling:**
+
 - Throws error if URL is wrong
 - Throws error if RabbitMQ is not running
 - Throws error if connection timeout (default: 30 seconds)
@@ -61,7 +108,7 @@ import { publisher, consumer } from 'rabbitmq-with-retry-and-dlq';
 // First call automatically establishes connection
 await publisher.publishToQueue({
   queueName: 'orders',
-  message: { orderId: 123 }
+  message: { orderId: 123 },
 });
 ```
 
@@ -75,6 +122,7 @@ This library follows the RabbitMQ best practice pattern:
 - **Consumer** → Owns **Queues** and **Bindings** (decides what to subscribe to)
 
 This is cleaner because:
+
 1. Publishers don't need to know about queues
 2. Consumers can create their own queues and choose their bindings
 3. Multiple consumers can bind differently to the same exchange
@@ -95,8 +143,8 @@ await publisher.assertExchange(['orders', 'payments', 'notifications']);
 
 // With options
 await publisher.assertExchange('orders', {
-  exchangeType: 'direct',  // 'direct' | 'topic' | 'fanout' | 'headers' (default: 'direct')
-  durable: true,           // Survives broker restart (default: true)
+  exchangeType: 'direct', // 'direct' | 'topic' | 'fanout' | 'headers' (default: 'direct')
+  durable: true, // Survives broker restart (default: true)
 });
 ```
 
@@ -111,12 +159,52 @@ await consumer.assertExchange('orders', { exchangeType: 'topic' });
 await consumer.assertExchange('payments', { exchangeType: 'direct' });
 
 // Or assert multiple exchanges at once
-await consumer.assertExchange(['orders', 'payments'], { exchangeType: 'direct' });
+await consumer.assertExchange(['orders', 'payments'], {
+  exchangeType: 'direct',
+});
 ```
 
 > **Why?** Publisher and consumer use separate connections. Even if publisher creates the exchange, the consumer's connection might not see it immediately. Asserting exchanges on the consumer's connection ensures they exist before binding.
 
-### Consumer: Assert Queues
+### Consumer: Setup Queue (RECOMMENDED - Best Practice)
+
+**Use `setupQueue()` for complete setup in one atomic operation** - prevents race conditions and supports multiple routing keys:
+
+```typescript
+// ✅ RECOMMENDED: Complete setup in one call
+await consumer.setupQueue({
+  queueName: 'orders-processor',
+  exchangeName: 'orders',
+  exchangeType: 'topic',
+  routingKeys: ['order.created', 'order.updated', 'order.cancelled'], // Multiple routing keys!
+  retryConfig: {
+    maxRetries: 5,
+    retryDelayMs: 2000,
+    backoffStrategy: 'exponential',
+    jitterMs: 1000,
+  },
+});
+
+// Then consume (queue already set up)
+await consumer.consumeQueue({
+  queueName: 'orders-processor',
+  onMessage: async (message) => {
+    console.log('Processing order:', message);
+    await processOrder(message);
+  },
+});
+```
+
+**What `setupQueue()` does:**
+
+1. ✅ Asserts exchange
+2. ✅ Creates queue with retry/DLQ infrastructure
+3. ✅ Binds queue to exchange with all routing keys
+4. ✅ All in ONE atomic operation (no race conditions)
+
+### Consumer: Assert Queues (Alternative - More Control)
+
+Use `assertQueues()` when you need more control or want to add bindings dynamically:
 
 ```typescript
 // Assert a single queue
@@ -125,9 +213,11 @@ await consumer.assertQueues('orders-worker');
 // Assert multiple queues
 await consumer.assertQueues(['orders-worker', 'payments-worker']);
 
-// Assert queue with retry/DLQ configuration
+// Assert queue with exchange binding and retry/DLQ configuration
 await consumer.assertQueues('orders-worker', {
-  durable: true,           // Queue survives restart (default: true)
+  exchangeName: 'orders',
+  exchangeType: 'direct',
+  routingKey: 'order.created', // Single routing key
   retryConfig: {
     maxRetries: 5,
     retryDelayMs: 2000,
@@ -136,28 +226,34 @@ await consumer.assertQueues('orders-worker', {
 });
 ```
 
-### Consumer: Bind Queue to Exchange
+### Consumer: Bind Queue to Exchange (For Additional Bindings)
+
+Use `bindQueue()` to add more routing key bindings after initial setup:
 
 ```typescript
 // IMPORTANT: Call consumer.assertExchange() FIRST to prevent race conditions!
 
 // Bind queue to exchange with routing key
-await consumer.bindQueue('orders-worker', 'orders', 'order.created');
+await consumer.bindQueue('orders-worker', 'orders', 'order.created', {
+  exchangeType: 'topic', // Ensures exchange exists (recommended)
+});
 
 // Bind with pattern (for topic exchanges)
-await consumer.bindQueue('all-orders', 'events', 'order.*');
+await consumer.bindQueue('all-orders', 'events', 'order.*', {
+  exchangeType: 'topic',
+});
 
-// Multiple bindings to same queue
+// Add multiple bindings to same queue
 await consumer.bindQueue('orders-worker', 'orders', 'order.created');
 await consumer.bindQueue('orders-worker', 'orders', 'order.updated');
+await consumer.bindQueue('orders-worker', 'orders', 'order.cancelled');
 ```
 
 ### Complete Best Practice Example (RECOMMENDED)
 
-Use `setupQueue()` for atomic setup - it does everything in ONE operation, preventing all race conditions:
-
 ```typescript
 // === PUBLISHER SIDE ===
+// Publisher only knows about exchanges
 await publisher.assertExchange('orders', { exchangeType: 'topic' });
 
 await publisher.publishToExchange({
@@ -167,81 +263,66 @@ await publisher.publishToExchange({
 });
 
 // === CONSUMER SIDE ===
-// Use setupQueue() - does exchange, queue, and bindings in ONE atomic operation
+// Step 1: Setup queue with exchange and multiple routing keys (RECOMMENDED)
 await consumer.setupQueue({
   queueName: 'orders-processor',
   exchangeName: 'orders',
   exchangeType: 'topic',
-  routingKeys: ['order.created', 'order.updated'],
-  retryConfig: { maxRetries: 3, retryDelayMs: 5000 }
+  routingKeys: ['order.created', 'order.updated'], // Multiple keys!
+  retryConfig: { maxRetries: 3, retryDelayMs: 5000 },
 });
 
-// Start consuming
+// Step 2: Start consuming (queue already set up)
 await consumer.consumeQueue({
   queueName: 'orders-processor',
   onMessage: async (message) => {
     console.log('Processing order:', message);
+    await processOrder(message);
   },
 });
 ```
 
 ### Alternative: Step-by-Step Setup
 
-If you need more control, you can use separate methods (but ensure correct order):
+If you need more granular control, use separate methods:
 
 ```typescript
-// Step 1: Assert exchanges on consumer's connection
+// Step 1: Assert exchanges on consumer's connection (defensive)
 await consumer.assertExchange('orders', { exchangeType: 'topic' });
 
 // Step 2: Create queues with retry/DLQ config
 await consumer.assertQueues('orders-processor', {
-  retryConfig: { maxRetries: 3, retryDelayMs: 5000 }
+  retryConfig: { maxRetries: 3, retryDelayMs: 5000 },
+});
+
+// Step 3: Bind queues to exchanges (can add multiple routing keys)
+await consumer.bindQueue('orders-processor', 'orders', 'order.created', {
+  exchangeType: 'topic',
+});
+await consumer.bindQueue('orders-processor', 'orders', 'order.updated', {
+  exchangeType: 'topic',
 });
 
-// Step 3: Bind queues to exchanges
-await consumer.bindQueue('orders-processor', 'orders', 'order.created');
-await consumer.bindQueue('orders-processor', 'orders', 'order.updated');
+// Step 4: Start consuming
+await consumer.consumeQueue({
+  queueName: 'orders-processor',
+  onMessage: async (message) => {
+    await processOrder(message);
+  },
+});
 ```
 
 ---
 
-## Alternative: Publisher-Managed Queues
-
-For simpler use cases, the publisher can also manage queues (backward compatible):
+## Direct Queue Publishing (Without Exchange)
 
-### 3. Assert Queues (with Retry Config)
+For simple point-to-point messaging without exchanges:
 
-**Note:** `assertQueues()` is **idempotent** - it safely skips queues that already exist. You can call it multiple times without errors.
+### Publish to Queue
 
 ```typescript
-await publisher.assertQueues('orders', {
-  durable: true,                    // Queue survives restart (default: true)
-  retryConfig: {
-    maxRetries: 5,                  // Required
-    retryDelayMs: 2000,             // Base delay (default: 5000ms)
-    backoffStrategy: 'exponential', // 'exponential' or 'linear' (default: exponential)
-    maxDelayMs: 300000,             // Max delay cap (default: 300000 = 5min)
-    jitterMs: 1000,                 // Random jitter 0-1000ms (default: 0)
-  },
-});
-
-// Assert multiple queues
-await publisher.assertQueues(['orders', 'payments', 'notifications'], {
-  retryConfig: { maxRetries: 3 }
-});
-
-// With exchange
-await publisher.assertQueues('order_processing', {
-  exchangeName: 'orders_exchange',
-  exchangeType: 'direct',           // 'direct' | 'topic' | 'fanout' | 'headers'
-  routingKey: 'order.created',
-  retryConfig: { maxRetries: 3 },
-});
-```
+// Note: Queue should be set up by consumer first using assertQueues() or setupQueue()
 
-### 4. Publish to Queue
-
-```typescript
 await publisher.publishToQueue({
   queueName: 'orders',
   message: {
@@ -249,14 +330,19 @@ await publisher.publishToQueue({
     amount: 99.99,
   },
   options: {
-    persistent: true,  // Survives broker restart (default: true)
-    priority: 5,       // 0-10 priority (optional)
-    expiration: '5000' // TTL in ms (optional)
+    persistent: true, // Survives broker restart (default: true)
+    priority: 5, // 0-10 priority (optional)
+    expiration: '5000', // TTL in ms (optional)
+  },
+  // Optional: retryConfig if queue wasn't set up with retry
+  retryConfig: {
+    maxRetries: 5,
+    retryDelayMs: 2000,
   },
 });
 ```
 
-### 5. Publish to Exchange
+### Publish to Exchange
 
 ```typescript
 // Publisher only needs exchange and routing key (not queue!)
@@ -272,10 +358,10 @@ await publisher.publishToExchange({
 });
 ```
 
-### 6. Consumer
+### Consumer (Best Practice)
 
 ```typescript
-// Set up error handler
+// Set up error handler FIRST
 consumer.on('error', (errorEvent) => {
   console.error('RabbitMQ Error:', errorEvent);
   if (errorEvent.type === 'DLQ_FAILED') {
@@ -283,31 +369,34 @@ consumer.on('error', (errorEvent) => {
   }
 });
 
-// Consume messages
+// Step 1: Setup queue with exchange and routing keys
+await consumer.setupQueue({
+  queueName: 'orders-processor',
+  exchangeName: 'orders_exchange',
+  exchangeType: 'direct',
+  routingKeys: ['order.created', 'order.updated'],
+  retryConfig: {
+    maxRetries: 5,
+    retryDelayMs: 2000,
+    backoffStrategy: 'exponential',
+  },
+});
+
+// Step 2: Start consuming (queue already set up)
 await consumer.consumeQueue({
-  queueName: 'orders',
+  queueName: 'orders-processor',
   onMessage: async (message, messageInfo) => {
     console.log('Processing:', message);
-    
+
     // Your business logic
     await processOrder(message);
-    
+
     // Success = auto-ack
-    // Throw error = retry with backoff
+    // Throw error = retry with backoff → DLQ
   },
   options: {
-    prefetch: 5,      // Max unacked messages (default: 5)
-    noAck: false,     // Auto-ack (default: false)
-  },
-});
-
-// Consume from exchange
-await consumer.consumeQueue({
-  queueName: 'order_processing',
-  exchangeName: 'orders_exchange',
-  routingKey: 'order.created',
-  onMessage: async (message) => {
-    await processOrder(message);
+    prefetch: 5, // Max unacked messages (default: 5)
+    noAck: false, // Auto-ack (default: false)
   },
 });
 ```
@@ -335,11 +424,11 @@ process.on('SIGINT', shutdown);
 
 ```typescript
 interface RetryConfig {
-  maxRetries: number;        // Required: max retry attempts
-  retryDelayMs?: number;     // Optional: base delay in ms (default: 5000)
-  backoffStrategy?: string;  // Optional: 'exponential' | 'linear' (default: 'exponential')
-  maxDelayMs?: number;       // Optional: max delay cap (default: 300000)
-  jitterMs?: number;         // Optional: random jitter range (default: 0)
+  maxRetries: number; // Required: max retry attempts
+  retryDelayMs?: number; // Optional: base delay in ms (default: 5000)
+  backoffStrategy?: string; // Optional: 'exponential' | 'linear' (default: 'exponential')
+  maxDelayMs?: number; // Optional: max delay cap (default: 300000)
+  jitterMs?: number; // Optional: random jitter range (default: 0)
 }
 ```
 
@@ -403,9 +492,9 @@ async function startApp() {
     // 1. Initialize RabbitMQ connection (required - use await)
     console.log('Connecting to RabbitMQ...');
     await initializeRabbitMQ('amqp://user:pass@localhost:5672');
-    
+
     console.log('✓ Publisher connected:', isPublisherConnected()); // true
-    console.log('✓ Consumer connected:', isConsumerConnected());   // true
+    console.log('✓ Consumer connected:', isConsumerConnected()); // true
 
     // 2. Set up error handler
     consumer.on('error', (errorEvent: RabbitMQErrorEvent) => {
@@ -416,12 +505,12 @@ async function startApp() {
     await publisher.assertExchange('orders', { exchangeType: 'topic' });
     console.log('✓ Publisher exchange asserted');
 
-    // 4. Consumer: Assert exchange on consumer's connection (PREVENTS RACE CONDITIONS!)
-    await consumer.assertExchange('orders', { exchangeType: 'topic' });
-    console.log('✓ Consumer exchange asserted');
-
-    // 5. Consumer: Assert queues with retry config (consumer owns queues)
-    await consumer.assertQueues('orders-processor', {
+    // 4. Consumer: Setup queue with exchange and routing keys (RECOMMENDED)
+    await consumer.setupQueue({
+      queueName: 'orders-processor',
+      exchangeName: 'orders',
+      exchangeType: 'topic',
+      routingKeys: ['order.created', 'order.updated'],
       retryConfig: {
         maxRetries: 5,
         retryDelayMs: 2000,
@@ -429,14 +518,9 @@ async function startApp() {
         jitterMs: 1000,
       },
     });
-    console.log('✓ Queues asserted');
-
-    // 6. Consumer: Bind queue to exchange (consumer decides what to receive)
-    await consumer.bindQueue('orders-processor', 'orders', 'order.created');
-    await consumer.bindQueue('orders-processor', 'orders', 'order.updated');
-    console.log('✓ Queue bindings created');
+    console.log('✓ Queue setup complete');
 
-    // 7. Start consumer
+    // 5. Start consumer (queue already set up)
     await consumer.consumeQueue({
       queueName: 'orders-processor',
       onMessage: async (message) => {
@@ -498,29 +582,28 @@ startApp();
 
 ### Publisher Methods
 
-| Method | Description |
-|--------|-------------|
-| `assertExchange(names, options?)` | Create exchange(s) - Publisher owns exchanges |
-| `assertQueues(names, options?)` | Create queue(s) with optional retry config (backward compatible) |
-| `publishToExchange(config)` | Publish to exchange with routing key |
-| `publishToQueue(config)` | Publish directly to queue |
-| `publishBatch(configs)` | Publish multiple messages |
-| `deleteQueues(names, options?)` | Delete queue(s) and related retry/DLQ queues |
-| `close()` | Close publisher connection |
+| Method                            | Description                                                    |
+| --------------------------------- | -------------------------------------------------------------- |
+| `assertExchange(names, options?)` | Create exchange(s) - Publisher owns exchanges                  |
+| `publishToExchange(config)`       | Publish to exchange with routing key                           |
+| `publishToQueue(config)`          | Publish directly to queue (queue should be set up by consumer) |
+| `publishBatch(configs)`           | Publish multiple messages                                      |
+| `close()`                         | Close publisher connection                                     |
 
 ### Consumer Methods
 
-| Method | Description |
-|--------|-------------|
-| `setupQueue(config)` | **RECOMMENDED** - Atomic setup: exchange + queue + bindings in one operation |
-| `assertExchange(names, options?)` | Assert exchange(s) on consumer connection |
-| `assertQueues(names, options?)` | Create queue(s) with optional retry/DLQ config |
-| `bindQueue(queue, exchange, routingKey, options?)` | Bind queue to exchange |
-| `consumeQueue(config)` | Start consuming from queue |
-| `consumeMultipleQueues(config)` | Consume from multiple queues |
-| `consumeWithPattern(exchange, pattern, handler)` | Consume with pattern matching (topic) |
-| `getConsumerStats()` | Get consumer statistics |
-| `close()` | Close consumer connection |
+| Method                                             | Description                                                                                          |
+| -------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
+| `setupQueue(config)`                               | **⭐ RECOMMENDED** - Complete setup: exchange + queue + bindings + retry/DLQ in one atomic operation |
+| `assertExchange(names, options?)`                  | Assert exchange(s) on consumer connection (defensive)                                                |
+| `assertQueues(names, options?)`                    | Create queue(s) with optional exchange binding and retry/DLQ config                                  |
+| `bindQueue(queue, exchange, routingKey, options?)` | Bind queue to exchange (for additional routing keys)                                                 |
+| `deleteQueues(names, options?)`                    | Delete queue(s) and related retry/DLQ queues                                                         |
+| `consumeQueue(config)`                             | Start consuming from queue (queue must be set up first)                                              |
+| `consumeMultipleQueues(config)`                    | Consume from multiple queues                                                                         |
+| `consumeWithPattern(exchange, pattern, handler)`   | Consume with pattern matching (topic)                                                                |
+| `getConsumerStats()`                               | Get consumer statistics                                                                              |
+| `close()`                                          | Close consumer connection                                                                            |
 
 ---
 
@@ -550,12 +633,13 @@ startApp();
 
 ```typescript
 await consumer.bindQueue(
-  'queue-name',      // Queue to bind
-  'exchange-name',   // Exchange to bind to
-  'routing.key',     // Routing key or pattern (for topic exchanges)
-  {                  // Options (optional)
-    exchangeType: 'topic',  // If provided, asserts exchange before binding (RECOMMENDED)
-    durable: true           // Exchange durability (default: true)
+  'queue-name', // Queue to bind
+  'exchange-name', // Exchange to bind to
+  'routing.key', // Routing key or pattern (for topic exchanges)
+  {
+    // Options (optional)
+    exchangeType: 'topic', // If provided, asserts exchange before binding (RECOMMENDED)
+    durable: true, // Exchange durability (default: true)
   }
 );
 
@@ -602,13 +686,13 @@ await consumer.bindQueue(
 
 ```typescript
 // Delete queue (includes retry and DLQ by default)
-await publisher.deleteQueues('orders');
+await consumer.deleteQueues('orders');
 
 // Delete multiple queues
-await publisher.deleteQueues(['orders', 'payments']);
+await consumer.deleteQueues(['orders', 'payments']);
 
 // Delete only main queue
-await publisher.deleteQueues('orders', {
+await consumer.deleteQueues('orders', {
   includeRetry: false,
   includeDLQ: false,
 });
@@ -619,11 +703,13 @@ await publisher.deleteQueues('orders', {
 ## Important Notes
 
 ### Required (Must Implement)
+
 - ⚠️ **Must call `await initializeRabbitMQ(url)` with try/catch** - throws error on connection failure
 - ⚠️ **Must implement graceful shutdown handlers** (`SIGTERM`, `SIGINT`)
 - ⚠️ **Must monitor DLQ failures** (indicates message loss)
 
 ### Error Handling
+
 - `initializeRabbitMQ()` throws error if:
   - RabbitMQ URL is wrong
   - RabbitMQ is not running
@@ -631,6 +717,7 @@ await publisher.deleteQueues('orders', {
 - Always wrap in try/catch for fail-fast behavior
 
 ### Automatic (No Action Needed)
+
 - ✅ Auto-reconnection on connection loss
 - ✅ Lazy loading - connects on first use (after initialization)
 - ✅ Message durability with `persistent: true`
@@ -638,12 +725,16 @@ await publisher.deleteQueues('orders', {
 - ✅ Thread-safe initialization
 
 ### Best Practices
+
 - Call `initializeRabbitMQ(url)` once in your setup/helper file
 - **Use separation of concerns pattern:**
-  - Publisher → `assertExchange()` (owns exchanges)
-  - Consumer → `assertQueues()` + `bindQueue()` (owns queues and bindings)
-- Set `retryConfig` in `assertQueues()` - auto-used when processing
-- `assertExchange()`, `assertQueues()`, and `bindQueue()` are idempotent - safe to call multiple times
+  - Publisher → `assertExchange()` + `publishToExchange()` (owns exchanges)
+  - Consumer → `setupQueue()` or `assertQueues()` + `bindQueue()` (owns queues and bindings)
+- **Recommended workflow:**
+  1. Setup infrastructure at startup: `consumer.setupQueue()` or `consumer.assertQueues()`
+  2. Start consuming: `consumer.consumeQueue()`
+- Set `retryConfig` in `setupQueue()` or `assertQueues()` - auto-used when processing
+- `assertExchange()`, `assertQueues()`, `setupQueue()`, and `bindQueue()` are idempotent - safe to call multiple times
 - Use exponential backoff with jitter to prevent thundering herd
 - Always set up error event handlers before consuming
 - Use graceful shutdown in production
@@ -655,9 +746,10 @@ await publisher.deleteQueues('orders', {
 ### Error: PRECONDITION_FAILED - inequivalent arg 'x-dead-letter-exchange'
 
 **Problem:**
+
 ```
-Error: Operation failed: QueueDeclare; 406 (PRECONDITION_FAILED) with message 
-"PRECONDITION_FAILED - inequivalent arg 'x-dead-letter-exchange' for queue 
+Error: Operation failed: QueueDeclare; 406 (PRECONDITION_FAILED) with message
+"PRECONDITION_FAILED - inequivalent arg 'x-dead-letter-exchange' for queue
 'my_queue' in vhost '/': received 'my_exchange' but current is ''"
 ```
 
@@ -668,32 +760,36 @@ The queue already exists in RabbitMQ with different configuration arguments than
 Delete the existing queue and let your code recreate it with the correct configuration.
 
 **Option 1 - Using the utility script:**
+
 ```bash
 npx ts-node scripts/delete-queue.ts my_queue
 ```
 
 **Option 2 - Using RabbitMQ Management UI:**
+
 1. Navigate to `http://localhost:15672` (default credentials: guest/guest)
 2. Go to the "Queues" tab
 3. Find and delete the problematic queue
 
 **Option 3 - Using RabbitMQ CLI:**
+
 ```bash
 rabbitmqadmin delete queue name=my_queue
 ```
 
 **Option 4 - Using this library:**
+
 ```typescript
-import { publisher } from 'rabbitmq-with-retry-and-dlq';
+import { consumer } from 'rabbitmq-with-retry-and-dlq';
 
-await publisher.deleteQueues('my_queue', {
+await consumer.deleteQueues('my_queue', {
   includeRetry: true,
-  includeDLQ: true
+  includeDLQ: true,
 });
 ```
 
 **Prevention:**
-Always use `publisher.assertQueues()` to create queues with the proper retry configuration before publishing or consuming.
+Always use `consumer.setupQueue()` or `consumer.assertQueues()` to create queues with the proper retry configuration before consuming.
 
 ---