@onlineapps/conn-infra-mq 1.1.37 → 1.1.39

package/package.json

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

package/src/layers/QueueManager.js

@@ -266,7 +266,7 @@ class QueueManager {
           console.error('[RabbitMQClient] Close reason:', channel._closeReason || 'Unknown');
         });
         
-        transport.queueChannel = channel;
+        transport._queueChannel = channel;
         console.log(`[QueueManager] DEBUG: Channel recreated (was null) before ${queueInfo.name}`);
       } else {
         // Check if channel is closed - amqplib may not set closed property immediately
@@ -305,7 +305,7 @@ class QueueManager {
             });
             
             channel = newChannel;
-            transport.queueChannel = channel;
+            transport._queueChannel = channel;
             console.log(`[QueueManager] DEBUG: Channel recreated (check failed) before ${queueInfo.name}`);
             channelUsable = true;
           } catch (recreateErr) {
@@ -365,110 +365,94 @@ class QueueManager {
         }
       }
       
-      // CRITICAL: Use assertQueue directly - if queue exists with different args (406), that's OK
-      // BUT: 406 PRECONDITION-FAILED closes the channel in amqplib!
-      // Solution: Track channel state, catch 406, recreate channel immediately, and continue
+      // CRITICAL: Use the SAME pattern as ensureQueue() - checkQueue() FIRST, then assertQueue() only if 404
+      // This prevents channel closure on 406 PRECONDITION-FAILED
+      // Pattern: checkQueue() -> if 404, assertQueue() -> if 406, use existing queue (channel stays open)
       let queueCreated = false;
       
-      // CRITICAL: Track operation on channel for debugging
+      // Track operation on channel for debugging
       if (channel && channel._lastOperation !== undefined) {
-        channel._lastOperation = `About to assertQueue ${queueName}`;
+        channel._lastOperation = `About to checkQueue ${queueName}`;
       }
       
       try {
-        console.log(`[QueueManager] DEBUG: About to assertQueue ${queueName}`);
+        console.log(`[QueueManager] DEBUG: About to checkQueue ${queueName} (same pattern as ensureQueue)`);
         console.log(`[QueueManager] DEBUG: Channel state: exists=${!!channel}, closed=${channel ? (channel.closed === true ? 'true' : channel.closed === false ? 'false' : 'undefined') : 'N/A'}`);
-        console.log(`[QueueManager] DEBUG: Channel created at: ${channel?._createdAt || 'N/A'}`);
-        console.log(`[QueueManager] DEBUG: Queue options:`, JSON.stringify(queueOptions, null, 2));
         
-        await channel.assertQueue(queueName, queueOptions);
+        // CRITICAL: Use checkQueue() FIRST (same as ensureQueue() pattern)
+        // This prevents channel closure on 406 - if queue exists with different args, checkQueue() returns 406 but channel stays open
+        await channel.checkQueue(queueName);
         
-        console.log(`[QueueManager] DEBUG: assertQueue succeeded for ${queueName}`);
+        // Queue exists - use it
+        console.log(`[QueueManager] DEBUG: checkQueue succeeded - queue ${queueName} exists`);
         if (channel && channel._lastOperation !== undefined) {
-          channel._lastOperation = `assertQueue ${queueName} succeeded`;
+          channel._lastOperation = `checkQueue ${queueName} succeeded`;
         }
         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}`);
-        console.error(`[QueueManager] DEBUG: Channel state after error: exists=${!!channel}, closed=${channel ? (channel.closed === true ? 'true' : channel.closed === false ? 'false' : 'undefined') : 'N/A'}`);
-        console.error(`[QueueManager] DEBUG: Channel close reason: ${channel?._closeReason || 'N/A'}`);
+        console.info(`[QueueManager] ✓ Business queue exists: ${queueName}`);
+      } catch (checkErr) {
+        console.log(`[QueueManager] DEBUG: checkQueue failed for ${queueName}:`, checkErr.message);
+        console.log(`[QueueManager] DEBUG: Error code: ${checkErr.code}`);
         
-        // If 406 PRECONDITION-FAILED, queue exists with different args - channel is closed, recreate it IMMEDIATELY
-        // CRITICAL: amqplib closes channel on 406 SYNCHRONOUSLY, so we MUST recreate it to continue
-        if (assertErr.code === 406) {
-          console.warn(`[QueueManager] Queue ${queueName} exists with different arguments (406), channel WILL BE CLOSED. Recreating channel IMMEDIATELY...`);
+        // Check if channel is still open
+        if (!channel || channel.closed) {
+          throw new Error('Channel closed during checkQueue - cannot verify queue');
+        }
+        
+        // If queue doesn't exist (404), create it using assertQueue
+        if (checkErr.code === 404) {
+          console.log(`[QueueManager] DEBUG: Queue ${queueName} doesn't exist (404), creating with assertQueue...`);
           
