@platform-x/hep-message-broker-client 1.1.28 → 1.1.29

package/dist/src/config/index.js

@@ -2,7 +2,7 @@
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
 Object.defineProperty(exports, "__esModule", { value: true });
 const dotenv_1 = __importDefault(require("dotenv"));
 dotenv_1.default.config();
@@ -33,13 +33,14 @@ exports.default = {
         IS_ENABLED: (_p = process.env.RABBITMQ_IS_ENABLED) !== null && _p !== void 0 ? _p : 'true',
         RABBITMQ_CONFIG: (_q = process.env.RABBITMQ_CONFIG) !== null && _q !== void 0 ? _q : '',
         PREFETCH_COUNT: Number((_r = process.env.RABBITMQ_PREFETCH) !== null && _r !== void 0 ? _r : 50),
-        CONNECTION_ERROR: (_s = process.env.RABBITMQ_CONNECTION_ERROR) !== null && _s !== void 0 ? _s : false,
-        PUBLISHER_ERROR: (_t = process.env.RABBITMQ_PUBLISHER_ERROR) !== null && _t !== void 0 ? _t : false,
-        CONSUMER_ERROR: (_u = process.env.RABBITMQ_CONSUMER_ERROR) !== null && _u !== void 0 ? _u : false,
-        CONNECTION_RETRY_ERROR: (_v = process.env.RABBITMQ_RETRY_ENABLE_CONNECTION) !== null && _v !== void 0 ? _v : false,
-        PUBLISHER_RETRY_ERROR: (_w = process.env.RABBITMQ_RETRY_ENABLE_PUBLISH) !== null && _w !== void 0 ? _w : false,
-        CONSUMER_RETRY_ERROR: (_x = process.env.RABBITMQ_RETRY_ENABLE_CONSUMER) !== null && _x !== void 0 ? _x : false,
-        CONFIG_PATH: (_y = process.env.CONFIG_PATH) !== null && _y !== void 0 ? _y : '/etc/rabbitmq/rabbitMQConfig.json',
+        PREFETCH_COUNT_OVR: Number((_t = (_s = process.env.RABBITMQ_PREFETCH_OVR) !== null && _s !== void 0 ? _s : process.env.RABBITMQ_PREFETCH) !== null && _t !== void 0 ? _t : 50),
+        CONNECTION_ERROR: (_u = process.env.RABBITMQ_CONNECTION_ERROR) !== null && _u !== void 0 ? _u : false,
+        PUBLISHER_ERROR: (_v = process.env.RABBITMQ_PUBLISHER_ERROR) !== null && _v !== void 0 ? _v : false,
+        CONSUMER_ERROR: (_w = process.env.RABBITMQ_CONSUMER_ERROR) !== null && _w !== void 0 ? _w : false,
+        CONNECTION_RETRY_ERROR: (_x = process.env.RABBITMQ_RETRY_ENABLE_CONNECTION) !== null && _x !== void 0 ? _x : false,
+        PUBLISHER_RETRY_ERROR: (_y = process.env.RABBITMQ_RETRY_ENABLE_PUBLISH) !== null && _y !== void 0 ? _y : false,
+        CONSUMER_RETRY_ERROR: (_z = process.env.RABBITMQ_RETRY_ENABLE_CONSUMER) !== null && _z !== void 0 ? _z : false,
+        CONFIG_PATH: (_0 = process.env.CONFIG_PATH) !== null && _0 !== void 0 ? _0 : '/etc/rabbitmq/rabbitMQConfig.json',
     }
 };
 //# sourceMappingURL=index.js.map

package/dist/src/messageBroker/rabbitmq/MessageBroker.js

