@onlineapps/conn-infra-mq 1.1.44 → 1.1.46

package/package.json

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

package/src/layers/QueueManager.js

@@ -36,6 +36,14 @@ class QueueManager {
     if (!transport || !transport.channel) {
       throw new Error('MQ client not connected');
     }
+    
+    // CRITICAL: Business queues MUST be created via setupServiceQueues() AFTER registration
+    // Business queues should NOT be created via ensureQueue() before registration
+    // This prevents queues from being created with wrong arguments or before service is registered
+    if (queueConfig.isBusinessQueue(queueName)) {
+      throw new Error(`Business queue ${queueName} must be created via setupServiceQueues() after successful registration. Do not use ensureQueue() for business queues.`);
+    }
+    
     // Use queueChannel for queue operations to avoid RPC reply queue issues
     // queueChannel is a regular channel, not ConfirmChannel
     const channel = transport.queueChannel || transport.channel;
@@ -55,25 +63,6 @@ class QueueManager {
         console.warn(`[QueueManager] Infrastructure queue config not found for ${queueName}, using provided options:`, error.message);
         queueOptions = this._buildQueueOptions(queueName, options);
       }
-    } else if (queueConfig.isBusinessQueue(queueName)) {
-      // Business queue - use central business queue config
-      try {
-        const parsed = queueConfig.parseBusinessQueue(queueName);
-        if (parsed) {
-          const businessConfig = queueConfig.getBusinessQueueConfig(parsed.queueType, parsed.serviceName);
-          queueOptions = {
-            durable: businessConfig.durable !== false,
-            arguments: { ...businessConfig.arguments }
-          };
-        } else {
-          // Fallback to provided options
-          queueOptions = this._buildQueueOptions(queueName, options);
-        }
-      } catch (error) {
-        // If config not found, fall back to provided options
-        console.warn(`[QueueManager] Business queue config not found for ${queueName}, using provided options:`, error.message);
-        queueOptions = this._buildQueueOptions(queueName, options);
-      }
     } else {
       // Unknown queue type - use provided options
       queueOptions = this._buildQueueOptions(queueName, options);
@@ -365,96 +354,8 @@ class QueueManager {
         }
       }
       
-      // 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)
+      // Recreate if closed (may have been closed by previous operations)
       if (!channel || channel.closed) {
         console.log(`[QueueManager] DEBUG: Channel is closed before assertQueue ${queueName}, recreating...`);
         channel = await transport._connection.createChannel();
@@ -505,13 +406,13 @@ class QueueManager {
         console.log(`[QueueManager] DEBUG: assertQueue failed for ${queueName}:`, assertErr.message);
         console.log(`[QueueManager] DEBUG: Error code: ${assertErr.code}`);
         
-        // If 406 PRECONDITION-FAILED, this should not happen if we deleted the queue
-        // But handle it anyway - queue exists with different args
+        // If 406 PRECONDITION-FAILED, queue exists with different args
+        // Delete it and recreate with correct args
         if (assertErr.code === 406) {
-          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`);
+          console.warn(`[QueueManager] Queue ${queueName} exists with different arguments (406), deleting and recreating...`);
+          console.warn(`[QueueManager] Expected args:`, JSON.stringify(queueOptions.arguments));
           
-          // Try to delete and recreate one more time
+          // Delete queue and recreate with correct args
           try {
             // Recreate channel (closed by 406)
             channel = await transport._connection.createChannel();