@platform-x/hep-message-broker-client 1.1.21 → 1.1.23

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

@@ -367,7 +367,7 @@ class MessageBroker {
      * @param request - The request object containing the queue name and the message payload
      * @returns true if the message was published successfully, false otherwise
      */
-    publishMessage(request) {
+    publishMessage(classInstance, publishErrorHandler, publishRetryHandler, request) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             logger_1.Logger.info('Reached to publishMessage', 'publishMessage');
@@ -375,7 +375,7 @@ class MessageBroker {
             const retryDelayConfig = ((_a = message === null || message === void 0 ? void 0 : message.message) === null || _a === void 0 ? void 0 : _a.feed_type) === constants_1.RABBITMQ_FEED_TYPE.OVR ? RABBITMQ.OVR_TTL : RABBITMQ.ETX_TTL;
             const retryDelay = retryDelayConfig.split('|').map(Number);
             let attempt = 0;
-            while (attempt < maxRetries) {
+            while (attempt <= maxRetries) {
                 try {
                     yield this.checkConnectionAndChannel();
                     const messageBuffer = Buffer.from(JSON.stringify(message));
@@ -392,15 +392,29 @@ class MessageBroker {
                 catch (error) {
                     attempt++;
                     logger_1.Logger.error(`Attempt ${attempt} of ${maxRetries} failed in ${retryDelay[attempt - 1] / 1000}s...: ${error.message}`, 'publishMessage');
-                    if (attempt >= maxRetries) {
+                    if (attempt > maxRetries) {
                         logger_1.Logger.error('Max retries reached. Sending message to Dead Letter Queue...', 'publishMessage');
                         yield this.sendToDeadLetterQueue({ message, attempt });
+                        // Dead Letter Queue
+                        if (typeof classInstance[publishErrorHandler] === 'function') {
+                            classInstance[publishErrorHandler]({ message, retries: attempt });
+                        }
+                        else {
+                            logger_1.Logger.error(`Method ${publishErrorHandler} not found on classInstance`, 'publishMessage');
+                        }
                         logger_1.Logger.error(`Failed to publish message to queue ${queueName} after ${maxRetries} attempts`, 'publishMessage');
                         return false;
                     }
                     // Exponential backoff using TTL array
                     const delay = (_b = retryDelay[attempt - 1]) !== null && _b !== void 0 ? _b : retryDelay[retryDelay.length - 1];
                     logger_1.Logger.info(`Retrying in ${delay / 1000}s...`, 'publishMessage');
+                    // Retry Queue 3 times
+                    if (typeof classInstance[publishRetryHandler] === 'function') {
+                        classInstance[publishRetryHandler]({ message, retries: attempt });
+                    }
+                    else {
+                        logger_1.Logger.error(`Method ${publishRetryHandler} not found on classInstance`, 'publishMessage');
+                    }
                     yield new Promise(res => setTimeout(res, delay));
                 }
             }
@@ -440,14 +454,14 @@ class MessageBroker {
      * @param consumerHandler - Method name on classInstance to process each message
      * @param consumerErrorHandler - Method name on classInstance called when all retries fail
      */
-    initializeConsumers(classInstance, consumerHandler, consumerErrorHandler) {
+    initializeConsumers(classInstance, consumerHandler, consumerErrorHandler, consumerRetryHandler) {
         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;
                 for (const queueName in consumeQueues) {
                     if (Object.prototype.hasOwnProperty.call(consumeQueues, queueName)) {
-                        yield this.consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler);
+                        yield this.consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler, consumerRetryHandler);
                     }
                 }
             }
@@ -468,7 +482,7 @@ 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) {
+    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();
@@ -507,7 +521,7 @@ class MessageBroker {
                             this.channel.ack(message);
                         }
                         else {
-                            if (retryCount >= maxRetries) {
+                            if (retryCount > maxRetries) {
                                 logger_1.Logger.error('Max retries reached. Sending message to Dead Letter Queue.', 'consumeMessage');
                                 yield this.sendToDeadLetterQueue({ message: data, attempt: retryCount });
                                 if (typeof classInstance[consumerErrorHandler] === 'function') {
@@ -527,6 +541,13 @@ class MessageBroker {
                                 const delay = Number(retryDelay[delayIndex]);
                                 logger_1.Logger.info(`Retrying in ${delay / 1000} seconds... (attempt ${nextAttempt} of ${maxRetries} ${data.feed_type})`, 'consumeMessage');
                                 yield this.sendMessageToRetryQueue({ attempt: nextAttempt, data, retryDelayMs: delay, queueName });
+                                // retry call
+                                if (typeof classInstance[consumerRetryHandler] === 'function') {
+                                    yield classInstance[consumerRetryHandler](data);
+                                }
+                                else {
+                                    logger_1.Logger.error(`Method ${consumerRetryHandler} not found on classInstance`, 'consumeMessage');
+                                }
                                 this.channel.ack(message);
                             }
                         }

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

@@ -264,7 +264,7 @@ class MessageBrokerClient {
      * Funvction for initialize consumer queue
      * @param consumerQueues
      */
-    initializeConsumers(classInstance, consumerHandler, consumerErrorHandler, consumerRetryHandler) {
+    initializeConsumers(classInstance, consumerHandler, consumerErrorHandler) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 logger_1.Logger.info('Reached in initialize consumer', `initializeConsumers`);
@@ -273,7 +273,7 @@ class MessageBrokerClient {
                 for (let queueName in configData === null || configData === void 0 ? void 0 : configData.consume_queues) {
                     if (Object.prototype.hasOwnProperty.call(consume_queues, queueName)) {
                         // Call function Consume messages with retry
-                        yield this.consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler, consumerRetryHandler);
+                        yield this.consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler);
                     }
                 }
             }
@@ -328,7 +328,7 @@ class MessageBrokerClient {
      * Function to consume message with retry
      * @param queueName
      */
-    consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler, consumerRetryHandler) {
+    consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler) {
         return __awaiter(this, void 0, void 0, function* () {
             logger_1.Logger.info("Reached: Consuming messages from the queue", 'consumeMessage');
             let attempt = 0;
@@ -380,13 +380,6 @@ class MessageBrokerClient {
                                     let count = retry_delay.length === attempt ? retry_delay[retry_delay.length - 1] : retry_delay[attempt - 1];
                                     retryDelay = Number(count);
                                     yield this.sendMessageToRetryQueue(attempt, data, retryDelay, queueName);
-                                    // retry method
-                                    if (typeof classInstance[consumerRetryHandler] === 'function') {
-                                        yield classInstance[consumerRetryHandler](data); // Dynamically call the method
-                                    }
-                                    else {
-                                        logger_1.Logger.info(`Method ${consumerRetryHandler} not found in classInstance.`, 'consumerMessage');
-                                    }
                                     logger_1.Logger.info(`Retrying in ${retryDelay / 1000} seconds...`, 'consumeMessage');
                                     yield new Promise((resolve) => setTimeout(resolve, retryDelay));
                                 }

package/package.json

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