@onlineapps/mq-client-core 1.0.78 → 1.0.80

package/package.json

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

package/src/config.js

@@ -27,3 +27,6 @@ const runtimeCfg = createRuntimeConfig({
 module.exports = runtimeCfg;
 
 
+
+
+

package/src/defaults.js

@@ -15,3 +15,6 @@ module.exports = {
 };
 
 
+
+
+

package/src/transports/rabbitmqClient.js

@@ -80,6 +80,7 @@ class RabbitMQClient extends EventEmitter {
     this._reconnecting = false;
     this._disconnecting = false;
     this._reconnectAttempts = 0;
+    this._activeTimers = new Set();
     this._maxReconnectAttempts = this._config.maxReconnectAttempts || 10; // Max 10 attempts
     this._reconnectBaseDelay = this._config.reconnectBaseDelay || 1000; // Start with 1 second
     this._reconnectMaxDelay = this._config.reconnectMaxDelay || 30000; // Max 30 seconds
@@ -418,6 +419,41 @@ class RabbitMQClient extends EventEmitter {
    * @returns {Promise<void>}
    * @throws {Error} If connection or channel creation fails.
    */
+  /**
+   * Helper to set a trackable timeout
+   * @private
+   */
+  _setTimeout(callback, ms) {
+    const timer = setTimeout(() => {
+      this._activeTimers.delete(timer);
+      callback();
+    }, ms);
+    this._activeTimers.add(timer);
+    return timer;
+  }
+
+  /**
+   * Helper to clear a trackable timeout
+   * @private
+   */
+  _clearTimeout(timer) {
+    if (timer) {
+      clearTimeout(timer);
+      this._activeTimers.delete(timer);
+    }
+  }
+
+  /**
+   * Clear all active timers
+   * @private
+   */
+  _clearAllTimers() {
+    for (const timer of this._activeTimers) {
+      clearTimeout(timer);
+    }
+    this._activeTimers.clear();
+  }
+
   async connect() {
     let connectTimeoutTimer = null;
     try {
@@ -435,7 +471,7 @@ class RabbitMQClient extends EventEmitter {
 
       const connectPromise = amqp.connect(...connectArgs);
       const timeoutPromise = new Promise((_, reject) => {
-        connectTimeoutTimer = setTimeout(() => reject(new Error('Connection timeout after 10 seconds')), 10000);
+        connectTimeoutTimer = this._setTimeout(() => reject(new Error('Connection timeout after 10 seconds')), 10000);
         if (connectTimeoutTimer && typeof connectTimeoutTimer.unref === 'function') {
           connectTimeoutTimer.unref();
         }
@@ -443,7 +479,7 @@ class RabbitMQClient extends EventEmitter {
       console.log('[RabbitMQClient] Starting connection race...');
       this._connection = await Promise.race([connectPromise, timeoutPromise]);
       if (connectTimeoutTimer) {
-        clearTimeout(connectTimeoutTimer);
+        this._clearTimeout(connectTimeoutTimer);
         connectTimeoutTimer = null;
       }
       console.log('[RabbitMQClient] Connection established');
@@ -562,18 +598,18 @@ class RabbitMQClient extends EventEmitter {
     
     // Wait for 'reconnected' event
     return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
+      const timeout = this._setTimeout(() => {
         this.removeListener('reconnected', onReconnected);
         this.removeListener('error', onError);
         reject(new Error(`Reconnection timeout after ${this._reconnectWaitTimeout}ms`));
       }, this._reconnectWaitTimeout);
       
       const onReconnected = () => {
-        clearTimeout(timeout);
+        this._clearTimeout(timeout);
         this.removeListener('reconnected', onReconnected);
         this.removeListener('error', onError);
         // Wait a bit for channels to be fully recreated
-        setTimeout(resolve, 500);
+        this._setTimeout(resolve, 500);
       };
       
       const onError = (error) => {
@@ -581,7 +617,7 @@ class RabbitMQClient extends EventEmitter {
         if (error.message && error.message.includes('Connection closed unexpectedly')) {
           return; // Expected during reconnection
         }
-        clearTimeout(timeout);
+        this._clearTimeout(timeout);
         this.removeListener('reconnected', onReconnected);
         this.removeListener('error', onError);
         reject(error);
@@ -1052,6 +1088,10 @@ class RabbitMQClient extends EventEmitter {
 
   async disconnect() {
     this._disconnecting = true;
+    
+    // Clear all active timers (reconnection, waits, etc.)
+    this._clearAllTimers();
+    
     // Stop health monitoring
     this._stopHealthMonitoring();
     
@@ -1324,13 +1364,13 @@ class RabbitMQClient extends EventEmitter {
         // Use callback-based confirmation - kanály jsou spolehlivé, takže callback vždy dorazí
         const confirmPromise = new Promise((resolve, reject) => {
           // Set timeout for publish confirmation (configurable)
-          const timeout = setTimeout(() => {
+          const timeout = this._setTimeout(() => {
             reject(new Error(`Publish confirmation timeout for queue "${queue}" after ${this._publishConfirmationTimeout}ms`));
           }, this._publishConfirmationTimeout);
           
           // Check if channel is still valid before sending
           if (!this._channel || this._channel.closed) {
-            clearTimeout(timeout);
+            this._clearTimeout(timeout);
             reject(new Error(`Cannot publish: channel is closed for queue "${queue}"`));
             return;
           }
@@ -1344,7 +1384,7 @@ class RabbitMQClient extends EventEmitter {
           try {
             originalChannel.sendToQueue(queue, buffer, { persistent, headers }, (err, ok) => {
               callbackInvoked = true;
-              clearTimeout(timeout);
+              this._clearTimeout(timeout);
               
               // CRITICAL: Check if channel was closed or recreated during publish
               // If channel was recreated, the delivery tag is invalid - ignore this callback
@@ -1398,11 +1438,11 @@ class RabbitMQClient extends EventEmitter {
             });
             
             // Set a safety timeout - if callback wasn't invoked and channel closed, retry
-            setTimeout(() => {
+            this._setTimeout(() => {
               if (!callbackInvoked && (!this._channel || this._channel.closed || this._channel !== originalChannel)) {
                 console.warn(`[RabbitMQClient] [mq-client-core] [PUBLISH] Callback timeout and channel closed for queue "${queue}", will retry after reconnection`);
                 if (this._reconnecting) {
-                  clearTimeout(timeout);
+                  this._clearTimeout(timeout);
                   this._waitForReconnection().then(() => {
                     return this.publish(queue, buffer, options);
                   }).then(resolve).catch(reject);
@@ -1438,12 +1478,12 @@ class RabbitMQClient extends EventEmitter {
         // Use callback-based confirmation - kanály jsou spolehlivé
         const confirmPromise = new Promise((resolve, reject) => {
           // Set timeout for exchange publish confirmation
-          const timeout = setTimeout(() => {
+          const timeout = this._setTimeout(() => {
             reject(new Error(`Exchange publish confirmation timeout for exchange "${exchange}" after ${this._publishConfirmationTimeout}ms`));
           }, this._publishConfirmationTimeout);
           
           this._channel.publish(exchange, routingKey, buffer, { persistent, headers }, (err, ok) => {
-            clearTimeout(timeout);
+            this._clearTimeout(timeout);
             if (err) {
               console.error(`[RabbitMQClient] [mq-client-core] [PUBLISH] Exchange publish callback error:`, err.message);
               reject(err);
@@ -1512,16 +1552,17 @@ class RabbitMQClient extends EventEmitter {
       
       if (queueConfig) {
         if (isInfraQueue) {
-          // Infrastructure queue - use central config
+          // Infrastructure queue - use central config for expected arguments,
+          // but DO NOT create it here. Ownership rule: infra queues are created by their owning infra service.
           try {
             const infraConfig = queueConfig.getInfrastructureQueueConfig(queue);
             queueOptions = {
               durable: infraConfig.durable !== false,
               arguments: { ...infraConfig.arguments }
             };
-            console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] Asserting infrastructure queue ${queue} with config from queueConfig`);
+            console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] Checking infrastructure queue ${queue} exists (no auto-create)`);
           } catch (configErr) {
-            console.warn(`[RabbitMQClient] [mq-client-core] [CONSUMER] Infrastructure queue config not found for ${queue}, using default:`, configErr.message);
+            console.warn(`[RabbitMQClient] [mq-client-core] [CONSUMER] Infrastructure queue config not found for ${queue}, will still require it to exist:`, configErr.message);
           }
         } else if (isBusinessQueue) {
           // Business queue - use central config
@@ -1560,28 +1601,45 @@ class RabbitMQClient extends EventEmitter {
         }
       }
       
-      try {
-        console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] About to call assertQueue(${queue}, ${JSON.stringify(queueOptions)})`);
-        
-        // Ensure queue channel is available
-        await this._ensureQueueChannel();
-        if (!this._queueChannel) {
-          throw new Error('Queue channel is not available (connection may be closed)');
+      // Ensure queue channel is available
+      await this._ensureQueueChannel();
+      if (!this._queueChannel) {
+        throw new Error('Queue channel is not available (connection may be closed)');
+      }
+
+      if (isInfraQueue) {
+        // IMPORTANT: Do NOT auto-create infrastructure queues in consumers.
+        // If missing, fail-fast. The owning infra service must recreate on startup.
+        try {
+          this._trackChannelOperation(this._queueChannel, `checkQueue ${queue}`);
+          await this._queueChannel.checkQueue(queue);
+          console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] ✓ Infrastructure queue ${queue} exists (consumer will proceed)`);
+        } catch (checkErr) {
+          if (checkErr.code === 404) {
+            throw new Error(
+              `Infrastructure queue ${queue} is missing. ` +
+              'Ownership rule: infrastructure queues must be created by their owning infrastructure service via initInfrastructureQueues().'
+            );
+          }
+          throw checkErr;
         }
-        
-        this._trackChannelOperation(this._queueChannel, `assertQueue ${queue}`);
-        await this._queueChannel.assertQueue(queue, queueOptions);
-        console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] ✓ Queue ${queue} asserted successfully`);
-      } catch (assertErr) {
-        // If queue exists with different arguments (406), this is a CRITICAL ERROR
-        // We should NOT proceed - the root cause must be fixed
-        if (assertErr.code === 406) {
-          console.error(`[RabbitMQClient] [mq-client-core] [CONSUMER] ✗ CRITICAL: Queue ${queue} exists with different arguments!`);
-          console.error(`[RabbitMQClient] [mq-client-core] [CONSUMER] Error:`, assertErr.message);
-          console.error(`[RabbitMQClient] [mq-client-core] [CONSUMER] Expected options:`, JSON.stringify(queueOptions, null, 2));
-          console.error(`[RabbitMQClient] [mq-client-core] [CONSUMER] This means assertQueue() was called without parameters somewhere else. Root cause must be fixed!`);
-          throw new Error(`Cannot assertQueue ${queue}: queue exists with different arguments. Root cause: assertQueue() was called without parameters. Fix the root cause instead of proceeding.`);
-        } else {
+      } else {
+        // Business queue (or unknown) - assert with canonical parameters to prevent 406 drift.
+        try {
+          console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] About to call assertQueue(${queue}, ${JSON.stringify(queueOptions)})`);
+          this._trackChannelOperation(this._queueChannel, `assertQueue ${queue}`);
+          await this._queueChannel.assertQueue(queue, queueOptions);
+          console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] ✓ Queue ${queue} asserted successfully`);
+        } catch (assertErr) {
+          // If queue exists with different arguments (406), this is a CRITICAL ERROR
+          // We should NOT proceed - the root cause must be fixed
+          if (assertErr.code === 406) {
+            console.error(`[RabbitMQClient] [mq-client-core] [CONSUMER] ✗ CRITICAL: Queue ${queue} exists with different arguments!`);
+            console.error(`[RabbitMQClient] [mq-client-core] [CONSUMER] Error:`, assertErr.message);
+            console.error(`[RabbitMQClient] [mq-client-core] [CONSUMER] Expected options:`, JSON.stringify(queueOptions, null, 2));
+            console.error(`[RabbitMQClient] [mq-client-core] [CONSUMER] This means assertQueue() was called without parameters somewhere else. Root cause must be fixed!`);
+            throw new Error(`Cannot assertQueue ${queue}: queue exists with different arguments. Root cause: assertQueue() was called without parameters. Fix the root cause instead of proceeding.`);
+          }
           // Other error - rethrow
           throw assertErr;
         }
@@ -1623,6 +1681,14 @@ class RabbitMQClient extends EventEmitter {
         if (msg === null) {
           return; // Consumer cancellation
         }
+
+        // IMPORTANT:
+        // `msg` MUST be acked/nacked on the SAME channel instance that delivered it.
+        // During reconnects, `this._consumerChannel` may be replaced while a handler is running.
+        // If we ack/nack a message using a different (new) channel, RabbitMQ will close the channel with:
+        //   406 (PRECONDITION-FAILED) unknown delivery tag
+        // which cascades into "Channel closed" errors across the service.
+        const channelForMsg = this._consumerChannel;
         
         // Structured log: message received
         const msgHeaders = msg.properties?.headers || {};
@@ -1650,7 +1716,23 @@ class RabbitMQClient extends EventEmitter {
           await onMessage(msg);
           // Acknowledge message after successful processing
           if (!noAck) {
-            this._consumerChannel.ack(msg);
+            // Only ack on the original channel instance; if it's gone/closed, do not attempt ack.
+            if (!channelForMsg || channelForMsg.closed) {
+              console.warn('[RabbitMQClient] [mq-client-core] [CONSUMER] Cannot ack - consumer channel is closed/recreated (message will be requeued by broker)');
+              return;
+            }
+            try {
+              channelForMsg.ack(msg);
+            } catch (ackErr) {
+              // If the channel was closed/recreated during processing, delivery tag becomes invalid.
+              // Do NOT send further acks that would close the channel with 406.
+              const m = ackErr && ackErr.message ? ackErr.message : '';
+              if (m.includes('unknown delivery tag') || m.includes('PRECONDITION_FAILED') || m.includes('Channel closed')) {
+                console.warn('[RabbitMQClient] [mq-client-core] [CONSUMER] Ack failed due to invalid delivery tag / closed channel (message delivery will be handled by broker)', { error: m });
+                return;
+              }
+              throw ackErr;
+            }
             // Structured log: message acknowledged
             this._log.output(wfId, 'MSG_ACKED', {
               handler: 'consume',
@@ -1668,9 +1750,9 @@ class RabbitMQClient extends EventEmitter {
         } catch (handlerErr) {
           // Negative acknowledge and requeue by default
           // Check if channel is still valid before nacking
-          if (this._consumerChannel && !this._consumerChannel.closed) {
+          if (channelForMsg && !channelForMsg.closed) {
             try {
-              this._consumerChannel.nack(msg, false, true);
+              channelForMsg.nack(msg, false, true);
             } catch (nackErr) {
               // Channel may have closed during nack - ignore
               console.warn(`[RabbitMQClient] [mq-client-core] Failed to nack message (channel may be closed): ${nackErr.message}`);
@@ -1731,7 +1813,13 @@ class RabbitMQClient extends EventEmitter {
         );
         
         console.log(`[RabbitMQClient] Waiting ${delay}ms before reconnection attempt ${this._reconnectAttempts + 1}...`);
-        await new Promise(resolve => setTimeout(resolve, delay));
+        await new Promise(resolve => this._setTimeout(resolve, delay));
+
+        // Check if we started disconnecting during the wait
+        if (this._disconnecting) {
+          console.log('[RabbitMQClient] Disconnecting during reconnection wait, aborting');
+          return;
+        }
 
         // Attempt to reconnect
         console.log(`[RabbitMQClient] Reconnection attempt ${this._reconnectAttempts + 1}...`);
@@ -1760,7 +1848,7 @@ class RabbitMQClient extends EventEmitter {
 
         const connectPromise = amqp.connect(...connectArgs);
         const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => reject(new Error('Connection timeout after 10 seconds')), 10000);
+          this._setTimeout(() => reject(new Error('Connection timeout after 10 seconds')), 10000);
         });
 
         this._connection = await Promise.race([connectPromise, timeoutPromise]);
@@ -2136,6 +2224,11 @@ class RabbitMQClient extends EventEmitter {
     try {
       this._consumerChannel.ack(msg);
     } catch (err) {
+      const m = err && err.message ? err.message : '';
+      if (m.includes('unknown delivery tag') || m.includes('PRECONDITION_FAILED') || m.includes('Channel closed')) {
+        console.warn('[RabbitMQClient] [mq-client-core] Cannot ack - consumer channel is closed/recreated (delivery tag invalid)', { error: m });
+        return;
+      }
       this.emit('error', err);
       throw err;
     }
@@ -2154,6 +2247,11 @@ class RabbitMQClient extends EventEmitter {
     try {
       this._consumerChannel.nack(msg, false, requeue);
     } catch (err) {
+      const m = err && err.message ? err.message : '';
+      if (m.includes('unknown delivery tag') || m.includes('PRECONDITION_FAILED') || m.includes('Channel closed')) {
+        console.warn('[RabbitMQClient] [mq-client-core] Cannot nack - consumer channel is closed/recreated (delivery tag invalid)', { error: m });
+        return;
+      }
       this.emit('error', err);
       throw err;
     }