@onlineapps/mq-client-core 1.0.26 → 1.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/mq-client-core",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "Core MQ client library for RabbitMQ - shared by infrastructure services and connectors",
   "main": "src/index.js",
   "scripts": {

package/src/transports/rabbitmqClient.js

@@ -164,8 +164,9 @@ class RabbitMQClient extends EventEmitter {
    * @throws {Error} If publish fails or channel is not available.
    */
   async publish(queue, buffer, options = {}) {
-    if (!this._channel) {
-      throw new Error('Cannot publish: channel is not initialized');
+    // Check channel state before publish
+    if (!this._channel || this._channel.closed) {
+      throw new Error('Cannot publish: channel is not initialized or closed');
     }
 
     const exchange = this._config.exchange || '';
@@ -181,15 +182,42 @@ class RabbitMQClient extends EventEmitter {
         // If queue doesn't exist (404), we should NOT auto-create it - infrastructure queues must be created explicitly
         // This prevents creating queues with wrong arguments (no TTL) which causes 406 errors later
         try {
+          // Check queueChannel state
+          if (!this._queueChannel || this._queueChannel.closed) {
+            // Recreate queueChannel if closed
+            if (this._connection && !this._connection.closed) {
+              this._queueChannel = await this._connection.createChannel();
+              this._queueChannel.on('error', (err) => {
+                console.warn('[RabbitMQClient] Queue channel error:', err.message);
+              });
+              this._queueChannel.on('close', () => {
+                console.warn('[RabbitMQClient] Queue channel closed');
+              });
+            } else {
+              throw new Error('Cannot publish: connection is closed');
+            }
+          }
           await this._queueChannel.checkQueue(queue);
           // Queue exists - proceed to publish
         } catch (checkErr) {
           // If queue doesn't exist (404), this is an ERROR for infrastructure queues
-          // Infrastructure queues (workflow.*, registry.*) must be created explicitly with correct arguments
+          // Infrastructure queues (workflow.*, registry.*, infrastructure.*, monitoring.*, validation.*) must be created explicitly with correct arguments
           // We should NOT auto-create them here, as we don't have access to queueConfig in mq-client-core
           if (checkErr.code === 404) {
-            // Check if this is an infrastructure queue
-            const isInfraQueue = queue.startsWith('workflow.') || queue.startsWith('registry.');
+            // Check if this is an infrastructure queue using queueConfig
+            let isInfraQueue = false;
+            try {
+              const queueConfig = require('../config/queueConfig');
+              isInfraQueue = queueConfig.isInfrastructureQueue(queue);
+            } catch (requireErr) {
+              // Fallback to pattern matching if queueConfig not available
+              isInfraQueue = queue.startsWith('workflow.') || 
+                            queue.startsWith('registry.') || 
+                            queue.startsWith('infrastructure.') || 
+                            queue.startsWith('monitoring.') || 
+                            queue.startsWith('validation.');
+            }
+            
             if (isInfraQueue) {
               throw new Error(`Cannot publish to infrastructure queue ${queue}: queue does not exist. Infrastructure queues must be created explicitly with correct arguments (TTL, max-length, etc.) before publishing.`);
             }
@@ -203,15 +231,31 @@ class RabbitMQClient extends EventEmitter {
           }
         }
         // Publish to queue using ConfirmChannel (for publisher confirms)
+        // Check channel state again before sendToQueue
+        if (this._channel.closed) {
+          throw new Error('Cannot publish: channel closed during operation');
+        }
         this._channel.sendToQueue(queue, buffer, { persistent, headers });
       } else {
         // If exchange is specified, assert exchange and publish to it
+        if (this._channel.closed) {
+          throw new Error('Cannot publish: channel closed during operation');
+        }
         await this._channel.assertExchange(exchange, 'direct', { durable: this._config.durable });
         this._channel.publish(exchange, routingKey, buffer, { persistent, headers });
       }
-      // Wait for confirmation
-      await this._channel.waitForConfirms();
+      // Wait for confirmation (with timeout to prevent hanging)
+      const confirmPromise = this._channel.waitForConfirms();
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error('Publisher confirm timeout after 5 seconds')), 5000);
+      });
+      await Promise.race([confirmPromise, timeoutPromise]);
     } catch (err) {
+      // If channel was closed, mark it for recreation
+      if (err.message && (err.message.includes('Channel closed') || err.message.includes('channel is closed') || this._channel?.closed)) {
+        console.warn('[RabbitMQClient] [mq-client-core] [PUBLISH] Channel closed during publish, will need to reconnect');
+        this._channel = null;
+      }
       this.emit('error', err);
       throw err;
     }
@@ -249,8 +293,10 @@ class RabbitMQClient extends EventEmitter {
         console.warn(`[RabbitMQClient] [mq-client-core] [CONSUMER] Cannot load queueConfig from @onlineapps/conn-infra-mq:`, requireErr.message);
         console.warn(`[RabbitMQClient] [mq-client-core] [CONSUMER] Using default queue options (this may cause 406 errors if queue exists with different args)`);
       }
-      const isInfraQueue = queueConfig.isInfrastructureQueue(queue);
-      const isBusinessQueue = queueConfig.isBusinessQueue(queue);
+      
+      // Only check queue types if queueConfig is available
+      const isInfraQueue = queueConfig ? queueConfig.isInfrastructureQueue(queue) : false;
+      const isBusinessQueue = queueConfig ? queueConfig.isBusinessQueue(queue) : false;
       
       let queueOptions = options.queueOptions || { durable };