@onlineapps/conn-infra-mq 1.1.43 → 1.1.44

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@onlineapps/conn-infra-mq",
-    "version": "1.1.43",
+    "version": "1.1.44",
     "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,24 +365,132 @@ class QueueManager {
         }
       }
       
-      // 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;
+      // CRITICAL: Check if queue exists with different arguments BEFORE assertQueue
+      // If queue exists with wrong args, delete it and create with correct args
+      // This prevents 406 errors and channel closure
+      let queueNeedsRecreation = false;
+      let existingQueueInfo = null;
+      
+      try {
+        // Use checkQueue to get existing queue info (this may close channel on 404, but that's OK)
+        // We use a separate channel for this check to avoid closing the main channel
+        let checkChannel = channel;
+        try {
+          existingQueueInfo = await checkChannel.checkQueue(queueName);
+          console.log(`[QueueManager] DEBUG: Queue ${queueName} exists, checking arguments...`);
+          
+          // Compare existing queue arguments with expected arguments
+          const existingArgs = existingQueueInfo.arguments || {};
+          const expectedArgs = queueOptions.arguments || {};
+          
+          // Check if arguments match (deep comparison of key values)
+          const argsMatch = Object.keys(expectedArgs).every(key => {
+            const existing = existingArgs[key];
+            const expected = expectedArgs[key];
+            
+            // Handle special case: x-dead-letter-routing-key may have placeholder replaced
+            if (key === 'x-dead-letter-routing-key') {
+              const expectedRoutingKey = expected.replace('{service}', serviceName);
+              return existing === expectedRoutingKey || existing === expected;
+            }
+            
+            return existing === expected;
+          }) && Object.keys(existingArgs).length === Object.keys(expectedArgs).length;
+          
+          if (!argsMatch) {
+            console.warn(`[QueueManager] Queue ${queueName} exists with different arguments, will delete and recreate`);
+            console.warn(`[QueueManager] Existing args:`, JSON.stringify(existingArgs));
+            console.warn(`[QueueManager] Expected args:`, JSON.stringify(expectedArgs));
+            queueNeedsRecreation = true;
+          } else {
+            console.log(`[QueueManager] DEBUG: Queue ${queueName} exists with correct arguments`);
+          }
+        } catch (checkErr) {
+          if (checkErr.code === 404) {
+            // Queue doesn't exist - will be created
+            console.log(`[QueueManager] DEBUG: Queue ${queueName} does not exist, will create`);
+            existingQueueInfo = null;
+          } else {
+            // Other error - log but continue (will try assertQueue anyway)
+            console.warn(`[QueueManager] checkQueue failed for ${queueName}:`, checkErr.message);
+            // Channel may be closed, but we'll recreate it before assertQueue
+          }
+        }
+      } catch (checkError) {
+        // If checkQueue fails (e.g., channel closed), continue anyway
+        // assertQueue will handle it
+        console.warn(`[QueueManager] Failed to check queue ${queueName}, will try assertQueue:`, checkError.message);
+      }
+      
+      // If queue exists with wrong args, delete it first
+      if (queueNeedsRecreation && existingQueueInfo) {
+        console.log(`[QueueManager] Deleting queue ${queueName} to recreate with correct arguments...`);
+        try {
+          // Recreate channel if needed (checkQueue may have closed it)
+          if (!channel || channel.closed) {
+            channel = await transport._connection.createChannel();
+            channel._createdAt = new Date().toISOString();
+            channel._closeReason = null;
+            channel._lastOperation = `Recreated before deleteQueue ${queueName}`;
+            
+            channel.on('error', (err) => {
+              console.error('[RabbitMQClient] Recreated queue channel error:', err.message);
+              channel._closeReason = `Error: ${err.message} (code: ${err.code})`;
+            });
+            channel.on('close', () => {
+              console.error('[RabbitMQClient] Recreated queue channel closed');
+              console.error('[RabbitMQClient] Close reason:', channel._closeReason || 'Unknown');
+            });
+            
+            transport._queueChannel = channel;
+          }
+          
+          await channel.deleteQueue(queueName);
+          console.log(`[QueueManager] ✓ Deleted queue ${queueName} for recreation`);
+        } catch (deleteErr) {
+          // If delete fails, log warning but continue - assertQueue will handle it
+          console.warn(`[QueueManager] Failed to delete queue ${queueName}, will try assertQueue anyway:`, deleteErr.message);
+        }
+      }
+      
+      // CRITICAL: Ensure channel is usable before assertQueue
+      // Recreate if closed (may have been closed by checkQueue or deleteQueue)
+      if (!channel || channel.closed) {
+        console.log(`[QueueManager] DEBUG: Channel is closed before assertQueue ${queueName}, recreating...`);
+        channel = await transport._connection.createChannel();
+        channel._createdAt = new Date().toISOString();
+        channel._closeReason = null;
+        channel._lastOperation = `Recreated before assertQueue ${queueName}`;
+        
+        channel.on('error', (err) => {
+          console.error('[RabbitMQClient] Recreated queue channel error:', err.message);
+          channel._closeReason = `Error: ${err.message} (code: ${err.code})`;
+        });
+        channel.on('close', () => {
+          console.error('[RabbitMQClient] Recreated queue channel closed');
+          console.error('[RabbitMQClient] Close reason:', channel._closeReason || 'Unknown');
+        });
+        
+        transport._queueChannel = channel;
+        console.log(`[QueueManager] DEBUG: Channel recreated before assertQueue ${queueName}`);
+      }
       
       // Track operation on channel for debugging
       if (channel && channel._lastOperation !== undefined) {
         channel._lastOperation = `About to assertQueue ${queueName}`;
       }
       
