@onlineapps/mq-client-core 1.0.80 → 1.0.82

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/mq-client-core",
-  "version": "1.0.80",
+  "version": "1.0.82",
   "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/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) => {
@@ -1715,25 +1716,23 @@ class RabbitMQClient extends EventEmitter {
         try {
           await onMessage(msg);
           // Acknowledge message after successful processing
-          if (!noAck) {
-            // Only ack on the original channel instance; if it's gone/closed, do not attempt ack.
+          if (!noAck && !msg._mqProcessed) {
             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);
+              msg._mqProcessed = true;
             } 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')) {
+                msg._mqProcessed = true;
                 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',
               function: 'RabbitMQClient.consume',
@@ -1741,7 +1740,6 @@ class RabbitMQClient extends EventEmitter {
               output: { status: 'acknowledged', queue }
             });
 
-            // Track ack (decrement in-flight)
             if (tracking) {
               tracking.inFlight = Math.max(0, tracking.inFlight - 1);
               tracking.lastCheck = Date.now();
@@ -1749,16 +1747,16 @@ class RabbitMQClient extends EventEmitter {
           }
         } catch (handlerErr) {
           // Negative acknowledge and requeue by default
-          // Check if channel is still valid before nacking
-          if (channelForMsg && !channelForMsg.closed) {
+          // Skip if already acked/nacked by the handler (prevents double ack → 406)
+          if (!msg._mqProcessed && channelForMsg && !channelForMsg.closed) {
             try {
               channelForMsg.nack(msg, false, true);
+              msg._mqProcessed = true;
             } catch (nackErr) {
-              // Channel may have closed during nack - ignore
+              msg._mqProcessed = true;
               console.warn(`[RabbitMQClient] [mq-client-core] Failed to nack message (channel may be closed): ${nackErr.message}`);
             }
           }
-          // Track nack (decrement in-flight)
           if (tracking) {
             tracking.inFlight = Math.max(0, tracking.inFlight - 1);
             tracking.lastCheck = Date.now();
@@ -2218,14 +2216,19 @@ class RabbitMQClient extends EventEmitter {
    * @param {Object} msg - RabbitMQ message object.
    */
   async ack(msg) {
+    if (msg._mqProcessed) {
+      return; // Already acked/nacked — idempotent
+    }
     if (!this._consumerChannel) {
       throw new Error('Cannot ack: consumer channel is not initialized');
     }
     try {
       this._consumerChannel.ack(msg);
+      msg._mqProcessed = true;
     } catch (err) {
       const m = err && err.message ? err.message : '';
       if (m.includes('unknown delivery tag') || m.includes('PRECONDITION_FAILED') || m.includes('Channel closed')) {
+        msg._mqProcessed = true;
         console.warn('[RabbitMQClient] [mq-client-core] Cannot ack - consumer channel is closed/recreated (delivery tag invalid)', { error: m });
         return;
       }
@@ -2240,15 +2243,20 @@ class RabbitMQClient extends EventEmitter {
    * @param {Object} [options] - { requeue: boolean }.
    */
   async nack(msg, options = {}) {
+    if (msg._mqProcessed) {
+      return; // Already acked/nacked — idempotent
+    }
     if (!this._consumerChannel) {
       throw new Error('Cannot nack: consumer channel is not initialized');
     }
     const requeue = options.requeue !== undefined ? options.requeue : true;
     try {
       this._consumerChannel.nack(msg, false, requeue);
+      msg._mqProcessed = true;
     } catch (err) {
       const m = err && err.message ? err.message : '';
       if (m.includes('unknown delivery tag') || m.includes('PRECONDITION_FAILED') || m.includes('Channel closed')) {
+        msg._mqProcessed = true;
         console.warn('[RabbitMQClient] [mq-client-core] Cannot nack - consumer channel is closed/recreated (delivery tag invalid)', { error: m });
         return;
       }