@onlineapps/conn-infra-mq 1.1.41 → 1.1.43

package/package.json

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

package/src/transports/rabbitmqClient.js

@@ -114,6 +114,40 @@ class RabbitMQClient extends EventEmitter {
     }
   }
 
+  /**
+   * Recreates the publish channel if it's closed.
+   * Used when channel closes unexpectedly (e.g., due to 406 errors).
+   * @private
+   * @returns {Promise<void>}
+   * @throws {Error} If connection is not available or channel recreation fails.
+   */
+  async _recreateChannel() {
+    if (!this._connection) {
+      throw new Error('Cannot recreate channel: connection is not available');
+    }
+
+    try {
+      // Close old channel if it exists
+      if (this._channel) {
+        try {
+          await this._channel.close();
+        } catch (err) {
+          // Ignore errors when closing already-closed channel
+        }
+      }
+
+      // Create new ConfirmChannel
+      this._channel = await this._connection.createConfirmChannel();
+      this._channel.on('error', (err) => this.emit('error', err));
+      this._channel.on('close', () => {
+        this.emit('error', new Error('RabbitMQ channel closed unexpectedly'));
+      });
+    } catch (err) {
+      this._channel = null;
+      throw new Error(`Failed to recreate channel: ${err.message}`);
+    }
+  }
+
   /**
    * Disconnects: closes channel and connection.
    * @returns {Promise<void>}
@@ -158,6 +192,16 @@ class RabbitMQClient extends EventEmitter {
     if (!this._channel) {
       throw new Error('Cannot publish: channel is not initialized');
     }
+    
+    // Check if channel is closed and recreate if needed
+    if (this._channel.closed) {
+      console.warn('[RabbitMQClient] Publish channel is closed, recreating...');
+      try {
+        await this._recreateChannel();
+      } catch (recreateErr) {
+        throw new Error(`Cannot publish: channel is closed and recreation failed: ${recreateErr.message}`);
+      }
+    }
 
     const exchange = this._config.exchange || '';
     const routingKey = options.routingKey || queue;
@@ -177,20 +221,11 @@ class RabbitMQClient extends EventEmitter {
           // Business queue - should already exist, skip checkQueue() to avoid channel closure
           console.log(`[RabbitMQClient] DEBUG: Business queue ${queue}, skipping checkQueue() in publish() - queue should already exist`);
         } else {
-          // Infrastructure queue - check if it exists
-          const queueOptions = this._getQueueOptions(queue);
-          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`);
-            }
-          }
+          // Infrastructure queue - skip assertQueue() to avoid 406 channel closure
+          // Infrastructure queues are created by monitoring consumer at startup
+          // If queue doesn't exist, publish() will fail with a clear error
+          // This matches the pattern used for business queues - early creation, no runtime checks
+          console.log(`[RabbitMQClient] DEBUG: Infrastructure queue ${queue}, skipping assertQueue() - queue should already exist (created by monitoring consumer)`);
         }
         // Publish using ConfirmChannel (for publisher confirms)
         this._channel.sendToQueue(queue, buffer, { persistent, headers, routingKey });