-          // CRITICAL: Channel is already closed by amqplib at this point
-          // We MUST create a new channel before continuing
-          try {
-            // Wait a tiny bit for channel close event to propagate
-            await new Promise(resolve => setImmediate(resolve));
-            
-            // Create new channel
-            const newChannel = await transport._connection.createChannel();
-            newChannel._createdAt = new Date().toISOString();
-            newChannel._closeReason = null;
-            newChannel._lastOperation = `Recreated after 406 for ${queueName}`;
-            
-            // Set up error/close handlers for new channel
-            newChannel.on('error', (err) => {
-              console.error('[RabbitMQClient] New queue channel error:', err.message);
-              newChannel._closeReason = `Error: ${err.message} (code: ${err.code})`;
-            });
-            newChannel.on('close', () => {
-              console.error('[RabbitMQClient] New queue channel closed');
-              console.error('[RabbitMQClient] Close reason:', newChannel._closeReason || 'Unknown');
-            });
-            
-            // Update references
-            channel = newChannel;
-            transport.queueChannel = channel;
-            
-            console.log(`[QueueManager] DEBUG: Channel recreated after 406 for ${queueName}`);
-            console.log(`[QueueManager] DEBUG: New channel created at: ${channel._createdAt}`);
-          } catch (recreateErr) {
-            console.error(`[QueueManager] DEBUG: Failed to recreate channel after 406:`, recreateErr.message);
-            throw new Error(`Failed to recreate channel after 406 for ${queueName}: ${recreateErr.message}`);
+          if (channel && channel._lastOperation !== undefined) {
+            channel._lastOperation = `About to assertQueue ${queueName} (queue doesn't exist)`;
           }
           
-          // Queue exists (just with different args) - accept it
-          queues[queueInfo.type] = queueName;
-          queueCreated = true;
-        } else if (assertErr.message && assertErr.message.includes('Channel closed')) {
-          // Channel closed error (not 406) - recreate channel
-          console.error(`[QueueManager] DEBUG: Channel was closed during assertQueue for ${queueName} (not 406), recreating...`);
           try {
-            await new Promise(resolve => setImmediate(resolve));
-            
-            const newChannel = await transport._connection.createChannel();
-            newChannel._createdAt = new Date().toISOString();
-            newChannel._closeReason = null;
-            newChannel._lastOperation = `Recreated after channel closed error for ${queueName}`;
-            
-            newChannel.on('error', (err) => {
-              console.error('[RabbitMQClient] New queue channel error:', err.message);
-              newChannel._closeReason = `Error: ${err.message} (code: ${err.code})`;
-            });
-            newChannel.on('close', () => {
-              console.error('[RabbitMQClient] New queue channel closed');
-              console.error('[RabbitMQClient] Close reason:', newChannel._closeReason || 'Unknown');
-            });
-            
-            channel = newChannel;
-            transport.queueChannel = channel;
+            await channel.assertQueue(queueName, queueOptions);
+            console.log(`[QueueManager] DEBUG: assertQueue succeeded for ${queueName}`);
+            if (channel && channel._lastOperation !== undefined) {
+              channel._lastOperation = `assertQueue ${queueName} succeeded`;
+            }
+            queues[queueInfo.type] = queueName;
+            queueCreated = true;
+            console.info(`[QueueManager] ✓ Created business queue: ${queueName}`);
+          } catch (assertErr) {
+            // If channel closed during assertQueue, it's a real error
+            if (!channel || channel.closed) {
+              throw new Error(`Channel closed during assertQueue for ${queueName} - check channel management`);
+            }
             
-            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}`);
+            // If 406 PRECONDITION-FAILED, queue exists with different args (race condition?)
+            if (assertErr.code === 406) {
+              console.warn(`[QueueManager] Queue ${queueName} exists with different arguments (406 from assertQueue):`, assertErr.message);
+              // Channel should still be open - try checkQueue to verify
+              if (!channel || channel.closed) {
+                throw new Error('Channel closed - cannot check existing queue');
+              }
+              try {
+                await channel.checkQueue(queueName);
+                queues[queueInfo.type] = queueName;
+                queueCreated = true;
+                console.info(`[QueueManager] ✓ Business queue exists (verified): ${queueName}`);
+              } catch (verifyErr) {
+                throw new Error(`Failed to verify existing queue ${queueName}: ${verifyErr.message}`);
+              }
+            } else {
+              // Other errors - rethrow
+              throw assertErr;
+            }
           }
-          // Don't set queueCreated - this is a real error, not a 406
-          throw new Error(`Failed to create business queue ${queueName}: ${assertErr.message}`);
+        } else if (checkErr.code === 406) {
+          // Queue exists with different args (406 from checkQueue) - use it as-is
+          // CRITICAL: checkQueue() on 406 does NOT close channel (unlike assertQueue() on 406)
+          console.warn(`[QueueManager] Queue ${queueName} exists with different arguments (406 from checkQueue), using as-is:`, checkErr.message);
+          queues[queueInfo.type] = queueName;
+          queueCreated = true;
+          console.info(`[QueueManager] ✓ Business queue exists (different args): ${queueName}`);
         } else {
-          // Other error - critical, cannot continue
-          throw new Error(`Failed to create business queue ${queueName}: ${assertErr.message}`);
+          // Other error - rethrow
+          throw checkErr;
         }
       }