@platform-x/hep-message-broker-client 1.0.1 → 1.0.2

package/dist/src/config/index.js

@@ -32,7 +32,7 @@ exports.default = {
         CONNECTION_ERROR: (_q = process.env.RABBITMQ_CONNECTION_ERROR) !== null && _q !== void 0 ? _q : false,
         PUBLISHER_ERROR: (_r = process.env.RABBITMQ_PUBLISHER_ERROR) !== null && _r !== void 0 ? _r : false,
         CONSUMER_ERROR: (_s = process.env.RABBITMQ_CONSUMER_ERROR) !== null && _s !== void 0 ? _s : false,
-        CONFIG_PATH: (_t = process.env.CONFIG_PATH) !== null && _t !== void 0 ? _t : '/etc/rabbitmq/rabbitMQConfig.json',
+        CONFIG_PATH: (_t = process.env.CONFIG_PATH) !== null && _t !== void 0 ? _t : "C:/platform-X/rabbitMQConfig.json",
     }
 };
 //# sourceMappingURL=index.js.map

package/dist/src/messageBroker/rabbitmq/MessageBrokerClient.d.ts

@@ -32,7 +32,7 @@ export declare class MessageBrokerClient {
       * @param messagePublisherErrorHandler
       * @returns
     */
-    publishMessageToExchange(request: PublishMessageInputType): Promise<true | undefined>;
+    publishMessageToExchange(request: PublishMessageInputType): Promise<boolean>;
     /**
      * Funciton to message handler
      */
@@ -62,7 +62,7 @@ export declare class MessageBrokerClient {
      * @param queueName
      * @retruns
      */
-    sendMessageToDeadLatter(attempt: number, data: any): Promise<boolean | undefined>;
+    sendMessageToDeadLatter(attempt: number, data: any): Promise<boolean>;
     /***
      * Function to send message to retry queue
      * @param attempt
@@ -79,6 +79,14 @@ export declare class MessageBrokerClient {
      * @returns
      */
     findQueueAndExchange(queueName: string, exchangeName: string): Promise<void>;
+    /**
+      * Function to check connection and channel
+    */
+    private checkConnectionAndChannel;
+    /**
+      * Function to recreate channel
+    */
+    private recreateChannel;
     /**
       * Function to setup the queues and exchanges
       * @params array

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

@@ -199,67 +199,55 @@ class MessageBrokerClient {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             logger_1.Logger.info('Reached:publishMessageToExchange', 'publishMessageToExchange');
-            // Publish the message
-            // Logger.debug('Reached:publishMessageToExchange', 'publishMessageToExchange',{classInstance, messagePublisherErrorHandler});
+            let attempt = 0;
+            const exchangeName = (_a = request === null || request === void 0 ? void 0 : request.exchangeName) !== null && _a !== void 0 ? _a : '';
+            const queueName = request.queueName;
+            const data = request === null || request === void 0 ? void 0 : request.message;
+            const messageBuffer = Buffer.from(JSON.stringify(data.message));
             try {
-                if (isConnectionOpen) {
-                    logger_1.Logger.info('Connection is open, continue to message publish', 'publishMessageToExchange');
-                    // let attempt: number = 0;
-                    const exchangeName = (_a = request === null || request === void 0 ? void 0 : request.exchangeName) !== null && _a !== void 0 ? _a : '';
-                    const queueName = request.queueName;
-                    const data = request === null || request === void 0 ? void 0 : request.message;
-                    // const options:object | null = request?.options; // Optional parameter for retry count if you wnats to override the default retry count
-                    const messageBuffer = Buffer.from(JSON.stringify(data.message));
-                    // let retries: number = typeof data.message === 'object' && data.message !== null ? (data.message as { retries: number }).retries ?? 0 : 0;
-                    // while (attempt < maxRetries) {
-                    const isSent = yield new Promise((resolve, reject) => {
-                        const sent = channel.publish(exchangeName, queueName, messageBuffer, {
-                            persistent: true, // Ensures the message is persisted
-                            // correlationId: this.correlationId,
+                // 1. Ensure connection and channel exists
+                yield this.checkConnectionAndChannel();
+                // 2. Retry loop
+                while (attempt < maxRetries) {
+                    try {
+                        logger_1.Logger.info(`Attempting to publish message`, 'publishMessageToExchange');
+                        let sent = channel.publish(exchangeName, queueName, messageBuffer, {
+                            persistent: true,
                         });
-                        logger_1.Logger.info(`Message sent on exchange status ${sent}`, 'publishMessageToExchange');
-                        if (sent) {
-                            logger_1.Logger.debug(`Message sent successfully`, 'publishMessageToExchange', { data, queueName });
-                            resolve(true);
+                        // if(attempt <1){ sent = false}else{sent = true} // Simulate failure for testing retry logic
+                        if (sent && (RABBITMQ.PUBLISHER_ERROR !== 'true' && RABBITMQ.PUBLISHER_ERROR !== true)) {
+                            logger_1.Logger.info(`Message published successfully on attempt ${attempt + 1}`, 'publishMessageToExchange');
+                            logger_1.Logger.info(`✅ Message sent successfully`, 'publishMessageToExchange');
+                            break;
                         }
                         else {
-                            logger_1.Logger.error(`Failed to publish message to exchange.`, 'publishMessageToExchange', { message: messageBuffer.toString() });
-                            reject(false);
+                            throw new Error('Publish returned false');
+                        }
+                    }
+                    catch (error) {
+                        attempt++;
+                        logger_1.Logger.error(`Failed attempt ${attempt} to publish message`, 'publishMessageToExchange', error);
+                        if (attempt < maxRetries) {
+                            logger_1.Logger.info(`Retrying in ${retry_delay}ms...`, 'publishMessageToExchange');
+                            yield new Promise(res => setTimeout(res, retry_delay));
+                        }
+                        else {
+                            logger_1.Logger.error(`Error in publishMessageToExchange: ${error}`, 'publishMessageToExchange');
+                            throw new Error('Max retries reached');
                         }
-                    });
-                    logger_1.Logger.info(`Message publish attempt completed status ${isSent}`, 'publishMessageToExchange');
-                    if ((isSent) && (RABBITMQ.PUBLISHER_ERROR !== 'true' && RABBITMQ.PUBLISHER_ERROR !== true)) {
-                        logger_1.Logger.info(`Message published successfully`, 'publishMessageToExchange');
-                        return isSent;
                     }
-                    // else{
-                    //   let queueName = (request as PublishMessageInputType)?.queueName
-                    //   if (attempt >= maxRetries) {
-                    //     Logger.error('Max retries reached. Failed to publish message.', 'publishMessageToExchange', request);
-                    //     // Optionally: Log or persist the failed message to a DB, file, or other storage for manual intervention
-                    //     this.sendMessageToDeadLatter(attempt, data, queueName);
-                    //     this.messagePublisherErrorHandler(request); // we need to comment this line
-                    // if (typeof classInstance[messagePublisherErrorHandler] === 'function') {
-                    //   classInstance[messagePublisherErrorHandler](data); // Dynamically call the method
-                    // } else {
-                    //   Logger.info(`Method ${messagePublisherErrorHandler} not found in classInstance.`, 'publishMessageToExchange');
-                    // }
-                    //     return false;
-                    //   }else{
-                    //     await this.publishMessageRetryQueue(request, (attempt+1));
-                    //     attempt++;
-                    //   }
-                    // }
-                    // }
                 }
+                return true;
             }
             catch (error) {
-                logger_1.Logger.error(`Error sending message: ${error}`, 'sendMessage');
-                throw new Error("Failed to publish message to exchange");
+                logger_1.Logger.error('Max retries reached. Sending message to Dead Letter Queue...', 'publishMessageToExchange');
+                yield this.sendMessageToDeadLatter(attempt, data);
+                const customError = new Error('Failed to publish message to exchange');
+                customError.originalError = error; // optional
+                throw customError;
             }
         });
     }
-    ;
     /**
      * Funciton to message handler
      */
@@ -444,19 +432,31 @@ class MessageBrokerClient {
      */
     sendMessageToDeadLatter(attempt, data) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.Logger.info("Reached: send message on dead later queue", 'sendMessageToDeadLater');
+            logger_1.Logger.info("Reached: send message on dead letter queue", 'sendMessageToDeadLater');
             try {
                 if (isConnectionOpen) {
-                    return channel.sendToQueue(dlx_queue, Buffer.from(JSON.stringify(data)), {
+                    logger_1.Logger.info(`Attempting to send message to DLX queue: ${dlx_queue} (attempt: ${attempt}, retry-count: ${attempt - 1}, size: ${JSON.stringify(data).length} bytes)`, 'sendMessageToDeadLater');
+                    const sent = channel.sendToQueue(dlx_queue, Buffer.from(JSON.stringify(data)), {
                         persistent: true,
                         headers: {
                             'x-retry-count': attempt - 1
                         },
                     });
+                    if (sent) {
+                        logger_1.Logger.info(`Message successfully published to DLX queue: ${dlx_queue} (attempt: ${attempt}, retry-count: ${attempt - 1})`, 'sendMessageToDeadLater');
+                    }
+                    else {
+                        logger_1.Logger.error(`Failed to publish message to DLX queue: ${dlx_queue} - Channel buffer full (attempt: ${attempt}, retry-count: ${attempt - 1})`, 'sendMessageToDeadLater');
+                    }
+                    return sent;
+                }
+                else {
+                    logger_1.Logger.error(`Cannot send message to DLX - Connection is not open (queue: ${dlx_queue}, attempt: ${attempt})`, 'sendMessageToDeadLater');
+                    return false;
                 }
             }
             catch (error) {
-                logger_1.Logger.error("Error in send message on dead later queue", 'sendMessageToDeadLater', { message: error.message });
+                logger_1.Logger.error(`Error sending message to dead letter queue: ${error.message} (queue: ${dlx_queue}, attempt: ${attempt})`, 'sendMessageToDeadLater');
                 throw error;
             }
         });
@@ -544,6 +544,40 @@ class MessageBrokerClient {
             }
         });
     }
