@platform-x/hep-message-broker-client 1.1.24 → 1.1.26

package/src/messageBroker/rabbitmq/MessageBrokerClient.ts

@@ -0,0 +1,685 @@
+// Import the amqplib library for RabbitMQ
+import * as amqp from 'amqplib';
+import config from '../../config';
+import { Logger } from '../../Util/logger';
+import ConnectionWrapper from '../interface/ConnectionWrapper';
+import ConfigManager from '../../config/ConfigManager';
+import { PublishMessageInputType } from '../types/PublishMessageInputType';
+import MessageModel from '../../models/MessageModel';
+import { ActionType } from '../types/ActionType';
+import { SECRET_KEYS } from '../../Util/constants';
+import { getIAMSecrets } from '../..';
+// Remove lodash delay import
+let configManager: ConfigManager = ConfigManager.getInstance();
+// Declare variables for the connection and channel
+let connection: amqp.Connection;
+let channel: amqp.Channel;
+// Declare variable for check connection
+let isConnectionOpen = false;
+
+let configData: any = {};
+const RABBITMQ = config?.RABBITMQ;
+let maxRetries: number = RABBITMQ?.MAX_RETRIES;
+let retry_delay: any = RABBITMQ?.TTL?.split("|"); 
+// let dlx_exchange:string = RABBITMQ.DLX_EXCHANGE;
+let dlx_queue:string = RABBITMQ.DLX_QUEUE;
+// let retry_exchange:string = RABBITMQ.RETRY_EXCHANGE;
+// let retry_queue:string = RABBITMQ.RETRY_QUEUE;
+let connectionRetry:number = 1;
+let retryCountHeader = 'x-retry-count';
+export class MessageBrokerClient {
+
+  // private readonly correlationId: string;
+  // constructor() {
+    // this.correlationId = generateCorrelationId();
+  // }
+
+  /**
+    * Function to check the status of the connection
+    * @returns boolean
+  */
+  public async isConnected(): Promise<boolean> {
+    return isConnectionOpen;
+  };
+
+
+  /**
+    * Function to initialize the connection, channel and setup the queues and exchanges
+    * @param reqData
+    * @returns 
+  */
+  public async initialize() {
+    Logger.info('Reached to initialize', 'initialize');
+    configData = configManager.getConfig();
+    // dlx_exchange = configData?.dlx_exchange;
+    dlx_queue = configData?.dlx_queue;
+    // retry_exchange = configData?.retry_exchange;
+    // retry_queue = configData?.retry_queue;
+    let retries: number = 0;
+    // Retrie times connection 
+    while (retries < maxRetries) {
+      try {
+        if(RABBITMQ.CONNECTION_ERROR === 'true' || RABBITMQ.CONNECTION_ERROR === true){
+          throw new Error("Error in connection");
+        }
+        await this.createConnection();
+        return { connection: connection, channel: channel };
+      } catch (err) {
+        retries++;
+        Logger.error('initialize:Failed to connect to RabbitMQ', `Attempt ${retries} of ${maxRetries}.`);
+        if (retries >= maxRetries) {
+          Logger.error('Max retries reached, cannot connect to RabbitMQ.', 'initialize');
+          return { connection, channel };
+        }
+        // Wait before retrying (e.g., 10 seconds)
+        await new Promise(resolve => setTimeout(resolve, 10000));
+      }
+    }
+  };
+
+
+
+  /**
+    * Function to publish a message with retry
+    * @param request 
+    * @param classInstance
+    * @param messagePublisherErrorHandler 
+    * @returns 
+  */
+  public async publishMessage(
+    request: PublishMessageInputType
+    // , classInstance:any, messagePublisherErrorHandler:string
+    ){
+    Logger.info('Reached:publishMessage', 'publishMessage');
+    // Logger.debug('Reached:publishMessageToExchange', 'publishMessageToExchange',{classInstance, messagePublisherErrorHandler});
+    try{  
+      if(isConnectionOpen){
+        Logger.info('Check connection open or not', 'publishMessage');
+        const queueName: string = request.queueName;
+        const data: MessageModel = request.message;
+        const messageBuffer = Buffer.from(JSON.stringify(data?.message));
+        // let attempt: number = 0;
+        // let retries: number = typeof data.message === 'object' && data.message !== null ? (data.message as { retries: number }).retries ?? 0 : 0;
+        // while (attempt < maxRetries ) {
+        Logger.info('Max retries check', 'publishMessage');
+        const isSent = await new Promise<boolean>((resolve, reject) => {
+          let sent = channel.sendToQueue(queueName, Buffer.from(messageBuffer), {
+            persistent: true, // Ensures the message is persisted
+            // correlationId: this.correlationId,
+          });
+          if (sent) {
+            Logger.debug(`Message sent successfully`, 'publishMessage', { data, queueName });
+            resolve(true);
+          } else {
+            Logger.error(`Failed to publish message.`, 'publishMessage', { message: messageBuffer.toString() });
+            reject(false);
+          }
+        });
+        if((isSent) && (RABBITMQ.PUBLISHER_ERROR !== 'true' && RABBITMQ.PUBLISHER_ERROR !== true)){
+          return isSent;
+        }
+        // else{
+        //   let queueName = (request as PublishMessageInputType)?.queueName
+        //   if (attempt >= maxRetries) {
+        //     Logger.error('Max retries reached. Failed to publish message.', 'publishMessage', 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.`, 'publishMessage');
+          // }
+        //     return false;
+        //   }else{
+        //     await this.publishMessageRetryQueue(request, attempt); 
+        //     attempt++;
+        //   }
+        // }
+      // }
+      
+      }
+    } catch (error) {
+      Logger.error(`Error sending message: ${error}`, 'sendMessage');
+      throw new Error("Failed to publish message to queue");
+    }
+  }
+
+  /**
+    * Function to publish a message with retry
+    * @param request 
+    * @param classInstance
+    * @param messagePublisherErrorHandler
+    * @returns 
+  */
+  public async publishMessageToExchange(request: PublishMessageInputType): Promise<boolean> {
+    Logger.info('Reached:publishMessageToExchange', 'publishMessageToExchange');
+    let attempt = 0;
+    const exchangeName: string | undefined = request?.exchangeName ?? '';
+    const queueName: string = request.queueName;
+    const data: MessageModel = request?.message;
+    const messageBuffer = Buffer.from(JSON.stringify(data.message));
+    try {
+      // 1. Ensure connection and channel exists
+     await this.checkConnectionAndChannel();
+
+      // 2. Retry loop
+      while (attempt < maxRetries) {
+        try {
+          Logger.info(`Attempting to publish message`, 'publishMessageToExchange');
+          let sent = channel.publish(exchangeName, queueName, messageBuffer, {
+            persistent: 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.info(`Message published successfully on attempt ${attempt + 1}`, 'publishMessageToExchange');
+            Logger.info(`✅ Message sent successfully`, 'publishMessageToExchange');
+            break;
+          } else {
+            throw new Error('Publish returned false');
+          }
+        } catch (error) {
+          attempt++;
+          Logger.error(`Failed attempt ${attempt} to publish message`, 'publishMessageToExchange', error);
+          if (attempt < maxRetries) {
+            Logger.info(`Retrying in ${retry_delay}ms...`, 'publishMessageToExchange');
+            await new Promise(res => setTimeout(res, retry_delay));
+          }else {
+            Logger.error(`Error in publishMessageToExchange: ${error}`, 'publishMessageToExchange');
+            throw new Error('Max retries reached');
+          }
+        }
+      }
+      return true;
+    } catch (error) {
+      Logger.error('Max retries reached. Sending message to Dead Letter Queue...', 'publishMessageToExchange');
+      await this.sendMessageToDeadLatter(attempt, data);
+      const customError = new Error('Failed to publish message to exchange');
+      (customError as any).originalError = error; // optional
+      throw customError;
+    }
+  }
+  /**
+   * Funciton to message handler
+   */
+  // TO Do rename function name messagePublisherErrorHandler
+  public async messagePublisherErrorHandler(request: PublishMessageInputType): Promise<boolean> {
+    Logger.info(`${JSON.stringify(request)}`, 'messagePublisherErrorHandler');
+    return Promise.resolve(true);
+  }
+
+  /**
+   * Funvction for initialize consumer queue
+   * @param consumerQueues
+   */
+  public async initializeConsumers(classInstance:any, consumerHandler:string, consumerErrorHandler:string,serviceConsumerQueues?: {}) {
+    try {
+      Logger.info('Reached in initialize consumer', `initializeConsumers`);
+      Logger.debug('Consumer queues serviceConsumerQueues : ', 'initializeConsumers', { serviceConsumerQueues });
+
+      let consume_queues = serviceConsumerQueues ?? configData?.consume_queues;
+      // Consume messages from all queues
+      for (let queueName in consume_queues) {
+        if (Object.prototype.hasOwnProperty.call(consume_queues, queueName)) {
+          // Call function Consume messages with retry
+          await this.consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler,);
+        }
+      }
+    } catch (error: unknown) {
+      Logger.error('Error initializing consumers:', 'initializeConsumers', (error as Error).message);
+      throw new Error((error as Error).message);
+    }
+  }
+
+  /**
+       * Function for perform action with retry
+       * @param actionHandler 
+       * @param context 
+       * @param failActionHandler 
+       * @returns 
+       */
+  public async performActionWithRetry<T>(actionHandler: ActionType<T>,  failActionHandler: ActionType<T>, context: T): Promise<boolean> {
+    Logger.info("Reached: in perform action with retry ", "performActionWithRetry")
+    let attempt: number = 0;
+    while (attempt < maxRetries) {
+      try {
+        actionHandler(context);
+        return true;
+      } catch (error) {
+        attempt++;
+        Logger.error(`Failed to publish message. Attempt ${attempt} of ${maxRetries}. Error:`, 'performActionWithRetry', { message: (error as Error).message });
+        let queueName = (context as PublishMessageInputType)?.queueName
+        const data: MessageModel = (context as PublishMessageInputType)?.message;
+        if (attempt >= maxRetries) {
+          Logger.error('Max retries reached. Failed to publish message.', 'performActionWithRetry');
+          // Optionally: Log or persist the failed message to a DB, file, or other storage for manual intervention
+          this.sendMessageToDeadLatter(attempt, data);
+          failActionHandler(context);
+          return false;
+        }
+        // Wait before retrying (Exponential Backoff)
+        let retryDelay: number;
+        retryDelay = Number(retry_delay[attempt- 1]);
+        let count:any = retry_delay.length - 1 === attempt?retry_delay.length - 1:retry_delay[attempt - 1];
+        retryDelay = Number(count);
+        this.sendMessageToRetryQueue(attempt, data, retryDelay, queueName);
+        Logger.info(`Retrying in ${retryDelay / 1000} seconds...`, 'performActionWithRetry');
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+      }
+    }
+    return false;
+  }
+
+
+
+  /**
+   * Function to consume message with retry
+   * @param queueName
+   */
+  public async consumeMessage(queueName: string, classInstance: any, consumerHandler: string , consumerErrorHandler:string) {
+    Logger.info("Reached: Consuming messages from the queue", 'consumeMessage')
+    let attempt:number = 0;
+      if(isConnectionOpen){
+        return await channel.consume(queueName, async (message: any) => {
+          if(message){ 
+            Logger.info(`Message received from queue ${queueName}: ${JSON.stringify(message)}`, 'consumeMessage');
+            let msgData: any = JSON.parse(message.content.toString());
+            Logger.info(`Received message from queue ${queueName}: ${JSON.stringify(msgData)}`, 'consumeMessage');
+            const headers =  message.properties.headers || {};
+            attempt = headers[retryCountHeader] || 0;
+            const data:any = {body:msgData?.result?.data, queue_name:queueName, language: msgData?.language, correlationId: msgData?.correlationId, retries: msgData?.retries, item_id: msgData?.item_id, metadatakey: msgData?.metadatakey};
+            try {
+              let success:any = {};
+              if(RABBITMQ.CONSUMER_ERROR !== 'true' && RABBITMQ.CONSUMER_ERROR !== true){
+                Logger.info("Consumer handler call for process the request", 'consumeMessage')
+                // success = await this.consumerHandler({ queueName, message: msgData });
+                if (typeof classInstance[consumerHandler] === 'function') {
+                  success = await classInstance[consumerHandler]({ queueName, message: msgData }); // Dynamically call the method
+                } else {
+                  Logger.info(`Method ${consumerHandler} not found in classInstance.`, 'consumerMessage');
+                }
+              }
+              if(success?.isMatch === true){
+                if (!success?.status) {
+                  const retryCount = message.properties.headers['x-retry-count'] || 0;
+                  // while (retryCount < maxRetries) {
+                    attempt = retryCount?retryCount:attempt;
+                    if (retryCount >= maxRetries) {
+                      Logger.error('Max retries reached. Failed to publish message.', 'consumeMessage');
+                      // Optionally: Log or persist the failed message to a DB, file, or other storage for manual intervention
+                      this.sendMessageToDeadLatter(attempt, data);
+                      // this.consumerErrorHandler(data);
+                      if (typeof classInstance[consumerErrorHandler] === 'function') {
+                        classInstance[consumerErrorHandler](data); // Dynamically call the method
+                      } else {
+                        Logger.info(`Method ${consumerErrorHandler} not found in classInstance.`, 'consumerMessage');
+                      }
+                      channel.nack(message, false, false); // Move message to DLQ after failure
+                      return false;
+                    }
+                    attempt++;
+                    if (data?.retries >=0) {
+                      data.retries = attempt;
+                    }
+                    // Wait before retrying (Exponential Backoff)
+                    let retryDelay: number;
+                    let count:any = retry_delay.length === attempt?retry_delay[retry_delay.length - 1]:retry_delay[attempt-1];
+                    retryDelay = Number(count);
+                    await this.sendMessageToRetryQueue(attempt, data, retryDelay, queueName);
+                    Logger.info(`Retrying in ${retryDelay / 1000} seconds...`, 'consumeMessage');
+                    await new Promise((resolve) => setTimeout(resolve, retryDelay));
+                } else {
+                  Logger.info(`Acknowledge the successful processing`, 'consumeMessage');
+                }
+                // Acknowledge the successful processing
+                channel.ack(message);
+              }
+            } catch (error) {
+              let errorMessage:string = (error as Error).message;
+              Logger.error(`Error processing message`, 'consumeMessage', { message: errorMessage});
+              this.sendMessageToDeadLatter(attempt, data);
+              // this.consumerErrorHandler(data);
+              if (typeof classInstance[consumerErrorHandler] === 'function') {
+                classInstance[consumerErrorHandler](data); // Dynamically call the method
+              } else {
+                Logger.info(`Method ${consumerErrorHandler} not found in classInstance.`, 'consumerMessage');
+              }
+              channel.nack(message, false, false); // Move message to DLQ after failure
+            }
+          }
+        });
+      }
+  };
+
+  // /**
+  //  * Function for consumer massage handler
+  //  * @param request
+  //  * @returns 
+  //  */
+  // public async consumerHandler(request: PublishMessageInputType): Promise<boolean> {
+  //   Logger.info(`${JSON.stringify(request)}`, 'consumerHandler');
+  //   return true;
+  // }
+
+  // /**
+  //  * Function to consumer message error handler
+  //  * @param request
+  //  * @returns
+  //  */
+
+  // public async consumerErrorHandler(request:any):Promise<boolean> {
+  //   Logger.info(`${JSON.stringify(request)}`, 'consumerErrorHandler');
+  //   return true;
+  // }
+
+
+  /**
+   * Function to send message to dead later queue
+   * @param attempt
+   * @param data
+   * @param queueName
+   * @retruns
+   */
+
+  public async sendMessageToDeadLatter(attempt:number, data:any){
+    Logger.info("Reached: send message on dead letter queue", 'sendMessageToDeadLater')
+    try {
+      if(isConnectionOpen){
+        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.info(`Message successfully published to DLX queue: ${dlx_queue} (attempt: ${attempt}, retry-count: ${attempt - 1})`, 'sendMessageToDeadLater');
+        } else {
+          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.error(`Cannot send message to DLX - Connection is not open (queue: ${dlx_queue}, attempt: ${attempt})`, 'sendMessageToDeadLater');
+        return false;
+      }
+    } catch (error:unknown) {
+      Logger.error(`Error sending message to dead letter queue: ${(error as Error).message} (queue: ${dlx_queue}, attempt: ${attempt})`, 'sendMessageToDeadLater');
+      throw error;
+    }
+  }
+
+
+  /***
+   * Function to send message to retry queue
+   * @param attempt
+   * @param data
+   * @param retryDelay
+   * @param queueName
+   * @returns
+   */
+
+  public async sendMessageToRetryQueue(attempt:number, data:any, retryDelay:any, queueName:string){
+    Logger.info("Reached: send message on retry queue", 'sendMessageToRetryQueue')
+    try {
+      if(isConnectionOpen){
+        const isSent = await new Promise<boolean>((resolve, reject) => {
+            const messageBuffer = Buffer.from(JSON.stringify(data));
+            let sent = channel.sendToQueue(queueName, messageBuffer, {
+              headers: {
+                'x-retry-count': attempt + 1,
+                'x-message-ttl': retryDelay,
+              }
+            });
+          if (sent) {
+            Logger.debug(`Message sent successfully`, 'publishMessage', { data, queueName });
+            resolve(true);
+          } else {
+            Logger.error(`Failed to publish message.`, 'publishMessage', { message: data.toString() });
+            reject(false);
+          }
+        });
+        return isSent;
+      }
+    } catch (error:unknown) {
+      Logger.error("Error in send message on retry queue", 'sendMessageToRetryQueue', {message: (error as Error ).message});
+      throw error;
+    }
+  }
+
+  /**
+   * Function to find the queue, exchange and add binding 
+   * @param queueName
+   * @param exchangeName
+   * @returns
+   */
+  public async findQueueAndExchange(queueName:string, exchangeName:string){
+    Logger.info('Reached to findQueueAndExchange', 'findQueueAndExchange');
+    try {
+      let exchanges: any = configData?.exchanges;
+      let queues: any = configData.queues;
+      let bindings: any = configData.bindings;
+      // Declare the queues with dlx
+      
+      for (let data of queues) {
+        if(data?.name === queueName){
+          await this.createQueue(data);
+        }
+        Logger.info(`${data?.name} queue created `, 'findQueueAndExchange');
+      }
+
+      // Declare the exchange with dlx 
+      for (let data of exchanges) {
+        if(data?.name === exchangeName){
+          await this.createExchange(data);
+        }
+        Logger.info(`${data?.name} exchange created`, 'findQueueAndExchange');
+      }
+
+      // Declare the bindings for queues and exchanges with routing keys
+      for (let obj in bindings) {
+        bindings[obj]?.forEach(async (key: any) => {
+          if(obj === exchangeName && key?.queue === queueName){
+            await this.bindQueueAndExchanges(obj, key?.queue, key?.routingKey);
+          }
+          Logger.info(`${key?.queue} bind with exchange name ${obj} and routing key ${key?.routingKey}`, 'findQueueAndExchange');
+        })
+      }
+    } catch (error) {
+      Logger.error("Error on setup queues, exchanges and binding", 'findQueueAndExchange', (error as Error).message);
+      throw error;
+    }
+  }
+
+  /**
+    * Function to check connection and channel
+  */
+  private async checkConnectionAndChannel() {
+    Logger.info('Reached: checkConnectionAndChannel', 'checkConnectionAndChannel');
+   // 🧪 1. Ensure connection exists
+      if (!isConnectionOpen) {
+        Logger.warn('No connection found. Creating new connection...', 'publishMessageToExchange');
+        await this.createConnection();
+      }
+      // 🧪 2. Ensure channel is alive
+      const channelConnection: any = channel?.connection;
+      if (!channel || !channelConnection || channelConnection.stream.destroyed) {
+        Logger.warn('Channel seems dead, recreating before publish...', 'publishMessageToExchange');
+        await this.recreateChannel();
+      }
+  }
+
+  /**
+    * Function to recreate channel
+  */
+  private async recreateChannel() {
+    try {
+      channel = await connection.createConfirmChannel();
+      channel.prefetch(RABBITMQ?.PREFETCH_COUNT)
+      Logger.info(' Channel recreated successfully.', 'recreateChannel');
+    } catch (err: any) {
+      Logger.error(' Failed to recreate channel:', err);
+    }
+  }
+
+  /**
+    * Function to setup the queues and exchanges
+    * @params array
+    * @rtrun 
+  */
+  private async setupQueuesAndExchanges(): Promise<void> {
+    Logger.info('Reached to setupQueuesAndExchanges', 'setupQueuesAndExchanges');
+    try {
+      let exchanges: any = configData.exchanges;
+      let queues: any = configData.queues;
+      let bindings: any = configData.bindings;
+      // Declare the exchange with dlx 
+      for (let data of exchanges) {
+        await this.createExchange(data);
+        Logger.info(`${data?.name} exchange created`, 'setupQueuesAndExchanges');
+      }
+
+      // Declare the queues with dlx
+      for (let data of queues) {
+        await this.createQueue(data);
+        Logger.info(`${data?.name} queue created `, 'setupQueuesAndExchanges');
+      }
+
+      // Declare the bindings for queues and exchanges with routing keys
+      for (let obj in bindings) {
+        bindings[obj]?.forEach(async (key: any) => {
+          await this.bindQueueAndExchanges( obj, key?.queue, key?.routingKey);
+          Logger.info(`${key?.queue} bind with exchange name ${obj} and routing key ${key?.routingKey}`, 'setupQueuesAndExchanges');
+        })
+      }
+    } catch (error) {
+      Logger.error("Error on setup queues, exchanges and binding", 'setupQueuesAndExchanges', (error as Error).message);
+    }
+  };
+
+
+  /**
+   * Function to binding queue and exchange
+   * @param exchangeName
+   * @param queueName
+   * @param routingKey
+   */
+
+  private async bindQueueAndExchanges(exchangeName:string, queueName:string, routingKey:string):Promise<void> {
+    try {
+      await channel.bindQueue(queueName, exchangeName, routingKey, { 'toQueue':queueName, 'x-match': 'any' });
+    } catch (error:unknown) {
+      Logger.error('Error in bind Queue and exchange', 'bindQueueAndExchanges', {message:(error as Error).message});
+    }
+    
+  }
+
+
+   /**
+   * Function to create the queue
+   * @param data
+   */
+
+  private async createQueue(data:any ):Promise<void> {
+    try {
+      await channel.assertQueue(data?.name, { durable: data.durable, exclusive: data.exclusive, autoDelete: data.autoDelete, arguments: data.arguments });  
+    } catch (error:unknown) {
+      Logger.error('Error in Create Queue', 'createQueue', {message:(error as Error).message});
+    }
+  }
+
+   /**
+   * Function to create the exchange
+   * @param data
+   */
+
+   private async createExchange(data:any ):Promise<void> {
+    try {
+      await channel.assertExchange(data?.name, data.type, { durable: data.durable, autoDelete: data.autoDelete });
+    } catch (error:unknown) {
+      Logger.error('Error in Create exchange', 'createExchange', {message:(error as Error).message});
+    }
+  }
+
+  // private async publishMessageRetryQueue(request: PublishMessageInputType, attempt: number) {
+  //   try {
+  //     Logger.error(`Failed to publish message. Attempt ${attempt} of ${maxRetries}. Error:`, 'publishMessageRetryQueue', request);
+  //     let queueName = (request as PublishMessageInputType)?.queueName
+  //     const data: MessageModel = (request as PublishMessageInputType)?.message;
+  //     if (typeof data.message === 'object' && data.message !== null) {
+  //       (data.message as { retries: number }).retries = attempt;
+  //     }
+  //     // Wait before retrying (Exponential Backoff)
+  //     let retryDelay: number;
+  //     retryDelay = Number(retry_delay[attempt]);
+  //     let count:any = retry_delay.length - 1 === attempt?retry_delay[retry_delay.length - 1]:retry_delay[attempt];
+  //     retryDelay = Number(count);
+  //     await this.sendMessageToRetryQueue(attempt, data, retryDelay, queueName);
+  //     Logger.info(`Retrying in ${retryDelay / 1000}, seconds...`, 'publishMessageRetryQueue');
+  //     await new Promise((resolve) => setTimeout(resolve, retryDelay)); 
+  //   } catch (error) {
+  //     Logger.error(`Failed to publish message. Attempt ${attempt} of ${maxRetries}. Error:`, 'publishMessageRetryQueue', request);
+  //     throw error;
+  //   }
+  // }
+
+  /**
+    * Function to connect create to RabbitMQ
+    */
+  public async createConnection(): Promise<ConnectionWrapper> {
+    try {
+      Logger.info('Reached to createConnection', 'createConnection');
+      configManager.loadConfig(RABBITMQ?.CONFIG_PATH);
+      const secret = await getIAMSecrets();
+      let url: string = `amqp://${secret?.[SECRET_KEYS.RABBITMQ_USER]}:${secret?.[SECRET_KEYS.RABBITMQ_PASS]}@${RABBITMQ?.HOST}`;
+      // Create a connection to RabbitMQ server
+      connection = await amqp.connect(url, { heartbeat: RABBITMQ?.HEARTBEAT });
+      isConnectionOpen = true;
+      // check the connection status
+      this.bindConnectionEventHandler();
+      // create channel
+      channel = await connection.createConfirmChannel();
+      channel.prefetch(RABBITMQ?.PREFETCH_COUNT);
+      Logger.info('RabbitMQ connected successfully! ', 'createConnection');
+      // create exchange and queue and bind with exchange
+      await this.setupQueuesAndExchanges();
+      const connectionWrapper: ConnectionWrapper = { connection, channel }
+      return connectionWrapper;
+    } catch (error) {
+      // Log and rethrow any errors that occur during connection
+      Logger.error('Failed to connect to RabbitMQ', 'connection', (error as Error)?.message);
+      return { connection: null, channel: null } as unknown as ConnectionWrapper;
+    }
+  }
+
+  /**
+   * Function for bind connection event handler on close and error setupQueuesAndExchanges
+   * @returns 
+   */
+  private  bindConnectionEventHandler(): boolean {
+    try {
+      connection.on('close', async(err: any) => {
+        Logger.error(`RabbitMQ: bindConnectionEventHandler:close`, `Connection closed`, err);
+        isConnectionOpen = false;
+        if(connectionRetry<= maxRetries){
+          await this.createConnection();
+          connectionRetry++;
+        }
+      });
+      connection.on('error', async(err: any) => {
+        Logger.error(`RabbitMQ: bindConnectionEventHandler:error`, `Connection error`, err);
+        isConnectionOpen = false;
+        if(connectionRetry<= maxRetries){
+          await this.createConnection();
+          connectionRetry++;
+        }
+      });
+      return isConnectionOpen;
+    } catch (error) {
+      isConnectionOpen = false;
+      return isConnectionOpen;
+    }
+
+  }
+
+}
+

package/src/messageBroker/types/ActionType.ts

@@ -0,0 +1 @@
+export type ActionType<T> = (input: T) => void;