@onlineapps/conn-infra-mq 1.1.40 → 1.1.41

package/package.json

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

package/src/layers/QueueManager.js

@@ -365,121 +365,73 @@ class QueueManager {
         }
       }
       
-      // 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)
+      // CRITICAL: Use assertQueue() DIRECTLY - it's idempotent and safer than checkQueue() + assertQueue()
+      // assertQueue() creates queue if it doesn't exist, or does nothing if it exists with same params
+      // If queue exists with different params (406), channel closes but that's OK - we accept the queue
       let queueCreated = false;
       
       // Track operation on channel for debugging
       if (channel && channel._lastOperation !== undefined) {
-        channel._lastOperation = `About to checkQueue ${queueName}`;
+        channel._lastOperation = `About to assertQueue ${queueName}`;
       }
       
       try {
-        console.log(`[QueueManager] DEBUG: About to checkQueue ${queueName} (same pattern as ensureQueue)`);
+        console.log(`[QueueManager] DEBUG: About to assertQueue ${queueName} directly (idempotent)`);
         console.log(`[QueueManager] DEBUG: Channel state: exists=${!!channel}, closed=${channel ? (channel.closed === true ? 'true' : channel.closed === false ? 'false' : 'undefined') : 'N/A'}`);
         
-        // 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);
+        // CRITICAL: Use assertQueue() DIRECTLY - it's idempotent
+        // If queue doesn't exist → creates it
+        // If queue exists with same params → does nothing (OK)
+        // If queue exists with different params → 406, channel closes (but we accept the queue)
+        await channel.assertQueue(queueName, queueOptions);
         
-        // Queue exists - use it
-        console.log(`[QueueManager] DEBUG: checkQueue succeeded - queue ${queueName} exists`);
+        // Queue created or already exists with same params
+        console.log(`[QueueManager] DEBUG: assertQueue succeeded for ${queueName}`);
         if (channel && channel._lastOperation !== undefined) {
-          channel._lastOperation = `checkQueue ${queueName} succeeded`;
+          channel._lastOperation = `assertQueue ${queueName} succeeded`;
         }
         queues[queueInfo.type] = queueName;
         queueCreated = true;
-        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}`);
+        console.info(`[QueueManager] ✓ Created/verified business queue: ${queueName}`);
+      } catch (assertErr) {
+        console.log(`[QueueManager] DEBUG: assertQueue failed for ${queueName}:`, assertErr.message);
+        console.log(`[QueueManager] DEBUG: Error code: ${assertErr.code}`);
         
-        // 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
-        // CRITICAL: checkQueue() on 404 may close channel in amqplib, so we must check and recreate if needed
-        if (checkErr.code === 404) {
-          console.log(`[QueueManager] DEBUG: Queue ${queueName} doesn't exist (404), creating with assertQueue...`);
-          
-          // CRITICAL: checkQueue() on 404 may close channel - check and recreate if needed
-          if (!channel || channel.closed) {
-            console.warn(`[QueueManager] DEBUG: Channel closed after checkQueue(404) for ${queueName}, recreating...`);
-            try {
-              const newChannel = await transport._connection.createChannel();
-              newChannel._createdAt = new Date().toISOString();
-              newChannel._closeReason = null;
-              newChannel._lastOperation = `Recreated after checkQueue(404) for ${queueName}`;
-              
-              newChannel.on('error', (err) => {
-                console.error('[RabbitMQClient] Recreated queue channel error:', err.message);
-                newChannel._closeReason = `Error: ${err.message} (code: ${err.code})`;
-              });
-              newChannel.on('close', () => {
-                console.error('[RabbitMQClient] Recreated queue channel closed');
-                console.error('[RabbitMQClient] Close reason:', newChannel._closeReason || 'Unknown');
-              });
-              
-              channel = newChannel;
-              transport._queueChannel = channel;
-              console.log(`[QueueManager] DEBUG: Channel recreated after checkQueue(404) for ${queueName}`);
-            } catch (recreateErr) {
-              throw new Error(`Channel closed after checkQueue(404) for ${queueName} and failed to recreate: ${recreateErr.message}`);
-            }
-          }
-          
-          if (channel && channel._lastOperation !== undefined) {
-            channel._lastOperation = `About to assertQueue ${queueName} (queue doesn't exist)`;
-          }
+        // If 406 PRECONDITION-FAILED, queue exists with different args - accept it
+        // Channel is closed by server, but that's OK - queue exists and we can use it
+        if (assertErr.code === 406) {
+          console.warn(`[QueueManager] Queue ${queueName} exists with different arguments (406), accepting as-is:`, assertErr.message);
+          queues[queueInfo.type] = queueName;
+          queueCreated = true;
+          console.info(`[QueueManager] ✓ Business queue exists (different args, accepted): ${queueName}`);
           
+          // Channel is closed, but we need to recreate it for next queue
+          // Don't throw error - queue exists, we just need new channel
           try {
-            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`);
-            }
+            const newChannel = await transport._connection.createChannel();
+            newChannel._createdAt = new Date().toISOString();
+            newChannel._closeReason = null;
+            newChannel._lastOperation = `Recreated after 406 for ${queueName}`;
             
-            // 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;
-            }
+            newChannel.on('error', (err) => {
+              console.error('[RabbitMQClient] Recreated queue channel error:', err.message);
+              newChannel._closeReason = `Error: ${err.message} (code: ${err.code})`;
+            });
+            newChannel.on('close', () => {
+              console.error('[RabbitMQClient] Recreated queue channel closed');
+              console.error('[RabbitMQClient] Close reason:', newChannel._closeReason || 'Unknown');
+            });
+            
+            channel = newChannel;
+            transport._queueChannel = channel;
+            console.log(`[QueueManager] DEBUG: Channel recreated after 406 for ${queueName}`);
+          } catch (recreateErr) {
+            // Even if channel recreation fails, queue exists - log warning but continue
+            console.warn(`[QueueManager] Failed to recreate channel after 406 for ${queueName}, but queue exists:`, recreateErr.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 - rethrow
-          throw checkErr;
+          // Other error - critical, cannot continue
+          throw new Error(`Failed to create business queue ${queueName}: ${assertErr.message}`);
         }
       }