@onlineapps/mq-client-core 1.0.32 → 1.0.34

package/package.json

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

package/src/transports/rabbitmqClient.js

@@ -35,6 +35,13 @@ class RabbitMQClient extends EventEmitter {
     this._channel = null; // ConfirmChannel for publish operations
     this._queueChannel = null; // Regular channel for queue operations (assertQueue, checkQueue)
     this._consumerChannel = null; // Dedicated channel for consume operations
+    
+    // Track active consumers for re-registration after channel recreation
+    this._activeConsumers = new Map(); // queue -> { handler, options, consumerTag }
+    
+    // Auto-reconnect flags
+    this._reconnecting = false;
+    this._reconnectAttempts = 0;
   }
 
   /**
@@ -94,33 +101,57 @@ class RabbitMQClient extends EventEmitter {
 
       // Use ConfirmChannel to enable publisher confirms for publish operations
       this._channel = await this._connection.createConfirmChannel();
-      this._channel.on('error', (err) => this.emit('error', err));
-      this._channel.on('close', () => {
-        // Emit a channel close error
-        this.emit('error', new Error('RabbitMQ channel closed unexpectedly'));
+      // Enable publisher confirms explicitly
+      this._channel.on('error', async (err) => {
+        console.error('[RabbitMQClient] [mq-client-core] Publisher channel error:', err.message);
+        // Auto-recreate channel if connection is still alive
+        await this._ensurePublisherChannel();
+        this.emit('error', err);
+      });
+      this._channel.on('close', async () => {
+        console.warn('[RabbitMQClient] [mq-client-core] Publisher channel closed - will auto-recreate on next publish');
+        // Mark channel as null - will be recreated on next publish
+        this._channel = null;
+        // Try to recreate immediately if connection is alive
+        await this._ensurePublisherChannel();
+      });
+      // Set up publisher confirms callback
+      this._channel.on('drain', () => {
+        console.log('[RabbitMQClient] [mq-client-core] Publisher channel drained');
       });
       
       // Create a separate regular channel for queue operations (assertQueue, checkQueue)
       // This avoids RPC reply queue issues with ConfirmChannel.assertQueue()
       this._queueChannel = await this._connection.createChannel();
-      this._queueChannel.on('error', (err) => {
+      this._queueChannel.on('error', async (err) => {
         // Log but don't emit - queue channel errors are less critical
         console.warn('[RabbitMQClient] Queue channel error:', err.message);
+        // Auto-recreate channel if connection is still alive
+        await this._ensureQueueChannel();
       });
-      this._queueChannel.on('close', () => {
-        console.warn('[RabbitMQClient] Queue channel closed');
+      this._queueChannel.on('close', async () => {
+        console.warn('[RabbitMQClient] Queue channel closed - will auto-recreate on next operation');
+        // Mark channel as null - will be recreated on next queue operation
+        this._queueChannel = null;
+        // Try to recreate immediately if connection is alive
+        await this._ensureQueueChannel();
       });
       
       // Create a dedicated channel for consume operations
       // This prevents channel conflicts between publish (ConfirmChannel) and consume operations
       this._consumerChannel = await this._connection.createChannel();
-      this._consumerChannel.on('error', (err) => {
+      this._consumerChannel.on('error', async (err) => {
         console.warn('[RabbitMQClient] Consumer channel error:', err.message);
+        // Auto-recreate channel and re-register consumers
+        await this._ensureConsumerChannel();
         this.emit('error', err);
       });
-      this._consumerChannel.on('close', () => {
-        console.warn('[RabbitMQClient] Consumer channel closed');
-        this.emit('error', new Error('RabbitMQ consumer channel closed unexpectedly'));
+      this._consumerChannel.on('close', async () => {
+        console.warn('[RabbitMQClient] Consumer channel closed - will auto-recreate and re-register consumers');
+        // Mark channel as null - will be recreated and consumers re-registered
+        this._consumerChannel = null;
+        // Try to recreate and re-register consumers immediately if connection is alive
+        await this._ensureConsumerChannel();
       });
     } catch (err) {
       // Cleanup partially created resources
@@ -136,11 +167,192 @@ class RabbitMQClient extends EventEmitter {
     }
   }
 
+  /**
+   * Ensure publisher channel exists and is open
+   * Auto-recreates if closed
+   * @private
+   * @returns {Promise<void>}
+   */
+  async _ensurePublisherChannel() {
+    if (this._channel && !this._channel.closed) {
+      return; // Channel is good
+    }
+    
+    if (!this._connection || this._connection.closed) {
+      throw new Error('Cannot recreate publisher channel: connection is closed');
+    }
+    
+    try {
+      // Close old channel if exists
+      if (this._channel) {
+        try {
+          await this._channel.close();
+        } catch (_) {
+          // Ignore errors when closing already-closed channel
+        }
+      }
+      
+      // Create new ConfirmChannel
+      this._channel = await this._connection.createConfirmChannel();
+      this._channel.on('error', async (err) => {
+        console.error('[RabbitMQClient] [mq-client-core] Publisher channel error:', err.message);
+        await this._ensurePublisherChannel();
+        this.emit('error', err);
+      });
+      this._channel.on('close', async () => {
+        console.warn('[RabbitMQClient] [mq-client-core] Publisher channel closed - will auto-recreate on next publish');
+        this._channel = null;
+        await this._ensurePublisherChannel();
+      });
+      this._channel.on('drain', () => {
+        console.log('[RabbitMQClient] [mq-client-core] Publisher channel drained');
+      });
+      
+      console.log('[RabbitMQClient] [mq-client-core] ✓ Publisher channel recreated');
+    } catch (err) {
+      this._channel = null;
+      throw new Error(`Failed to recreate publisher channel: ${err.message}`);
+    }
+  }
+
+  /**
+   * Ensure queue channel exists and is open
+   * Auto-recreates if closed
+   * @private
+   * @returns {Promise<void>}
+   */
+  async _ensureQueueChannel() {
+    if (this._queueChannel && !this._queueChannel.closed) {
+      return; // Channel is good
+    }
+    
+    if (!this._connection || this._connection.closed) {
+      throw new Error('Cannot recreate queue channel: connection is closed');
+    }
+    
+    try {
+      // Close old channel if exists
+      if (this._queueChannel) {
+        try {
+          await this._queueChannel.close();
+        } catch (_) {
+          // Ignore errors when closing already-closed channel
+        }
+      }
+      
+      // Create new regular channel
+      this._queueChannel = await this._connection.createChannel();
+      this._queueChannel.on('error', async (err) => {
+        console.warn('[RabbitMQClient] Queue channel error:', err.message);
+        await this._ensureQueueChannel();
+      });
+      this._queueChannel.on('close', async () => {
+        console.warn('[RabbitMQClient] Queue channel closed - will auto-recreate on next operation');
+        this._queueChannel = null;
+        await this._ensureQueueChannel();
+      });
+      
+      console.log('[RabbitMQClient] [mq-client-core] ✓ Queue channel recreated');
+    } catch (err) {
+      this._queueChannel = null;
+      throw new Error(`Failed to recreate queue channel: ${err.message}`);
+    }
+  }
+
+  /**
+   * Ensure consumer channel exists and is open
+   * Auto-recreates and re-registers all consumers if closed
+   * @private
+   * @returns {Promise<void>}
+   */
+  async _ensureConsumerChannel() {
+    if (this._consumerChannel && !this._consumerChannel.closed) {
+      return; // Channel is good
+    }
+    
+    if (!this._connection || this._connection.closed) {
+      throw new Error('Cannot recreate consumer channel: connection is closed');
+    }
+    
+    try {
+      // Close old channel if exists
+      if (this._consumerChannel) {
+        try {
+          await this._consumerChannel.close();
+        } catch (_) {
+          // Ignore errors when closing already-closed channel
+        }
+      }
+      
+      // Create new regular channel
+      this._consumerChannel = await this._connection.createChannel();
+      this._consumerChannel.on('error', async (err) => {
+        console.warn('[RabbitMQClient] Consumer channel error:', err.message);
+        await this._ensureConsumerChannel();
+        this.emit('error', err);
+      });
+      this._consumerChannel.on('close', async () => {
+        console.warn('[RabbitMQClient] Consumer channel closed - will auto-recreate and re-register consumers');
+        this._consumerChannel = null;
+        await this._ensureConsumerChannel();
+      });
+      
+      // Re-register all active consumers
+      if (this._activeConsumers.size > 0) {
+        console.log(`[RabbitMQClient] [mq-client-core] Re-registering ${this._activeConsumers.size} consumers...`);
+        for (const [queue, consumerInfo] of this._activeConsumers.entries()) {
+          try {
+            // Re-assert queue with correct options before consuming (may have been deleted)
+            if (consumerInfo.options.queueOptions) {
+              try {
+                await this._ensureQueueChannel();
+                await this._queueChannel.assertQueue(queue, consumerInfo.options.queueOptions);
+              } catch (assertErr) {
+                if (assertErr.code === 404) {
+                  console.warn(`[RabbitMQClient] [mq-client-core] Queue ${queue} does not exist, skipping consumer re-registration`);
+                  this._activeConsumers.delete(queue);
+                  continue;
+                }
+                // 406 error means queue exists with different args - skip this consumer
+                if (assertErr.code === 406) {
+                  console.warn(`[RabbitMQClient] [mq-client-core] Queue ${queue} exists with different args, skipping consumer re-registration`);
+                  this._activeConsumers.delete(queue);
+                  continue;
+                }
+                throw assertErr;
+              }
+            }
+            
+            const consumeResult = await this._consumerChannel.consume(
+              queue,
+              consumerInfo.handler,
+              { noAck: consumerInfo.options.noAck }
+            );
+            consumerInfo.consumerTag = consumeResult.consumerTag;
+            console.log(`[RabbitMQClient] [mq-client-core] ✓ Re-registered consumer for queue: ${queue} (consumerTag: ${consumeResult.consumerTag})`);
+          } catch (err) {
+            console.error(`[RabbitMQClient] [mq-client-core] Failed to re-register consumer for queue ${queue}:`, err.message);
+            // Remove failed consumer from tracking
+            this._activeConsumers.delete(queue);
+          }
+        }
+      }
+      
+      console.log('[RabbitMQClient] [mq-client-core] ✓ Consumer channel recreated');
+    } catch (err) {
+      this._consumerChannel = null;
+      throw new Error(`Failed to recreate consumer channel: ${err.message}`);
+    }
+  }
+
   /**
    * Disconnects: closes channel and connection.
    * @returns {Promise<void>}
    */
   async disconnect() {
+    // Clear active consumers tracking
+    this._activeConsumers.clear();
+    
     try {
       if (this._consumerChannel) {
         await this._consumerChannel.close();
@@ -185,10 +397,11 @@ class RabbitMQClient extends EventEmitter {
    * @throws {Error} If publish fails or channel is not available.
    */
   async publish(queue, buffer, options = {}) {
-    // Check channel state before publish
-    if (!this._channel || this._channel.closed) {
-      throw new Error('Cannot publish: channel is not initialized or closed');
-    }
+    // Ensure publisher channel exists and is open (auto-recreates if closed)
+    await this._ensurePublisherChannel();
+    
+    // Log publish attempt for debugging
+    console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] Attempting to publish to queue "${queue}"`);
 
     const exchange = this._config.exchange || '';
     const routingKey = options.routingKey || queue;
@@ -203,21 +416,8 @@ 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');
-            }
-          }
+          // Ensure queue channel exists and is open (auto-recreates if closed)
+          await this._ensureQueueChannel();
           await this._queueChannel.checkQueue(queue);
           // Queue exists - proceed to publish
         } catch (checkErr) {
@@ -252,30 +452,56 @@ 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 });
+        // Channel is guaranteed to be open (ensured above)
+        console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] Sending message to queue "${queue}" (size: ${buffer.length} bytes)`);
+        
+        // Use callback-based confirmation - kanály jsou spolehlivé, takže callback vždy dorazí
+        const confirmPromise = new Promise((resolve, reject) => {
+          // Send message with callback
+          this._channel.sendToQueue(queue, buffer, { persistent, headers }, (err, ok) => {
+            if (err) {
+              console.error(`[RabbitMQClient] [mq-client-core] [PUBLISH] Send callback error for queue "${queue}":`, err.message);
+              reject(err);
+            } else {
+              console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] ✓ Message confirmed for queue "${queue}"`);
+              resolve();
+            }
+          });
+        });
+        
+        await confirmPromise;
       } else {
         // If exchange is specified, assert exchange and publish to it
-        if (this._channel.closed) {
-          throw new Error('Cannot publish: channel closed during operation');
-        }
+        // Channel is guaranteed to be open (ensured above)
         await this._channel.assertExchange(exchange, 'direct', { durable: this._config.durable });
-        this._channel.publish(exchange, routingKey, buffer, { persistent, headers });
+        
+        // Use callback-based confirmation - kanály jsou spolehlivé
+        const confirmPromise = new Promise((resolve, reject) => {
+          this._channel.publish(exchange, routingKey, buffer, { persistent, headers }, (err, ok) => {
+            if (err) {
+              console.error(`[RabbitMQClient] [mq-client-core] [PUBLISH] Exchange publish callback error:`, err.message);
+              reject(err);
+            } else {
+              console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] ✓ Exchange publish confirmed`);
+              resolve();
+            }
+          });
+        });
+        
+        await confirmPromise;
       }