@@ -63,6 +63,7 @@ class MessageBroker {
     constructor() {
         this.connection = null;
         this.channel = null;
+        this.consumerChannels = new Map();
     }
     /**
      * Description: Checks if the RabbitMQ connection and channel are established.
@@ -458,12 +459,20 @@ class MessageBroker {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 logger_1.Logger.info('Reached in initialize consumers', 'initializeConsumers');
-                const consumeQueues = configData === null || configData === void 0 ? void 0 : configData.etg_consume_queues;
+                const consumeQueues = configData === null || configData === void 0 ? void 0 : configData.etg_consume_queues; // for etx feed
+                const consumesQueuesOVR = configData === null || configData === void 0 ? void 0 : configData.etg_consume_queues_ovr; // for ovr feed
+                // etx Queue
                 for (const queueName in consumeQueues) {
                     if (Object.prototype.hasOwnProperty.call(consumeQueues, queueName)) {
                         yield this.consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler, consumerRetryHandler);
                     }
                 }
+                // OVR Queues
+                for (const queueName in consumesQueuesOVR) {
+                    if (Object.prototype.hasOwnProperty.call(consumesQueuesOVR, queueName)) {
+                        yield this.consumeMessageOVR(queueName, classInstance, consumerHandler, consumerErrorHandler, consumerRetryHandler);
+                    }
+                }
             }
             catch (error) {
                 logger_1.Logger.error('Error initializing consumers:', 'initializeConsumers', error.message);
@@ -471,6 +480,61 @@ class MessageBroker {
             }
         });
     }
+    /**
+     * Description: Creates (or replaces) a dedicated channel for consuming a single queue and
+     * applies the given prefetch. Each consumer gets its own channel so its prefetch window and
+     * ack/nack traffic are isolated from other consumers and from the shared publish channel.
+     * @param queueName - Queue this channel will consume from (used as the tracking key)
+     * @param prefetch - Max unacknowledged messages allowed in flight on this channel
+     * @returns The dedicated consumer channel
+     */
+    createConsumerChannel(queueName, prefetch) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.checkConnectionAndChannel(); // Ensure the underlying connection is alive
+            // Replace any stale channel for this queue to avoid duplicate consumers.
+            const existing = this.consumerChannels.get(queueName);
+            if (existing) {
+                try {
+                    yield existing.close();
+                }
+                catch ( /* already closed */_a) { /* already closed */ }
+                this.consumerChannels.delete(queueName);
+            }
+            const consumerChannel = yield this.connection.createChannel();
+            yield consumerChannel.prefetch(prefetch);
+            consumerChannel.on('error', (err) => {
+                logger_1.Logger.error(`Consumer channel error for ${queueName}: ${err.message}`, 'createConsumerChannel');
+            });
+            consumerChannel.on('close', () => {
+                this.consumerChannels.delete(queueName);
+            });
+            this.consumerChannels.set(queueName, consumerChannel);
+            logger_1.Logger.info(`Dedicated consumer channel created for ${queueName} (prefetch: ${prefetch})`, 'createConsumerChannel');
+            return consumerChannel;
+        });
+    }
+    /**
+     * consumeMessageOVR is a specialized consumer for OVR queues. It delegates to consumeMessage to handle the actual message processing, retry logic, and error handling.
+     * @param queueName
+     * @param classInstance
+     * @param consumerHandler
+     * @param consumerErrorHandler
+     * @param consumerRetryHandler
+     */
+    consumeMessageOVR(queueName, classInstance, consumerHandler, consumerErrorHandler, consumerRetryHandler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.Logger.info('Reached in consumeMessageOVR', 'consumeMessageOVR');
+                // OVR consumption uses the same retry/ack/nack pipeline as consumeMessage; delegate to avoid
+                // duplicated logic, but with an OVR-specific prefetch so it can be tuned independently of ETX.
+                yield this.consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler, consumerRetryHandler, RABBITMQ.PREFETCH_COUNT_OVR);
+            }
+            catch (error) {
+                logger_1.Logger.error('Error consuming messages from OVR queue:', 'consumeMessageOVR', error.message);
+                throw new Error(error.message);
+            }
+        });
+    }
     /**
      * Description: Consumes messages from a queue with retry logic.
      *  - Success → ack
@@ -482,11 +546,13 @@ class MessageBroker {
      * @param consumerHandler - Method name invoked to process each message
      * @param consumerErrorHandler - Method name invoked when all retries fail
      */
