@onlineapps/conn-infra-mq 1.1.16 → 1.1.18

package/package.json

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

package/src/layers/QueueManager.js

@@ -82,43 +82,55 @@ class QueueManager {
     // Track managed queue
     this.managedQueues.add(queueName);
 
-    // Use checkQueue first to avoid 406 PRECONDITION-FAILED closing the channel
-    // If queue doesn't exist (404), then assertQueue to create it
     // IMPORTANT: Check if channel is still open before operations
     if (!channel || channel.closed) {
       throw new Error('Channel is closed - cannot ensure queue');
     }
     
+    // CRITICAL: amqplib's assertQueue() uses RPC pattern even on regular channels
+    // This causes channel closure if reply queue doesn't exist
+    // Solution: Use checkQueue to verify existence, and if queue doesn't exist,
+    // it will be created automatically on first sendToQueue() with passive: false
+    // For now, we'll use checkQueue and let the queue be created lazily on first publish
+    
     try {
       const queueInfo = await channel.checkQueue(queueName);
       // Queue exists - return queue info
       return queueInfo;
     } catch (checkErr) {
-      // Check if channel is still open before assertQueue
+      // Check if channel is still open
       if (!channel || channel.closed) {
-        throw new Error('Channel closed during checkQueue - cannot create queue');
+        throw new Error('Channel closed during checkQueue - cannot verify queue');
       }
       
-      // If queue doesn't exist (404), create it with provided options
+      // If queue doesn't exist (404), we'll let it be created lazily on first publish
+      // This avoids RPC reply queue issues with assertQueue()
       if (checkErr.code === 404) {
-        try {
-          return await channel.assertQueue(queueName, queueOptions);
-        } catch (assertErr) {
-          // If channel closed during assertQueue, throw descriptive error
-          if (!channel || channel.closed) {
-            throw new Error(`Channel closed during assertQueue for ${queueName} - likely due to RPC reply queue issue`);
-          }
-          throw assertErr;
-        }
+        // Queue doesn't exist - will be created on first sendToQueue()
+        // Return a mock queue info to indicate queue will be created lazily
+        console.info(`[QueueManager] Queue ${queueName} doesn't exist - will be created on first publish`);
+        return {
+          queue: queueName,
+          messageCount: 0,
+          consumerCount: 0
+        };
       } else {
         // Other error (including 406) - queue exists with different args
         // Log warning and return queue info without asserting
         console.warn(`[QueueManager] Queue ${queueName} exists with different arguments, using as-is:`, checkErr.message);
-        // Check channel again before checkQueue
+        // Try checkQueue again to get queue info (if channel still open)
         if (!channel || channel.closed) {
           throw new Error('Channel closed - cannot check queue');
         }
-        return channel.checkQueue(queueName);
+        try {
+          return await channel.checkQueue(queueName);
+        } catch (retryErr) {
+          // If channel closed, throw descriptive error
+          if (!channel || channel.closed) {
+            throw new Error('Channel closed during checkQueue retry - RPC reply queue issue detected');
+          }
+          throw retryErr;
+        }
       }
     }
   }
@@ -280,17 +292,46 @@ class QueueManager {
    * @param {Object} options - Queue options
    */
   async createTemporaryQueue(prefix = 'temp', options = {}) {
+    const transport = this.client._transport;
+    if (!transport || !transport.channel) {
+      throw new Error('MQ client not connected');
+    }
+    // Use queueChannel for queue operations
+    const channel = transport.queueChannel || transport.channel;
+
     const queueName = `${prefix}.${Date.now()}.${Math.random().toString(36).substr(2, 9)}`;
 
-    await this.ensureQueue(queueName, {
+    // For temporary queues (rpc.reply.*), we MUST create them explicitly
+    // because they are used immediately for consuming replies
+    // Use assertQueue directly on queueChannel to avoid RPC reply queue issues
+    const queueOptions = {
       durable: false,
+      exclusive: options.exclusive !== false, // Default to exclusive for temporary queues
       autoDelete: true,
-      expires: options.expires || 60000, // 1 minute default
-      exclusive: options.exclusive || false,
-      ...options
-    });
+      arguments: {}
+    };
+
+    // Add expires if specified
+    if (options.expires) {
+      queueOptions.arguments['x-expires'] = options.expires;
+    }
 
-    return queueName;
+    // Check if channel is open before assertQueue
+    if (!channel || channel.closed) {
+      throw new Error('Channel is closed - cannot create temporary queue');
+    }
+
+    try {
+      await channel.assertQueue(queueName, queueOptions);
+      this.managedQueues.add(queueName);
+      return queueName;
+    } catch (assertErr) {
+      // If channel closed during assertQueue, throw descriptive error
+      if (!channel || channel.closed) {
+        throw new Error(`Channel closed during assertQueue for temporary queue ${queueName} - RPC reply queue issue detected`);
+      }
+      throw assertErr;
+    }
   }
 
   /**