-      // 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 channel was closed, try to recreate and retry once
       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;
+        console.warn('[RabbitMQClient] [mq-client-core] [PUBLISH] Channel closed during publish, recreating and retrying...');
+        try {
+          await this._ensurePublisherChannel();
+          // Retry publish once
+          return await this.publish(queue, buffer, options);
+        } catch (retryErr) {
+          console.error('[RabbitMQClient] [mq-client-core] [PUBLISH] Retry failed:', retryErr.message);
+          throw retryErr;
+        }
       }
       this.emit('error', err);
       throw err;
@@ -291,41 +517,8 @@ class RabbitMQClient extends EventEmitter {
    * @throws {Error} If consume setup fails or channel is not available.
    */
   async consume(queue, onMessage, options = {}) {
-    // Use dedicated consumer channel instead of ConfirmChannel
-    // ConfirmChannel is optimized for publish operations, not consume
-    if (!this._consumerChannel) {
-      // Recreate consumer channel if closed
-      if (this._connection && !this._connection.closed) {
-        this._consumerChannel = await this._connection.createChannel();
-        this._consumerChannel.on('error', (err) => {
-          console.warn('[RabbitMQClient] Consumer channel error:', err.message);
-          this.emit('error', err);
-        });
-        this._consumerChannel.on('close', () => {
-          console.warn('[RabbitMQClient] Consumer channel closed');
-          this.emit('error', new Error('RabbitMQ consumer channel closed unexpectedly'));
-        });
-      } else {
-        throw new Error('Cannot consume: consumer channel is not initialized and connection is closed');
-      }
-    }
-    
-    if (this._consumerChannel.closed) {
-      // Recreate consumer channel if closed
-      if (this._connection && !this._connection.closed) {
-        this._consumerChannel = await this._connection.createChannel();
-        this._consumerChannel.on('error', (err) => {
-          console.warn('[RabbitMQClient] Consumer channel error:', err.message);
-          this.emit('error', err);
-        });
-        this._consumerChannel.on('close', () => {
-          console.warn('[RabbitMQClient] Consumer channel closed');
-          this.emit('error', new Error('RabbitMQ consumer channel closed unexpectedly'));
-        });
-      } else {
-        throw new Error('Cannot consume: consumer channel is closed and connection is closed');
-      }
-    }
+    // Ensure consumer channel exists and is open (auto-recreates if closed and re-registers consumers)
+    await this._ensureConsumerChannel();
 
     const durable = options.durable !== undefined ? options.durable : this._config.durable;
     const prefetch = options.prefetch !== undefined ? options.prefetch : this._config.prefetch;
@@ -435,25 +628,36 @@ class RabbitMQClient extends EventEmitter {
       
       // Use dedicated consumer channel for consume operations
       // This prevents conflicts with ConfirmChannel used for publish operations
+      const messageHandler = async (msg) => {
+        if (msg === null) {
+          return;
+        }
+        try {
+          await onMessage(msg);
+          if (!noAck) {
+            this._consumerChannel.ack(msg);
+          }
+        } catch (handlerErr) {
+          // Negative acknowledge and requeue by default
+          this._consumerChannel.nack(msg, false, true);
+        }
+      };
+      
       const consumeResult = await this._consumerChannel.consume(
         queue,
-        async (msg) => {
-          if (msg === null) {
-            return;
-          }
-          try {
-            await onMessage(msg);
-            if (!noAck) {
-              this._consumerChannel.ack(msg);
-            }
-          } catch (handlerErr) {
-            // Negative acknowledge and requeue by default
-            this._consumerChannel.nack(msg, false, true);
-          }
-        },
+        messageHandler,
         { noAck }
       );
       
+      // Track consumer for auto re-registration if channel closes
+      this._activeConsumers.set(queue, {
+        handler: messageHandler,
+        options: { noAck, prefetch, durable, queueOptions },
+        consumerTag: consumeResult.consumerTag
+      });
+      
+      console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] ✓ Consumer registered for queue "${queue}" (consumerTag: ${consumeResult.consumerTag})`);
+      
       // Return consumer tag for cancellation
       return consumeResult.consumerTag;
     } catch (err) {