+      let queueCreated = false;
+      
       try {
-        console.log(`[QueueManager] DEBUG: About to assertQueue ${queueName} directly (idempotent)`);
+        console.log(`[QueueManager] DEBUG: About to assertQueue ${queueName} with correct arguments`);
         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: Queue options:`, JSON.stringify(queueOptions));
         
         // 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)
+        // If queue exists with different params → 406, channel closes (should not happen now, but handle it)
         await channel.assertQueue(queueName, queueOptions);
         
         // Queue created or already exists with same params
@@ -397,37 +505,59 @@ class QueueManager {
         console.log(`[QueueManager] DEBUG: assertQueue failed for ${queueName}:`, assertErr.message);
         console.log(`[QueueManager] DEBUG: Error code: ${assertErr.code}`);
         
-        // 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 406 PRECONDITION-FAILED, this should not happen if we deleted the queue
+        // But handle it anyway - queue exists with different args
         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}`);
+          console.error(`[QueueManager] ERROR: Queue ${queueName} still has different arguments after deletion attempt!`);
+          console.error(`[QueueManager] This should not happen - queue may have been recreated by another process`);
           
-          // Channel is closed, but we need to recreate it for next queue
-          // Don't throw error - queue exists, we just need new channel
+          // Try to delete and recreate one more time
           try {
-            const newChannel = await transport._connection.createChannel();
-            newChannel._createdAt = new Date().toISOString();
-            newChannel._closeReason = null;
-            newChannel._lastOperation = `Recreated after 406 for ${queueName}`;
+            // Recreate channel (closed by 406)
+            channel = await transport._connection.createChannel();
+            channel._createdAt = new Date().toISOString();
+            channel._closeReason = null;
+            channel._lastOperation = `Recreated after 406 for ${queueName}`;
             
-            newChannel.on('error', (err) => {
+            channel.on('error', (err) => {
               console.error('[RabbitMQClient] Recreated queue channel error:', err.message);
-              newChannel._closeReason = `Error: ${err.message} (code: ${err.code})`;
+              channel._closeReason = `Error: ${err.message} (code: ${err.code})`;
             });
-            newChannel.on('close', () => {
+            channel.on('close', () => {
               console.error('[RabbitMQClient] Recreated queue channel closed');
-              console.error('[RabbitMQClient] Close reason:', newChannel._closeReason || 'Unknown');
+              console.error('[RabbitMQClient] Close reason:', channel._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);
+            
+            // Delete queue
+            await channel.deleteQueue(queueName);
+            console.log(`[QueueManager] ✓ Deleted queue ${queueName} after 406 error`);
+            
+            // Recreate channel again (deleteQueue may close it)
+            channel = await transport._connection.createChannel();
+            channel._createdAt = new Date().toISOString();
+            channel._closeReason = null;
+            channel._lastOperation = `Recreated after deleteQueue ${queueName}`;
+            
+            channel.on('error', (err) => {
+              console.error('[RabbitMQClient] Recreated queue channel error:', err.message);
+              channel._closeReason = `Error: ${err.message} (code: ${err.code})`;
+            });
+            channel.on('close', () => {
+              console.error('[RabbitMQClient] Recreated queue channel closed');
+              console.error('[RabbitMQClient] Close reason:', channel._closeReason || 'Unknown');
+            });
+            
+            transport._queueChannel = channel;
+            
+            // Try assertQueue again
+            await channel.assertQueue(queueName, queueOptions);
+            console.log(`[QueueManager] ✓ Recreated queue ${queueName} with correct arguments`);
+            queues[queueInfo.type] = queueName;
+            queueCreated = true;
+          } catch (retryErr) {
+            throw new Error(`Failed to recreate queue ${queueName} after 406 error: ${retryErr.message}`);
           }
         } else {
           // Other error - critical, cannot continue