@onlineapps/conn-infra-mq 1.1.30 → 1.1.32

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@onlineapps/conn-infra-mq",
-    "version": "1.1.30",
+    "version": "1.1.32",
     "description": "A promise-based, broker-agnostic client for sending and receiving messages via RabbitMQ",
     "main": "src/index.js",
     "repository": {

package/src/layers/QueueManager.js

@@ -294,45 +294,69 @@ class QueueManager {
       }
       
       // CRITICAL: Use assertQueue directly - if queue exists with different args (406), that's OK
-      // We'll handle it gracefully, but channel should NOT close
+      // BUT: 406 PRECONDITION-FAILED closes the channel in amqplib!
+      // Solution: Catch 406, recreate channel immediately, and continue
+      let queueCreated = false;
       try {
-        // Check if channel is still open before each operation
-        if (!channel || channel.closed) {
-          console.error(`[QueueManager] DEBUG: Channel closed before creating ${queueName}`);
-          throw new Error(`Channel closed before creating ${queueName} - cannot continue`);
-        }
-        
         console.log(`[QueueManager] DEBUG: About to assertQueue ${queueName} with options:`, JSON.stringify(queueOptions, null, 2));
-        console.log(`[QueueManager] DEBUG: Channel state before assertQueue: closed=${channel.closed}`);
         
         await channel.assertQueue(queueName, queueOptions);
         
-        console.log(`[QueueManager] DEBUG: assertQueue succeeded for ${queueName}, channel closed=${channel.closed}`);
+        console.log(`[QueueManager] DEBUG: assertQueue succeeded for ${queueName}`);
         queues[queueInfo.type] = queueName;
+        queueCreated = true;
         console.info(`[QueueManager] ✓ Created business queue: ${queueName}`);
       } catch (assertErr) {
         console.error(`[QueueManager] DEBUG: assertQueue failed for ${queueName}:`, assertErr.message);
-        console.error(`[QueueManager] DEBUG: Error code: ${assertErr.code}, channel closed: ${channel ? channel.closed : 'N/A'}`);
-        console.error(`[QueueManager] DEBUG: Stack trace:`, assertErr.stack);
+        console.error(`[QueueManager] DEBUG: Error code: ${assertErr.code}`);
         
-        // If channel closed, this is a critical error
-        if (!channel || channel.closed) {
-          console.error(`[QueueManager] DEBUG: Channel was closed during assertQueue for ${queueName}`);
-          throw new Error(`Channel closed during assertQueue for ${queueName} - cannot create remaining queues`);
-        }
-        
-        // If 406 PRECONDITION-FAILED, queue exists with different args - use it as-is
-        // CRITICAL: Do NOT use checkQueue() here - it closes channel on 404!
-        // If assertQueue() returned 406, queue exists (just with different args) - that's OK
+        // If 406 PRECONDITION-FAILED, queue exists with different args - channel is closed, recreate it IMMEDIATELY
+        // CRITICAL: amqplib closes channel on 406, so we MUST recreate it to continue
         if (assertErr.code === 406) {
-          console.warn(`[QueueManager] Queue ${queueName} exists with different arguments, using as-is:`, assertErr.message);
+          console.warn(`[QueueManager] Queue ${queueName} exists with different arguments (406), channel will be closed. Recreating channel...`);
+          
+          // Recreate channel IMMEDIATELY - 406 closes it synchronously
+          try {
+            // Wait a tiny bit for channel close event to propagate
+            await new Promise(resolve => setImmediate(resolve));
+            channel = await transport._connection.createChannel();
+            transport.queueChannel = channel;
+            console.log(`[QueueManager] DEBUG: Channel recreated after 406 for ${queueName}`);
+          } catch (recreateErr) {
+            throw new Error(`Failed to recreate channel after 406 for ${queueName}: ${recreateErr.message}`);
+          }
+          
           // Queue exists (just with different args) - accept it
           queues[queueInfo.type] = queueName;
+          queueCreated = true;
         } else {
-          // Other error - critical, cannot continue
-          throw new Error(`Failed to create business queue ${queueName}: ${assertErr.message}`);
+          // Other error - check if it's a channel closed error
+          if (assertErr.message && assertErr.message.includes('Channel closed')) {
+            console.error(`[QueueManager] DEBUG: Channel was closed during assertQueue for ${queueName}, recreating...`);
+            // Try to recreate channel
+            try {
+              await new Promise(resolve => setImmediate(resolve));
+              channel = await transport._connection.createChannel();
+              transport.queueChannel = channel;
+              console.log(`[QueueManager] DEBUG: Channel recreated after channel closed error for ${queueName}`);
+            } catch (recreateErr) {
+              throw new Error(`Channel closed during assertQueue for ${queueName} and failed to recreate: ${recreateErr.message}`);
+            }
+            // Retry assertQueue with new channel (but only if it's not 406)
+            if (assertErr.code !== 406) {
+              throw new Error(`Failed to create business queue ${queueName}: ${assertErr.message}`);
+            }
+          } else {
+            // Other error - critical, cannot continue
+            throw new Error(`Failed to create business queue ${queueName}: ${assertErr.message}`);
+          }
         }
       }
+      
+      // Verify queue was created/confirmed
+      if (!queueCreated) {
+        throw new Error(`Failed to create or confirm business queue ${queueName}`);
+      }
     }
 
     // Setup DLQ exchange and bindings