-    consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler, consumerRetryHandler) {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger_1.Logger.info(`Reached: Consuming messages from queue ${queueName}`, 'consumeMessage');
-            yield this.checkConnectionAndChannel();
-            yield this.channel.consume(queueName, (message) => __awaiter(this, void 0, void 0, function* () {
+    consumeMessage(queueName_1, classInstance_1, consumerHandler_1, consumerErrorHandler_1, consumerRetryHandler_1) {
+        return __awaiter(this, arguments, void 0, function* (queueName, classInstance, consumerHandler, consumerErrorHandler, consumerRetryHandler, prefetch = prefetchCount) {
+            logger_1.Logger.info(`Reached: Consuming messages from queue ${queueName} (prefetch: ${prefetch})`, 'consumeMessage');
+            // Consume on a dedicated channel so this queue's prefetch window and
+            // ack/nack traffic are isolated from other consumers/publishers.
+            const consumerChannel = yield this.createConsumerChannel(queueName, prefetch);
+            yield consumerChannel.consume(queueName, (message) => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
                 if (!message)
                     return;
@@ -518,7 +584,7 @@ class MessageBroker {
                     if ((success === null || success === void 0 ? void 0 : success.isMatch) === true) {
                         if (success === null || success === void 0 ? void 0 : success.status) {
                             logger_1.Logger.info('Acknowledge the successful processing', 'consumeMessage');
-                            this.channel.ack(message);
+                            consumerChannel.ack(message);
                         }
                         else {
                             if (retryCount >= maxRetries) {
@@ -530,7 +596,7 @@ class MessageBroker {
                                 else {
                                     logger_1.Logger.error(`Method ${consumerErrorHandler} not found on classInstance`, 'consumeMessage');
                                 }
-                                this.channel.nack(message, false, false);
+                                consumerChannel.nack(message, false, false);
                             }
                             else {
                                 const nextAttempt = retryCount + 1;
@@ -548,7 +614,7 @@ class MessageBroker {
                                 else {
                                     logger_1.Logger.error(`Method ${consumerRetryHandler} not found on classInstance`, 'consumeMessage');
                                 }
-                                this.channel.ack(message);
+                                consumerChannel.ack(message);
                             }
                         }
                     }
@@ -562,7 +628,7 @@ class MessageBroker {
                     else {
                         logger_1.Logger.error(`Method ${consumerErrorHandler} not found on classInstance`, 'consumeMessage');
                     }
-                    this.channel.nack(message, false, false);
+                    consumerChannel.nack(message, false, false);
                 }
             }));
         });

package/dist/src/messageBroker/rabbitmq/MessageBrokerClient.js

@@ -71,10 +71,6 @@ let dlx_queue = RABBITMQ.DLX_QUEUE;
 // let retry_queue:string = RABBITMQ.RETRY_QUEUE;
 let connectionRetry = 1;
 let retryCountHeader = 'x-retry-count';
-let registeredConsumers = new Map();
-// Guards handleReconnect() so overlapping close/error events don't spawn
-// multiple concurrent reconnect loops.
-let isReconnecting = false;
 class MessageBrokerClient {
     // private readonly correlationId: string;
     // constructor() {
@@ -336,35 +332,9 @@ class MessageBrokerClient {
     consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler) {
         return __awaiter(this, void 0, void 0, function* () {
             logger_1.Logger.info("Reached: Consuming messages from the queue", 'consumeMessage');
-            // Remember this consumer so it can be re-attached after any reconnect or
-            // channel recreation. Keyed by queueName so repeated calls don't stack.
-            registeredConsumers.set(queueName, { queueName, classInstance, consumerHandler, consumerErrorHandler });
-            return yield this.subscribeConsumer(queueName, classInstance, consumerHandler, consumerErrorHandler);
-        });
-    }
-    ;
-    /**
-     * Function to attach a single consumer to a queue. Performs the actual
-     * channel.consume() and owns the ack/retry/DLQ logic. Kept separate from
-     * consumeMessage() so re-subscription (on reconnect) does not re-register
-     * the consumer in the registry, which would grow it unboundedly.
-     * @param queueName
-     * @param classInstance
-     * @param consumerHandler
-     * @param consumerErrorHandler
-     */
-    subscribeConsumer(queueName, classInstance, consumerHandler, consumerErrorHandler) {
-        return __awaiter(this, void 0, void 0, function* () {
             let attempt = 0;
             if (isConnectionOpen) {
-                // Capture the channel this consumer is registered on. acks/nacks for
-                // messages delivered here MUST go back to this same channel object —
-                // if the module-level `channel` is later reassigned (recreateChannel /
-                // createConnection), acking against the new channel raises
-                // PRECONDITION_FAILED ("unknown delivery tag") and closes it, taking
-                // every consumer down with it.
-                const ch = channel;
-                return yield ch.consume(queueName, (message) => __awaiter(this, void 0, void 0, function* () {
+                return yield channel.consume(queueName, (message) => __awaiter(this, void 0, void 0, function* () {
                     var _a;
                     if (message) {
                         logger_1.Logger.info(`Message received from queue ${queueName}: ${JSON.stringify(message)}`, 'consumeMessage');
@@ -401,7 +371,7 @@ class MessageBrokerClient {
                                         else {
                                             logger_1.Logger.info(`Method ${consumerErrorHandler} not found in classInstance.`, 'consumerMessage');
                                         }
-                                        this.safeNack(ch, message); // Move message to DLQ after failure
+                                        channel.nack(message, false, false); // Move message to DLQ after failure
                                         return false;
                                     }
                                     attempt++;
@@ -414,19 +384,13 @@ class MessageBrokerClient {
                                     retryDelay = Number(count);
                                     yield this.sendMessageToRetryQueue(attempt, data, retryDelay, queueName);
                                     logger_1.Logger.info(`Retrying in ${retryDelay / 1000} seconds...`, 'consumeMessage');
-                                    // Ack immediately once the message is safely on the retry
-                                    // queue. Do NOT block the delivery for the full TTL — the
-                                    // delay is enforced by the retry queue's own expiration.
-                                    // Holding it here risks breaching RabbitMQ's
-                                    // consumer_timeout and getting the channel cancelled.
-                                    this.safeAck(ch, message);
-                                    return;
+                                    yield new Promise((resolve) => setTimeout(resolve, retryDelay));
                                 }
                                 else {
                                     logger_1.Logger.info(`Acknowledge the successful processing`, 'consumeMessage');
                                 }
                                 // Acknowledge the successful processing
-                                this.safeAck(ch, message);
+                                channel.ack(message);
                             }
                         }
                         catch (error) {
@@ -440,7 +404,7 @@ class MessageBrokerClient {
                             else {
                                 logger_1.Logger.info(`Method ${consumerErrorHandler} not found in classInstance.`, 'consumerMessage');
                             }
-                            this.safeNack(ch, message); // Move message to DLQ after failure
+                            channel.nack(message, false, false); // Move message to DLQ after failure
                         }
                     }
                 }));
@@ -448,57 +412,6 @@ class MessageBrokerClient {
         });
     }
     ;
-    /**
-     * Function to re-attach every registered consumer. Called after each
-     * successful (re)connect and after a channel is recreated, so queues never
-     * end up with the connection alive but no consumer attached.
-     */
-    reregisterConsumers() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (registeredConsumers.size === 0) {
-                return;
-            }
-            logger_1.Logger.info(`Re-subscribing ${registeredConsumers.size} consumer(s) after (re)connect`, 'reregisterConsumers');
-            for (const c of registeredConsumers.values()) {
-                try {
-                    yield this.subscribeConsumer(c.queueName, c.classInstance, c.consumerHandler, c.consumerErrorHandler);
-                    logger_1.Logger.info(`Consumer re-subscribed on queue ${c.queueName}`, 'reregisterConsumers');
-                }
-                catch (error) {
-                    logger_1.Logger.error(`Failed to re-subscribe consumer on queue ${c.queueName}`, 'reregisterConsumers', error.message);
-                }
-            }
-        });
-    }
-    /**
-     * Function to ack a message against the channel it was delivered on, guarded
-     * so a stale delivery tag (channel already replaced) cannot throw and take
-     * down the current channel.
-     * @param ch the channel the message was consumed on
-     * @param message
-     */
-    safeAck(ch, message) {
-        try {
-            ch.ack(message);
-        }
-        catch (error) {
-            logger_1.Logger.error('Failed to ack message (stale channel?)', 'safeAck', error.message);
-        }
-    }
-    /**
-     * Function to nack a message against the channel it was delivered on, guarded
-     * against stale delivery tags. Never requeues (routes to DLQ).
-     * @param ch the channel the message was consumed on
-     * @param message
-     */
-    safeNack(ch, message) {
-        try {
-            ch.nack(message, false, false);
-        }
-        catch (error) {
-            logger_1.Logger.error('Failed to nack message (stale channel?)', 'safeNack', error.message);
-        }
-    }
     // /**
     //  * Function for consumer massage handler
     //  * @param request
@@ -792,17 +705,9 @@ class MessageBrokerClient {
                 // create channel
                 channel = yield connection.createConfirmChannel();
                 channel.prefetch(RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.PREFETCH_COUNT);
-                // Watch the channel itself: a channel-level fault (e.g. PRECONDITION_FAILED
-                // from a stale ack) closes the channel and cancels its consumers without
-                // closing the connection, so the connection 'close' path never fires.
-                this.bindChannelEventHandler();
                 logger_1.Logger.info('RabbitMQ connected successfully! ', 'createConnection');
                 // create exchange and queue and bind with exchange
                 yield this.setupQueuesAndExchanges();
-                // Re-attach any consumers registered before this (re)connect. Without
-                // this, after a reconnect the connection is healthy but no consumer is
-                // bound to the queues — the root cause of consumers "disappearing".
-                yield this.reregisterConsumers();
                 const connectionWrapper = { connection, channel };
                 return connectionWrapper;
             }
@@ -819,17 +724,21 @@ class MessageBrokerClient {
      */
     bindConnectionEventHandler() {
         try {
-            // 'error' always precedes 'close' from amqplib, so only 'close' drives the
-            // reconnect to avoid triggering it twice.
-            connection.on('error', (err) => {
-                var _a;
-                logger_1.Logger.error(`RabbitMQ: bindConnectionEventHandler:error`, `Connection error`, (_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err);
-            });
             connection.on('close', (err) => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                logger_1.Logger.error(`RabbitMQ: bindConnectionEventHandler:close`, `Connection closed`, (_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err);
+                logger_1.Logger.error(`RabbitMQ: bindConnectionEventHandler:close`, `Connection closed`, err);
                 isConnectionOpen = false;
-                yield this.handleReconnect();
+                if (connectionRetry <= maxRetries) {
+                    yield this.createConnection();
+                    connectionRetry++;
+                }
+            }));
+            connection.on('error', (err) => __awaiter(this, void 0, void 0, function* () {
+                logger_1.Logger.error(`RabbitMQ: bindConnectionEventHandler:error`, `Connection error`, err);
+                isConnectionOpen = false;
+                if (connectionRetry <= maxRetries) {
+                    yield this.createConnection();
+                    connectionRetry++;
+                }
             }));
             return isConnectionOpen;
         }
@@ -838,84 +747,6 @@ class MessageBrokerClient {
             return isConnectionOpen;
         }
     }
-    /**
-     * Function to bind channel-level event handlers. A channel can be cancelled
-     * (e.g. PRECONDITION_FAILED, consumer_timeout) while the connection stays up;
-     * in that case the connection 'close' handler never fires, so the channel is
-     * recreated and consumers re-attached here.
-     */
-    bindChannelEventHandler() {
-        try {
-            channel.on('error', (err) => {
-                var _a;
-                logger_1.Logger.error(`RabbitMQ: bindChannelEventHandler:error`, `Channel error`, (_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err);
-            });
-            channel.on('close', () => __awaiter(this, void 0, void 0, function* () {
-                logger_1.Logger.error(`RabbitMQ: bindChannelEventHandler:close`, `Channel closed`);
-                // Only self-heal the channel while the connection is still open. If the
-                // connection is down, handleReconnect() owns recovery (and will recreate
-                // the channel + consumers), so doing it here too would double-subscribe.
-                if (isConnectionOpen && !isReconnecting) {
-                    try {
-                        yield this.recreateChannel();
-                        this.bindChannelEventHandler();
-                        yield this.reregisterConsumers();
-                        logger_1.Logger.info('Channel and consumers recovered after channel close', 'bindChannelEventHandler');
-                    }
-                    catch (error) {
-                        logger_1.Logger.error('Failed to recover channel after close', 'bindChannelEventHandler', error.message);
-                    }
-                }
-            }));
-        }
-        catch (error) {
-            logger_1.Logger.error('Error in bindChannelEventHandler', 'bindChannelEventHandler', error.message);
-        }
-    }
-    /**
-     * Function to reconnect to RabbitMQ with capped exponential backoff. Unlike
-     * the old logic — which capped total lifetime reconnects at MAX_RETRIES and
-     * never reset the counter — this retries indefinitely and resets on success,
-     * so the service self-heals from every disconnect. createConnection()
-     * re-attaches all registered consumers on success.
-     */
-    handleReconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (isReconnecting) {
-                logger_1.Logger.info('Reconnect already in progress, skipping duplicate trigger', 'handleReconnect');
-                return;
-            }
-            isReconnecting = true;
-            connectionRetry = 1;
-            // Backoff schedule derived from the TTL config, capped at its last value.
-            const backoffs = (retry_delay !== null && retry_delay !== void 0 ? retry_delay : []).map(Number).filter((n) => !Number.isNaN(n) && n > 0);
-            const maxBackoff = backoffs.length ? backoffs[backoffs.length - 1] : 30000;
-            try {
-                while (!isConnectionOpen) {
-                    const delay = (_a = backoffs[connectionRetry - 1]) !== null && _a !== void 0 ? _a : maxBackoff;
-                    logger_1.Logger.info(`Reconnect attempt ${connectionRetry} in ${delay / 1000}s...`, 'handleReconnect');
-                    yield new Promise(resolve => setTimeout(resolve, delay));
-                    try {
-                        yield this.createConnection();
-                        if (isConnectionOpen) {
-                            connectionRetry = 1;
-                            logger_1.Logger.info('Reconnected to RabbitMQ successfully', 'handleReconnect');
-                            return;
-                        }
-                        throw new Error('createConnection did not establish an open connection');
-                    }
-                    catch (error) {
-                        logger_1.Logger.error(`Reconnect attempt ${connectionRetry} failed`, 'handleReconnect', error.message);
-                        connectionRetry++;
-                    }
-                }
-            }
-            finally {
-                isReconnecting = false;
-            }
-        });
-    }
 }
 exports.MessageBrokerClient = MessageBrokerClient;
 //# sourceMappingURL=MessageBrokerClient.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@platform-x/hep-message-broker-client",
-    "version": "1.1.28",
+    "version": "1.1.29",
     "description": "platform-x hep-message-broker service",
     "main": "./dist/src/index.js",
     "scripts": {