@onlineapps/conn-infra-mq 1.1.15 → 1.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@onlineapps/conn-infra-mq",
-    "version": "1.1.15",
+    "version": "1.1.17",
     "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;
+        }
       }
     }
   }
@@ -188,7 +200,8 @@ class QueueManager {
     if (!transport || !transport.channel) {
       throw new Error('MQ client not connected');
     }
-    const channel = transport.channel;
+    // Use queueChannel for queue operations to avoid RPC reply queue issues
+    const channel = transport.queueChannel || transport.channel;
 
     const queues = {};
 
@@ -302,7 +315,8 @@ class QueueManager {
     if (!transport || !transport.channel) {
       throw new Error('MQ client not connected');
     }
-    const channel = transport.channel;
+    // Use queueChannel for queue operations
+    const channel = transport.queueChannel || transport.channel;
 
     this.managedQueues.delete(queueName);
     return channel.deleteQueue(queueName, options);
@@ -354,7 +368,8 @@ class QueueManager {
     if (!transport || !transport.channel) {
       throw new Error('MQ client not connected');
     }
-    const channel = transport.channel;
+    // Exchange operations can use queueChannel (regular channel) - no RPC issues
+    const channel = transport.queueChannel || transport.channel;
 
     return channel.assertExchange(exchangeName, type, {
       durable: options.durable !== false,
@@ -373,7 +388,8 @@ class QueueManager {
     if (!transport || !transport.channel) {
       throw new Error('MQ client not connected');
     }
-    const channel = transport.channel;
+    // Bind operations can use queueChannel (regular channel) - no RPC issues
+    const channel = transport.queueChannel || transport.channel;
 
     return channel.bindQueue(queue, exchange, routingKey);
   }

package/src/transports/rabbitmqClient.js

@@ -38,10 +38,19 @@ class RabbitMQClient extends EventEmitter {
 
   /**
    * Getter for channel - provides compatibility with QueueManager
+   * Returns ConfirmChannel for publish operations
    */
   get channel() {
     return this._channel;
   }
+  
+  /**
+   * Getter for queue channel - regular channel for queue operations
+   * Use this for assertQueue, checkQueue to avoid RPC reply queue issues
+   */
+  get queueChannel() {
+    return this._queueChannel || this._channel; // Fallback to main channel if queueChannel not available
+  }
 
   /**
    * Connects to RabbitMQ server and creates a confirm channel.
@@ -95,6 +104,15 @@ class RabbitMQClient extends EventEmitter {
    * @returns {Promise<void>}
    */
   async disconnect() {
+    try {
+      if (this._queueChannel) {
+        await this._queueChannel.close();
+        this._queueChannel = null;
+      }
+    } catch (err) {
+      // Log but don't emit - queue channel errors are less critical
+      console.warn('[RabbitMQClient] Error closing queue channel:', err.message);
+    }
     try {
       if (this._channel) {
         await this._channel.close();
@@ -134,9 +152,22 @@ class RabbitMQClient extends EventEmitter {
     try {
       // Ensure queue exists if publishing directly to queue and using default exchange
       if (!exchange) {
+        // Use queueChannel (regular channel) for queue operations to avoid RPC reply queue issues
         // Use central config for infrastructure queues
         const queueOptions = this._getQueueOptions(queue);
-        await this._channel.assertQueue(queue, queueOptions);
+        try {
+          await this._queueChannel.checkQueue(queue);
+          // Queue exists - proceed to publish
+        } catch (checkErr) {
+          // If queue doesn't exist (404), create it
+          if (checkErr.code === 404) {
+            await this._queueChannel.assertQueue(queue, queueOptions);
+          } else {
+            // Other error (including 406) - queue exists with different args, proceed
+            console.warn(`[RabbitMQClient] Queue ${queue} exists with different arguments, using as-is`);
+          }
+        }
+        // Publish using ConfirmChannel (for publisher confirms)
         this._channel.sendToQueue(queue, buffer, { persistent, headers, routingKey });
       } else {
         // If exchange is specified, assert exchange and publish to it
@@ -177,9 +208,10 @@ class RabbitMQClient extends EventEmitter {
         
         if (isInfraQueue) {
           // Infrastructure queue - should already exist, created by infrastructure initialization
+          // Use queueChannel (regular channel) for queue operations to avoid RPC reply queue issues
           // Only check if it exists, don't try to create or assert with arguments
           try {
-            await this._channel.checkQueue(queue);
+            await this._queueChannel.checkQueue(queue);
             // Queue exists - proceed to consume
           } catch (checkErr) {
             if (checkErr.code === 404) {
@@ -191,13 +223,14 @@ class RabbitMQClient extends EventEmitter {
           }
         } else {
           // Business queue - may need to be created, but use unified config
+          // Use queueChannel (regular channel) for queue operations to avoid RPC reply queue issues
           const queueOptions = this._getQueueOptions(queue, { durable });
           
           // Try to assert queue with our config
           // If it fails with 406 (PRECONDITION-FAILED), queue exists with different args - use it as-is
           // IMPORTANT: Don't try to re-assert after 406, as it will close the channel
           try {
-            await this._channel.assertQueue(queue, queueOptions);
+            await this._queueChannel.assertQueue(queue, queueOptions);
           } catch (assertErr) {
             // If queue exists with different arguments (406), use it as-is without re-asserting
             if (assertErr.code === 406) {