@onlineapps/mq-client-core 1.0.39 → 1.0.41

package/package.json

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

package/src/transports/rabbitmqClient.js

@@ -56,6 +56,9 @@ class RabbitMQClient extends EventEmitter {
     this._reconnectMaxDelay = this._config.reconnectMaxDelay || 30000; // Max 30 seconds
     this._reconnectEnabled = this._config.reconnectEnabled !== false; // Default: enabled
     this._reconnectTimer = null;
+    // Reconnect wait timeout: at least maxReconnectAttempts × reconnectMaxDelay, minimum 60s
+    this._reconnectWaitTimeout = this._config.reconnectWaitTimeout || 
+      Math.max(60000, (this._maxReconnectAttempts * this._reconnectMaxDelay));
     
     // Publisher retry configuration
     this._publishRetryEnabled = this._config.publishRetryEnabled !== false; // Default: enabled
@@ -182,6 +185,61 @@ class RabbitMQClient extends EventEmitter {
     return this._publishMonitor.getPrometheusMetrics();
   }
 
+  /**
+   * Get current channel state
+   * @returns {Object} Channel state information
+   */
+  getChannelState() {
+    return {
+      publisher: {
+        exists: !!this._channel,
+        closed: this._channel ? this._channel.closed : true,
+        ready: this._channel && !this._channel.closed
+      },
+      queue: {
+        exists: !!this._queueChannel,
+        closed: this._queueChannel ? this._queueChannel.closed : true,
+        ready: this._queueChannel && !this._queueChannel.closed
+      },
+      consumer: {
+        exists: !!this._consumerChannel,
+        closed: this._consumerChannel ? this._consumerChannel.closed : true,
+        ready: this._consumerChannel && !this._consumerChannel.closed
+      }
+    };
+  }
+
+  /**
+   * Get current consumer state
+   * @returns {Object} Consumer state information
+   */
+  getConsumerState() {
+    return {
+      tracked: this._activeConsumers.size,
+      active: Array.from(this._activeConsumers.keys())
+    };
+  }
+
+  /**
+   * Get current buffer state
+   * @returns {Object} Buffer state information
+   */
+  getBufferState() {
+    return {
+      size: this._publishLayer._buffer.size(),
+      inMemory: this._publishLayer._buffer._inMemory?.size() || 0,
+      persistent: this._publishLayer._buffer._persistent ? (this._publishLayer._buffer._persistent.size?.() || 0) : 0
+    };
+  }
+
+  /**
+   * Check if client is connected
+   * @returns {boolean} True if connection exists and is not closed
+   */
+  isConnected() {
+    return !!(this._connection && !this._connection.closed);
+  }
+
   /**
    * Getter for channel - provides compatibility with QueueManager
    * Returns ConfirmChannel for publish operations
@@ -457,8 +515,8 @@ class RabbitMQClient extends EventEmitter {
       const timeout = setTimeout(() => {
         this.removeListener('reconnected', onReconnected);
         this.removeListener('error', onError);
-        reject(new Error('Reconnection timeout after 30 seconds'));
-      }, 30000); // 30 seconds timeout
+        reject(new Error(`Reconnection timeout after ${this._reconnectWaitTimeout}ms`));
+      }, this._reconnectWaitTimeout);
       
       const onReconnected = () => {
         clearTimeout(timeout);
@@ -619,11 +677,12 @@ class RabbitMQClient extends EventEmitter {
    * Ensure consumer channel exists and is open
    * Auto-recreates and re-registers all consumers if closed
    * @private
-   * @returns {Promise<void>}
+   * @returns {Promise<{reRegistered: number, failed: number}>} - Number of consumers re-registered and failed
    */
   async _ensureConsumerChannel() {
     if (this._consumerChannel && !this._consumerChannel.closed) {
-      return; // Channel is good
+      // Channel is good - return current consumer state
+      return { reRegistered: this._activeConsumers.size, failed: 0 };
     }
     
     if (!this._connection || this._connection.closed) {
@@ -631,7 +690,7 @@ class RabbitMQClient extends EventEmitter {
       // Reconnection logic will handle this - don't throw, just return
       // The channel will be recreated after reconnection completes
       console.warn('[RabbitMQClient] [mq-client-core] Cannot recreate consumer channel: connection is closed (reconnection in progress)');
-      return;
+      return { reRegistered: 0, failed: this._activeConsumers.size };
     }
     
     try {
@@ -657,6 +716,9 @@ class RabbitMQClient extends EventEmitter {
       this._attachConsumerChannelHandlers(this._consumerChannel);
       
       // Re-register all active consumers
+      let reRegistered = 0;
+      let failed = 0;
+      
       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()) {
@@ -665,18 +727,25 @@ class RabbitMQClient extends EventEmitter {
             if (consumerInfo.options.queueOptions) {
               try {
                 await this._ensureQueueChannel();
+                if (!this._queueChannel || this._queueChannel.closed) {
+                  throw new Error('Queue channel is not available (connection may be closed)');
+                }
                 this._trackChannelOperation(this._queueChannel, `assertQueue ${queue} (re-register)`);
                 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);
+                  failed++;
+                  this.emit('consumer:re-registration:failed', { queue, error: 'Queue does not exist', code: 404 });
                   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);
+                  failed++;
+                  this.emit('consumer:re-registration:failed', { queue, error: 'Queue exists with different arguments', code: 406 });
                   continue;
                 }
                 throw assertErr;
@@ -689,16 +758,21 @@ class RabbitMQClient extends EventEmitter {
               { noAck: consumerInfo.options.noAck }
             );
             consumerInfo.consumerTag = consumeResult.consumerTag;
+            reRegistered++;
             console.log(`[RabbitMQClient] [mq-client-core] ✓ Re-registered consumer for queue: ${queue} (consumerTag: ${consumeResult.consumerTag})`);
           } catch (err) {
+            failed++;
             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);
+            // Emit event for re-registration failure
+            this.emit('consumer:re-registration:failed', { queue, error: err.message, code: err.code });
           }
         }
       }
       
-      console.log('[RabbitMQClient] [mq-client-core] ✓ Consumer channel recreated');
+      console.log(`[RabbitMQClient] [mq-client-core] ✓ Consumer channel recreated (re-registered: ${reRegistered}, failed: ${failed})`);
+      return { reRegistered, failed };
     } catch (err) {
       this._consumerChannel = null;
       throw new Error(`Failed to recreate consumer channel: ${err.message}`);
@@ -1010,6 +1084,13 @@ class RabbitMQClient extends EventEmitter {
         try {
           // Ensure queue channel exists and is open (auto-recreates if closed)
           await this._ensureQueueChannel();
+          if (!this._queueChannel || this._queueChannel.closed) {
+            // Connection is closed and not reconnecting - cannot check queue
+            throw new TransientPublishError(
+              `Cannot check queue ${queue}: queue channel is not available (connection may be closed)`,
+              new Error('Queue channel unavailable')
+            );
+          }
           this._trackChannelOperation(this._queueChannel, `checkQueue ${queue}`);
           await this._queueChannel.checkQueue(queue);
           // Queue exists - proceed to publish
@@ -1037,12 +1118,32 @@ class RabbitMQClient extends EventEmitter {
               // Jasný, hlasitý signál pro infra služby – fronta chybí, je to programátorská chyba
               throw new QueueNotFoundError(queue, true, checkErr);
             }
+          // For non-infrastructure queues, check if queue creation is allowed before auto-creating
+          // Check recovery scope and filter
+          if (this._recoveryWorker && !this._recoveryWorker._queueCreationEnabled) {
+            // Queue creation disabled for this scope (e.g., infrastructure scope)
+            throw new QueueNotFoundError(queue, false, checkErr);
+          }
+          
+          // Check queue creation filter if provided
+          if (this._recoveryWorker && this._recoveryWorker._queueCreationFilter) {
+            if (!this._recoveryWorker._queueCreationFilter(queue)) {
+              // Queue creation filtered out - throw QueueNotFoundError so RecoveryWorker can handle it
+              throw new QueueNotFoundError(queue, false, checkErr);
+            }
+          }
+          
           // For non-infrastructure queues, allow auto-creation with default options
           const queueOptions = options.queueOptions || { durable: this._config.durable };
           console.warn(`[RabbitMQClient] [mq-client-core] [PUBLISH] Auto-creating non-infrastructure queue ${queue} with default options (no TTL). This should be avoided for production.`);
           // Channel could have been nulled out by close handlers; ensure it's available
-          if (!this._queueChannel) {
-            await this._ensureQueueChannel();
+          await this._ensureQueueChannel();
+          if (!this._queueChannel || this._queueChannel.closed) {
+            // Connection is closed and not reconnecting - cannot create queue
+            throw new TransientPublishError(
+              `Cannot create queue ${queue}: queue channel is not available (connection may be closed)`,
+              checkErr
+            );
           }
           this._trackChannelOperation(this._queueChannel, `assertQueue ${queue}`);
           await this._queueChannel.assertQueue(queue, queueOptions);
@@ -1184,23 +1285,11 @@ class RabbitMQClient extends EventEmitter {
         await confirmPromise;
       }
     } catch (err) {
-      // Pokud je kanál zavřený, stále se pokusíme o jedno interní obnovení a retry,
-      // aby byl publish co nejodolnější i předtím, než vstoupí do vyšší retry/recovery vrstvy.
-      if (err && 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, recreating and retrying once...');
-        try {
-          await this._ensurePublisherChannel();
-          // Retry publish once (může znovu vyhodit – už dojde do retry/recovery vrstvy)
-          return await this.publish(queue, buffer, options);
-        } catch (retryErr) {
-          console.error('[RabbitMQClient] [mq-client-core] [PUBLISH] Retry after channel recreation failed:', retryErr.message);
-          const classifiedRetryErr = classifyPublishError(retryErr);
-          this.emit('error', classifiedRetryErr);
-          throw classifiedRetryErr;
-        }
-      }
-
-      // Všechny ostatní chyby projdou jednotnou klasifikací do Transient/Permanent/QueueNotFound.
+      // CRITICAL: _publishOnce() je "single attempt" - žádný vnitřní retry
+      // Retry logika je pouze v PublishLayer, aby byl počet pokusů předvídatelný
+      // Pokud channel closed, vyhodíme TransientPublishError a necháme PublishLayer řešit retry
+      
+      // Všechny chyby projdou jednotnou klasifikací do Transient/Permanent/QueueNotFound
       const classifiedErr = classifyPublishError(err);
       this.emit('error', classifiedErr);
       throw classifiedErr;
@@ -1505,60 +1594,103 @@ class RabbitMQClient extends EventEmitter {
           }
         });
 
-        // Recreate all channels
+        // Recreate all channels with best effort - partial success is better than total failure
         console.log('[RabbitMQClient] Recreating channels...');
         
+        const channelState = { publisher: false, queue: false, consumer: false };
+        let consumerReRegResult = { reRegistered: 0, failed: 0 };
+        
         // Recreate publisher channel
-        this._channel = await this._connection.createConfirmChannel();
-        this._channel._createdAt = new Date().toISOString();
-        this._channel._closeReason = null;
-        this._channel._lastOperation = 'Recreated via _reconnectWithBackoff()';
-        this._channel._type = 'publisher';
-        this._attachPublisherChannelHandlers(this._channel);
+        try {
+          this._channel = await this._connection.createConfirmChannel();
+          this._channel._createdAt = new Date().toISOString();
+          this._channel._closeReason = null;
+          this._channel._lastOperation = 'Recreated via _reconnectWithBackoff()';
+          this._channel._type = 'publisher';
+          this._attachPublisherChannelHandlers(this._channel);
+          channelState.publisher = true;
+          console.log('[RabbitMQClient] ✓ Publisher channel recreated');
+        } catch (err) {
+          console.error('[RabbitMQClient] Failed to recreate publisher channel:', err.message);
+          this._channel = null;
+          // Continue - partial success is better than total failure
+        }
         
         // Recreate queue channel
-        this._queueChannel = await this._connection.createChannel();
-        this._queueChannel._createdAt = new Date().toISOString();
-        this._queueChannel._closeReason = null;
-        this._queueChannel._lastOperation = 'Recreated via _reconnectWithBackoff()';
-        this._queueChannel._type = 'queue';
-        this._attachQueueChannelHandlers(this._queueChannel);
+        try {
+          this._queueChannel = await this._connection.createChannel();
+          this._queueChannel._createdAt = new Date().toISOString();
+          this._queueChannel._closeReason = null;
+          this._queueChannel._lastOperation = 'Recreated via _reconnectWithBackoff()';
+          this._queueChannel._type = 'queue';
+          this._attachQueueChannelHandlers(this._queueChannel);
+          channelState.queue = true;
+          console.log('[RabbitMQClient] ✓ Queue channel recreated');
+        } catch (err) {
+          console.error('[RabbitMQClient] Failed to recreate queue channel:', err.message);
+          this._queueChannel = null;
+          // Continue - partial success is better than total failure
+        }
         
         // Recreate consumer channel and re-register all consumers
-        this._consumerChannel = await this._connection.createChannel();
-        this._consumerChannel._createdAt = new Date().toISOString();
-        this._consumerChannel._closeReason = null;
-        // IMPORTANT: Don't re-register consumers here - _ensureConsumerChannel() will do it
-        // This prevents duplicate re-registration (once in _reconnectWithBackoff, once in _ensureConsumerChannel)
-        // Just ensure consumer channel is created - it will automatically re-register all active consumers
-        await this._ensureConsumerChannel();
+        try {
+          this._consumerChannel = await this._connection.createChannel();
+          this._consumerChannel._createdAt = new Date().toISOString();
+          this._consumerChannel._closeReason = null;
+          this._consumerChannel._lastOperation = 'Recreated via _reconnectWithBackoff()';
+          this._consumerChannel._type = 'consumer';
+          this._attachConsumerChannelHandlers(this._consumerChannel);
+          
+          // Re-register all consumers
+          consumerReRegResult = await this._ensureConsumerChannel();
+          channelState.consumer = true;
+          console.log('[RabbitMQClient] ✓ Consumer channel recreated');
+        } catch (err) {
+          console.error('[RabbitMQClient] Failed to recreate consumer channel:', err.message);
+          this._consumerChannel = null;
+          // Continue - partial success is better than total failure
+        }
 
         // Reset reconnect state
         this._reconnectAttempts = 0;
         this._reconnecting = false;
         
-        // CRITICAL: Verify all channels are ready before emitting 'reconnected'
-        // This ensures publish/consume operations can proceed immediately after reconnection
-        if (!this._channel || this._channel.closed) {
-          throw new Error('Publisher channel not ready after reconnection');
-        }
-        if (!this._queueChannel || this._queueChannel.closed) {
-          throw new Error('Queue channel not ready after reconnection');
-        }
-        if (!this._consumerChannel || this._consumerChannel.closed) {
-          throw new Error('Consumer channel not ready after reconnection');
-        }
+        // Emit reconnected event with state information
+        // Partial success is acceptable - at least connection is re-established
+        const reconnectState = {
+          channels: channelState,
+          consumers: consumerReRegResult,
+          timestamp: new Date().toISOString()
+        };
         
-        console.log('[RabbitMQClient] ✓ Connection-level recovery completed successfully - all channels ready');
-        this.emit('reconnected');
+        console.log('[RabbitMQClient] ✓ Connection-level recovery completed', JSON.stringify(reconnectState, null, 2));
+        this.emit('reconnected', reconnectState);
         
         // Flush buffered messages po reconnectu
+        let bufferFlushResult = { inMemory: 0, persistent: 0, flushed: false };
         try {
           const flushResult = await this._publishLayer.flushBuffered();
-          this._publishMonitor.trackFlushed(flushResult.inMemory + flushResult.persistent);
-          console.log(`[RabbitMQClient] ✓ Flushed ${flushResult.inMemory + flushResult.persistent} buffered messages after reconnection`);
+          bufferFlushResult = {
+            inMemory: flushResult.inMemory || 0,
+            persistent: flushResult.persistent || 0,
+            flushed: true
+          };
+          this._publishMonitor.trackFlushed(bufferFlushResult.inMemory + bufferFlushResult.persistent);
+          console.log(`[RabbitMQClient] ✓ Flushed ${bufferFlushResult.inMemory + bufferFlushResult.persistent} buffered messages after reconnection`);
         } catch (flushErr) {
           console.warn(`[RabbitMQClient] Failed to flush buffered messages after reconnection: ${flushErr.message}`);
+          this.emit('buffer:flush:failed', { error: flushErr.message, bufferSize: this._publishLayer._buffer.size() });
+        }
+        
+        // If critical channels failed, log warning but don't throw - connection is re-established
+        if (!channelState.publisher) {
+          console.warn('[RabbitMQClient] ⚠ Publisher channel not ready after reconnection - publish operations may fail');
+        }
+        if (!channelState.queue) {
+          console.warn('[RabbitMQClient] ⚠ Queue channel not ready after reconnection - queue operations may fail');
+        }
+        if (!channelState.consumer) {
+          console.warn('[RabbitMQClient] ⚠ Consumer channel not ready after reconnection - consume operations may fail');
         }
         
         return; // Success - exit reconnection loop

package/src/workers/RecoveryWorker.js

@@ -90,6 +90,11 @@ class RecoveryWorker {
     // Use queue channel to create queue
     await this._client._ensureQueueChannel();
     
+    // Guard: ensure queue channel is available after ensure
+    if (!this._client._queueChannel || this._client._queueChannel.closed) {
+      throw new Error(`Cannot create queue ${queueName}: queue channel is not available (connection may be closed)`);
+    }
+    
     const queueOptions = options.queueOptions || { durable: this._client._config.durable };
     await this._client._queueChannel.assertQueue(queueName, queueOptions);
   }