@onlineapps/mq-client-core 1.0.79 → 1.0.81

package/package.json

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

package/src/config/queueConfig.js

@@ -249,6 +249,7 @@ module.exports = {
   monitoring: {
     /**
      * monitoring.workflow - Unified workflow lifecycle monitoring
+     * Bound to monitoring.workflow.fanout exchange (fanout).
      * Delivery Dispatcher publishes 'completed'/'failed' events after processing workflow.completed/workflow.failed
      * Business services publish 'progress' events during workflow step processing
      * Message format includes event_type: 'completed' | 'failed' | 'progress'
@@ -277,6 +278,73 @@ module.exports = {
         'x-message-ttl': 600000,      // 10 minutes TTL (longer for service tracking)
         'x-max-length': 20000
       }
+    },
+
+    /**
+     * monitoring.workflow.fanout - Fanout exchange for workflow events
+     * Publishers send to this exchange; monitoring.workflow + delivery.workflow.events both receive copies.
+     */
+    'workflow.fanout': {
+      type: 'exchange',
+      exchangeType: 'fanout',
+      durable: true
+    }
+  },
+
+  /**
+   * Delivery endpoint event queue configurations
+   * These are queues consumed by api_delivery_endpoint for real-time WS push.
+   */
+  deliveryEvents: {
+    /**
+     * delivery.workflow.events - Workflow progress events for WS clients
+     * Bound to monitoring.workflow.fanout exchange.
+     */
+    'workflow.events': {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 60000,       // 60s TTL - real-time events, stale ones are useless
+        'x-max-length': 10000
+      }
+    },
+
+    /**
+     * delivery.health.events - Infrastructure health events for WS clients
+     * Bound to infrastructure.health.events exchange.
+     */
+    'health.events': {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 60000,
+        'x-max-length': 5000
+      }
+    },
+
+    /**
+     * delivery.alert.events - Alert events for WS clients
+     * Bound to alert.events.fanout exchange.
+     */
+    'alert.events': {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 300000,      // 5 minutes - alerts are more important
+        'x-max-length': 5000
+      }
+    }
+  },
+
+  /**
+   * Alert exchange configuration
+   */
+  alerts: {
+    /**
+     * alert.events.fanout - Fanout exchange for alert events
+     * Monitoring watchdogs publish alerts here; delivery.alert.events consumes copies.
+     */
+    'events.fanout': {
+      type: 'exchange',
+      exchangeType: 'fanout',
+      durable: true
     }
   },
 

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/monitoring-publish.js

@@ -103,7 +103,11 @@ async function publishToMonitoringResilient(mqClient, queueName, message, logger
   }
 
   try {
-    await mqClient.publish(queueName, message);
+    const WORKFLOW_FANOUT = 'monitoring.workflow.fanout';
+    const publishOptions = queueName === 'monitoring.workflow'
+      ? { exchange: WORKFLOW_FANOUT, exchangeType: 'fanout', routingKey: '' }
+      : {};
+    await mqClient.publish(queueName, message, publishOptions);
     
     if (logger && logger.debug) {
       logger.debug(`Published to ${queueName}`, {

package/src/transports/rabbitmqClient.js

@@ -1258,7 +1258,8 @@ class RabbitMQClient extends EventEmitter {
     // Track operation for debugging
     this._trackChannelOperation(this._channel, `publish to ${queue}`);
     
-    const exchange = this._config.exchange || '';
+    const exchange = options.exchange || this._config.exchange || '';
+    const exchangeType = options.exchangeType || 'direct';
     const routingKey = options.routingKey || queue;
     const persistent = options.persistent !== undefined ? options.persistent : this._config.durable;
     const headers = options.headers || {};
@@ -1473,7 +1474,7 @@ class RabbitMQClient extends EventEmitter {
       } else {
         // If exchange is specified, assert exchange and publish to it
         // Channel is guaranteed to be open (ensured above)
-        await this._channel.assertExchange(exchange, 'direct', { durable: this._config.durable });
+        await this._channel.assertExchange(exchange, exchangeType, { durable: this._config.durable });
         
         // Use callback-based confirmation - kanály jsou spolehlivé
         const confirmPromise = new Promise((resolve, reject) => {
@@ -1552,16 +1553,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
@@ -1600,28 +1602,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;
         }
@@ -1663,6 +1682,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 || {};
@@ -1690,7 +1717,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',
@@ -1708,9 +1751,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}`);
@@ -2182,6 +2225,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;
     }
@@ -2200,6 +2248,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;
     }