+    /**
+      * Function to check connection and channel
+    */
+    checkConnectionAndChannel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info('Reached: checkConnectionAndChannel', 'checkConnectionAndChannel');
+            // 🧪 1. Ensure connection exists
+            if (!isConnectionOpen) {
+                logger_1.Logger.warn('No connection found. Creating new connection...', 'publishMessageToExchange');
+                yield this.createConnection();
+            }
+            // 🧪 2. Ensure channel is alive
+            const channelConnection = channel === null || channel === void 0 ? void 0 : channel.connection;
+            if (!channel || !channelConnection || channelConnection.stream.destroyed) {
+                logger_1.Logger.warn('Channel seems dead, recreating before publish...', 'publishMessageToExchange');
+                yield this.recreateChannel();
+            }
+        });
+    }
+    /**
+      * Function to recreate channel
+    */
+    recreateChannel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                channel = yield connection.createConfirmChannel();
+                channel.prefetch(RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.PREFETCH_COUNT);
+                logger_1.Logger.info(' Channel recreated successfully.', 'recreateChannel');
+            }
+            catch (err) {
+                logger_1.Logger.error(' Failed to recreate channel:', err);
+            }
+        });
+    }
     /**
       * Function to setup the queues and exchanges
       * @params array

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@platform-x/hep-message-broker-client",
-    "version": "1.0.1",
+    "version": "1.0.2",
     "description": "@platform-x/hep-message-broker-client",
     "main": "./dist/src/index.js",
     "scripts": {
@@ -37,4 +37,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}