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

package/src/messageBroker/rabbitmq/MessageBrokerClient.ts

@@ -1,855 +0,0 @@
-// 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';
-
-// Registry of active consumers so they can be re-subscribed after any
-// (re)connect. Without this, a connection blip brings the socket back up but
-// leaves every queue with no consumer attached (the primary "consumer
-// frequently detaches" bug). Keyed by queueName to avoid duplicate
-// subscriptions on the same queue.
-interface RegisteredConsumer {
-  queueName: string;
-  classInstance: any;
-  consumerHandler: string;
-  consumerErrorHandler: string;
-}
-let registeredConsumers: Map<string, RegisteredConsumer> = new Map();
-// Guards handleReconnect() so overlapping close/error events don't spawn
-// multiple concurrent reconnect loops.
-let isReconnecting = false;
-
-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')
-    // 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 await 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
-   */
-  private async subscribeConsumer(queueName: string, classInstance: any, consumerHandler: string, consumerErrorHandler: string) {
-    let attempt:number = 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: amqp.Channel = channel;
-        return await ch.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');
-                      }
-                      this.safeNack(ch, message); // 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');
-                    // 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;
-                } else {
-                  Logger.info(`Acknowledge the successful processing`, 'consumeMessage');
-                }
-                // Acknowledge the successful processing
-                this.safeAck(ch, 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');
-              }
-              this.safeNack(ch, message); // Move message to DLQ after failure
-            }
-          }
-        });
-      }
-  };
-
-  /**
-   * 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.
-   */
-  private async reregisterConsumers(): Promise<void> {
-    if (registeredConsumers.size === 0) {
-      return;
-    }
-    Logger.info(`Re-subscribing ${registeredConsumers.size} consumer(s) after (re)connect`, 'reregisterConsumers');
-    for (const c of registeredConsumers.values()) {
-      try {
-        await this.subscribeConsumer(c.queueName, c.classInstance, c.consumerHandler, c.consumerErrorHandler);
-        Logger.info(`Consumer re-subscribed on queue ${c.queueName}`, 'reregisterConsumers');
-      } catch (error) {
-        Logger.error(`Failed to re-subscribe consumer on queue ${c.queueName}`, 'reregisterConsumers', (error as 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
-   */
-  private safeAck(ch: amqp.Channel, message: amqp.Message): void {
-    try {
-      ch.ack(message);
-    } catch (error) {
-      Logger.error('Failed to ack message (stale channel?)', 'safeAck', (error as 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
-   */
-  private safeNack(ch: amqp.Channel, message: amqp.Message): void {
-    try {
-      ch.nack(message, false, false);
-    } catch (error) {
-      Logger.error('Failed to nack message (stale channel?)', 'safeNack', (error as Error).message);
-    }
-  }
-
-  // /**
-  //  * 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);
-      // 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.info('RabbitMQ connected successfully! ', 'createConnection');
-      // create exchange and queue and bind with exchange
-      await 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".
-      await this.reregisterConsumers();
-      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 {
-      // 'error' always precedes 'close' from amqplib, so only 'close' drives the
-      // reconnect to avoid triggering it twice.
-      connection.on('error', (err: any) => {
-        Logger.error(`RabbitMQ: bindConnectionEventHandler:error`, `Connection error`, err?.message ?? err);
-      });
-      connection.on('close', async(err: any) => {
-        Logger.error(`RabbitMQ: bindConnectionEventHandler:close`, `Connection closed`, err?.message ?? err);
-        isConnectionOpen = false;
-        await this.handleReconnect();
-      });
-      return isConnectionOpen;
-    } catch (error) {
-      isConnectionOpen = false;
-      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.
-   */
-  private bindChannelEventHandler(): void {
-    try {
-      channel.on('error', (err: any) => {
-        Logger.error(`RabbitMQ: bindChannelEventHandler:error`, `Channel error`, err?.message ?? err);
-      });
-      channel.on('close', async () => {
-        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 {
-            await this.recreateChannel();
-            this.bindChannelEventHandler();
-            await this.reregisterConsumers();
-            Logger.info('Channel and consumers recovered after channel close', 'bindChannelEventHandler');
-          } catch (error) {
-            Logger.error('Failed to recover channel after close', 'bindChannelEventHandler', (error as Error).message);
-          }
-        }
-      });
-    } catch (error) {
-      Logger.error('Error in bindChannelEventHandler', 'bindChannelEventHandler', (error as 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.
-   */
-  private async handleReconnect(): Promise<void> {
-    if (isReconnecting) {
-      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: number[] = (retry_delay ?? []).map(Number).filter((n: number) => !Number.isNaN(n) && n > 0);
-    const maxBackoff = backoffs.length ? backoffs[backoffs.length - 1] : 30000;
-    try {
-      while (!isConnectionOpen) {
-        const delay = backoffs[connectionRetry - 1] ?? maxBackoff;
-        Logger.info(`Reconnect attempt ${connectionRetry} in ${delay / 1000}s...`, 'handleReconnect');
-        await new Promise(resolve => setTimeout(resolve, delay));
-        try {
-          await this.createConnection();
-          if (isConnectionOpen) {
-            connectionRetry = 1;
-            Logger.info('Reconnected to RabbitMQ successfully', 'handleReconnect');
-            return;
-          }
-          throw new Error('createConnection did not establish an open connection');
-        } catch (error) {
-          Logger.error(`Reconnect attempt ${connectionRetry} failed`, 'handleReconnect', (error as Error).message);
-          connectionRetry++;
-        }
-      }
-    } finally {
-      isReconnecting = false;
-    }
-  }
-
-}
-