@onlineapps/mq-client-core 1.0.78 → 1.0.79

package/package.json

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

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);
@@ -1731,7 +1771,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 +1806,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]);