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

package/src/config/ConfigManager.ts

@@ -0,0 +1,35 @@
+import * as fs from "fs";
+import config from "./index";
+import { Logger } from '../Util/logger';
+
+class ConfigManager {
+    private static instance: ConfigManager;
+    private config: any;
+    private constructor() {
+        this.config = {};
+        this.loadConfig(config.RABBITMQ.CONFIG_PATH);
+    }
+
+    public static getInstance(): ConfigManager {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+
+    public loadConfig(configPath: string): void {
+        if (fs.existsSync(configPath)) {
+            // Do something
+            this.config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        }else{
+            Logger.error("Config file missing!", "loadConfig") 
+        }
+        
+    }
+
+    public getConfig(): any {
+        return this.config;
+    }
+}
+
+export default ConfigManager;

package/src/config/index.ts

@@ -0,0 +1,31 @@
+import dotenv from 'dotenv';
+dotenv.config();
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+
+export default {
+  LOG_LEVELS: ['info', 'error', 'warn', 'debug'],
+  NODE_ENV: 'development',
+  APP_NAME: 'hep-message-broker-client',
+  RABBITMQ: {
+    USER: process.env.RABBITMQ_USER??'root',
+    PASS: process.env.RABBITMQ_PASS??'root',
+    HOST: process.env.RABBITMQ_HOST??'127.0.0.1',
+    PORT: process.env.RABBITMQ_PORT??'5672',
+    MAIN_QUEUE: 'main_queue',
+    MAIN_EXCHANGE: 'assets_metadata_generate_exchange',
+    DLX_QUEUE: 'dead_letter_queue',
+    DLX_EXCHANGE: 'assets_dlx_exchange',
+    RETRY_QUEUE: 'retry_queue',
+    RETRY_EXCHANGE: 'assets_metadata_generate_retry_exchange',
+    MAX_RETRIES: Number(process.env.RABBITMQ_MAX_RETRIES?.trim() ?? 1),
+    HEARTBEAT: Number(process.env.RABBITMQ_HEARTBEAT?.trim() ?? 5),
+    TTL:process.env.RABBITMQ_TTL??"3000|6000|9000",
+    BACKOFF_TIME:Number(process.env.BACKOFF_TIME?.trim() ?? 1000),
+    IS_ENABLED: process.env.RABBITMQ_IS_ENABLED ?? 'true',
+    RABBITMQ_CONFIG: process.env.RABBITMQ_CONFIG ?? '',
+    PREFETCH_COUNT: Number(process.env.RABBITMQ_PREFETCH ?? 50),
+    CONNECTION_ERROR:process.env.RABBITMQ_CONNECTION_ERROR ?? false,
+    PUBLISHER_ERROR:process.env.RABBITMQ_PUBLISHER_ERROR ?? false,
+    CONSUMER_ERROR:process.env.RABBITMQ_CONSUMER_ERROR ?? false,
+    CONFIG_PATH: process.env.CONFIG_PATH ?? '/etc/rabbitmq/rabbitMQConfig.json',
+  }}

package/src/index.ts

@@ -0,0 +1,73 @@
+
+import { MessageBrokerClient } from "./messageBroker/rabbitmq/MessageBrokerClient";
+// const messageBrokerClient = new MessageBrokerClient();
+// let initial_message = {
+//     message: {
+//         'queue_name': 'image_thumbnail_request_queue',
+//         'body': {
+//             'url': 'https://dev.dam.hcl-x.com/server/api/core/bitstreams/43817aff-ebb7-47d2-be0e-fb4db1ab267a/content',
+//             'file_name': 'Kudos (1)',
+//             'destination_path': '1721365841379/public/png',
+//             'visibility': 'public', 
+//             'urgency': 0,
+//             'folder_name': '',
+//             'bitstream_id': '43817aff-ebb7-47d2-be0e-fb4db1ab267a',
+//             'ext': 'png',
+//             'asset_type': 'Image',
+//             'item_id': 'b1ff157e-a04f-4f8c-83b5-3a2ead732101',
+//         },
+//         'item_id': 'b1ff157e-a04f-4f8c-83b5-3a2ead732101',
+//         "language": "en",
+//         'retries': 0,
+//     },
+//     corelationId: 'lgkdkfgkkfd',
+//     version: 0,
+//     trace: '',
+// };
+
+// let initial_message = { 
+//     "message":{ 
+//       "queue_name":"summary_request_queue", 
+//       "body":{ 
+// 			"input": "€ !~!@#$%^&*()_++_<><?:{}[];,./ Hi everyone, good afternoon. Hope you all are doing good. Myself Akshima, Daitishin from Hetzial Healthcare. So today I am going to discuss about weight loss platy. We all must be aware about what is a weight loss platy. This is a term which we all come across when we are focusing on our weight loss journey. ",     
+// 			"language": "hi",     
+// 			"max_length": 20,     
+// 			"min_length": 10 
+//       }, 
+//       "language": "en", 
+// 	  "correlationId":"", 
+//       "retries": 0 
+//     }
+// };  
+ 
+// console.log(initial_message)
+// async function testConnection() {
+    // await messageBrokerClient.initialize().then(async () => { 
+    //    return ''; 
+        // setInterval(() => {
+            // messageBrokerClient.initializeConsumers();
+            // messageBrokerClient.publishMessage( { queueName: 'summary_request_queue', exchangeName:"assets_metadata_generate_exchange", message: initial_message })
+        
+    // }, 1);
+//     }); 
+// }
+ 
+// testConnection(); 
+
+
+
+
+
+
+
+export { MessageBrokerClient };
+let injectedSecretService: any = null;
+export const initIAMSecretsMessageBroker = (secretServiceIns: any) =>{
+  injectedSecretService = secretServiceIns;
+}
+export const getIAMSecrets = async() =>{
+  if (!injectedSecretService) {
+    throw new Error("IAM secrets not initialized");
+  }
+  return await injectedSecretService.getSecretKeys(); // returns cached data
+}

package/src/messageBroker/BaseRabbitMQClient.ts

@@ -0,0 +1,30 @@
+import * as amqp from 'amqplib';
+import ConfigManager from '../config/ConfigManager';
+import config from '../config';
+import ConnectionManager from './ConnectionManager';
+
+class BaseRabbitMQClient{
+    public readonly configManager: ConfigManager;
+    public readonly connectionManager: ConnectionManager = new ConnectionManager();
+    protected connection: amqp.Connection | undefined;
+    protected channel: amqp.Channel | undefined;
+    protected configData: any = {};
+    constructor() {
+        this.configManager = ConfigManager.getInstance();
+        this.configData = this.configManager.getConfig();
+        this.channel = this.connectionManager.getChannel();
+        this.connection = this.connectionManager.getConnection();
+        this.init();
+    }
+
+     /**
+     * Function for load the config data
+     */
+     private init() {
+        this.configManager.loadConfig(config?.RABBITMQ?.CONFIG_PATH);
+        this.configData = this.configManager.getConfig();
+    }
+    
+}
+
+export default BaseRabbitMQClient;

package/src/messageBroker/ConnectionManager.ts

@@ -0,0 +1,182 @@
+// Import the amqplib library for RabbitMQ
+import * as amqp from 'amqplib';
+import { Logger } from '../Util/logger';
+import ConfigManager from '../config/ConfigManager';
+import config from '../config';
+let isConnectionOpen = false;
+let MAX_RETRIES: number = 1;
+
+
+interface ConnectionWrapper {
+    connection: amqp.Connection,
+    channel: amqp.Channel
+}
+
+class ConnectionManager {
+    private static instance: ConnectionManager;
+    private readonly configManager: ConfigManager;
+    protected connection: amqp.Connection | undefined;
+    protected channel: amqp.Channel | undefined;
+    protected configData: any = {};
+    constructor() {
+        this.configManager = ConfigManager.getInstance();
+        this.init();
+    }
+    
+    /**
+     * Function for get channel
+     */
+    public getChannel():amqp.Channel | undefined{
+        return this.channel;
+    }
+
+    /**
+     * Function for get channel
+     */
+    public getConnection():amqp.Connection | undefined{
+        return this.connection;
+    }
+
+    /**
+     * Function for create and return intance
+     * @returns
+     */
+    public static async getInstance(): Promise<ConnectionManager> {
+        if (!ConnectionManager.instance) {
+            ConnectionManager.instance = new ConnectionManager();
+        }
+        return ConnectionManager.instance;
+    }
+
+    /**
+      * Function to connect create to RabbitMQ
+      */
+    public async createConnection(): Promise<ConnectionWrapper> {
+        try {
+            Logger.info('Reached to createConnection', 'createConnection');
+            this.configManager.loadConfig(config?.RABBITMQ?.CONFIG_PATH);
+            let url: string = `amqp://${this.configData?.username}:${this.configData?.password}@${this.configData?.host}`;
+            // Create a connection to RabbitMQ server
+            this.connection = await amqp.connect(url, { heartbeat: this.configData?.heartbeat });
+            isConnectionOpen = true;
+            // check the connection status
+            this.bindConnectionEventHandler();
+            // create channel
+            this.channel = await this.connection.createConfirmChannel();
+            Logger.info('RabbitMQ connected successfully! ', 'createConnection');
+            // create exchange and queue and bind with exchange
+            await this.setupQueuesAndExchanges();
+            const connectionWrapper: ConnectionWrapper = { connection: this.connection, channel: this.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 {
+            this.connection?.on('close', (err: any) => {
+                Logger.error(`RabbitMQ: bindConnectionEventHandler:close`, `Connection closed`, err);
+                isConnectionOpen = false;
+            });
+            this.connection?.on('error', (err: any) => {
+                Logger.error(`RabbitMQ: bindConnectionEventHandler:error`, `Connection error`, err);
+                isConnectionOpen = false;
+            });
+            return isConnectionOpen;
+        } catch (error) {
+            isConnectionOpen = false;
+            return isConnectionOpen;
+        }
+
+    }
+
+    /**
+      * 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');
+        let retries: number = 0;
+        MAX_RETRIES = this.configData?.max_retries;
+        // Retrie times connection
+        while (retries < MAX_RETRIES) {
+            try {
+                await this.createConnection();
+                return { connection:this.connection, channel:this.channel };
+            } catch (err) {
+                retries++;
+                Logger.error('initialize:Failed to connect to RabbitMQ', `Attempt ${retries} of ${MAX_RETRIES}.`);
+                if (retries >= MAX_RETRIES) {
+                    Logger.error('Max retries reached, cannot connect to RabbitMQ.', 'initialize');
+                    return { connection:this.connection, channel:this.channel };
+                }
+                // Wait before retrying (e.g., 10 seconds)
+                await new Promise(resolve => setTimeout(resolve, 10000));
+            }
+        }
+    };
+
+    /**
+      * 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 = this.configData.exchanges;
+            let queues: any = this.configData.queues;
+            let bindings: any = this.configData.bindings;
+            // Declare the exchange with dlx 
+            for (let data of exchanges) {
+                await this.channel?.assertExchange(data?.name, data.type, { durable: data.durable, autoDelete: data.autoDelete });
+                Logger.info(`${data?.name} exchange created`, 'setupQueuesAndExchanges');
+            }
+
+            // Declare the queues with dlx
+            for (let data of queues) {
+                await this.channel?.assertQueue(data?.name, { durable: data.durable, exclusive: data.exclusive, autoDelete: data.autoDelete, arguments: data.arguments });
+                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.channel?.bindQueue(key?.queue, obj, 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);
+            throw error;
+        }
+    };
+
+    /**
+     * Function for load the config data
+     */
+    private init() {
+        this.configManager.loadConfig(config?.RABBITMQ?.CONFIG_PATH);
+        this.configData = this.configManager.getConfig();
+    }
+
+}
+
+export default ConnectionManager;

package/src/messageBroker/MessageBrokerClient.ts

@@ -0,0 +1,88 @@
+import config from '../config';
+import ConfigManager from '../config/ConfigManager';
+import ConnectionManager from './ConnectionManager';
+import { IMessageBrokerClient } from './interface/IMessageBrokerClient';
+import MessageProducer from './MessageProducer';
+import { RabbitMQClient } from './RabbitMQClient';
+import RetryManager from './RetryManager';
+import { PublishMessageInputType } from './types/PublishMessageInputType';
+const connectionManager =  ConnectionManager.getInstance();
+export class MessageBrokerClient implements IMessageBrokerClient {
+  private readonly rabbitMQClient: RabbitMQClient;
+  private readonly messageProducer: MessageProducer;
+  private readonly configManager: ConfigManager;
+  // private readonly retryManager: RetryManager<T>;
+  private readonly isEnabledRabbitMQ: boolean = false;
+  private readonly configData: any = {};
+  constructor() {
+    this.rabbitMQClient = new RabbitMQClient();
+    this.messageProducer = new MessageProducer();
+    this.isEnabledRabbitMQ = config?.RABBITMQ?.IS_ENABLED === 'true';
+    this.configManager = ConfigManager.getInstance();
+    this.configData = this.configManager.getConfig();
+  }
+
+  /**
+   * Function to initialize the RabbitMQ connection
+   */
+  async initialize(): Promise<void> {
+    if(this.isEnabledRabbitMQ){
+      this.rabbitMQClient.initialize();
+    }
+  }
+
+  /**
+   * Function to close the connection and channel
+   */
+  disconnect(): void {
+    if(this.isEnabledRabbitMQ){
+      this.rabbitMQClient.disconnect();
+    }
+  }
+
+  /**
+   * Function to publish a message with retry
+   * @param request 
+   * @returns 
+   */
+  publishMessage(request:PublishMessageInputType): Promise<boolean> {
+    if(this.isEnabledRabbitMQ){
+      const boundPublishMessage = this.messageProducer.publishMessage.bind(this);
+      const boundConsumerHandler = this.messageProducer.messageHandler.bind(this);
+      let retry_delay = this.configData?.retry_delay;
+      let max_retries = this.configData?.max_retries;
+      // Instantiate RetryManager
+      const retryManager = RetryManager.getInstance<PublishMessageInputType>(max_retries, retry_delay);
+      retryManager.performActionWithRetry(boundPublishMessage, request, boundConsumerHandler)
+    }
+    return Promise.resolve(false);
+  }
+
+  /**
+   * Function to publish a message with retry to exchange
+   * @param request 
+   * @returns 
+   */
+  publishMessageToExchange(request:PublishMessageInputType): Promise<boolean> {
+    if(this.isEnabledRabbitMQ){
+      const boundPublishMessage = this.messageProducer.publishMessageToExchange.bind(this);
+      const boundConsumerHandler = this.messageProducer.messageHandler.bind(this);
+      let retry_delay = this.configData?.retry_delay;
+      let max_retries = this.configData?.max_retries;
+      // Instantiate RetryManager
+      const retryManager = RetryManager.getInstance<PublishMessageInputType>(max_retries, retry_delay);
+      retryManager.performActionWithRetry(boundPublishMessage, request, boundConsumerHandler)
+    }
+    return Promise.resolve(false);
+  }
+  /***
+   * Function to check if the connection is established
+   */
+  async isConnected(): Promise<boolean> {
+    if(this.isEnabledRabbitMQ){
+      return (await connectionManager) ? (await connectionManager).isConnected() : Promise.resolve(false);
+    }
+    return Promise.resolve(false);
+  }
+
+}

package/src/messageBroker/MessageConsumer.ts

@@ -0,0 +1,85 @@
+import { Logger } from "../Util/logger";
+import { PublishMessageInputType } from "./types/PublishMessageInputType";
+import RetryManager from './RetryManager';
+import MessageProducer from "./MessageProducer";
+import BaseRabbitMQClient from "./BaseRabbitMQClient";
+
+
+let configData: any = {};
+let max_retries: number = 0; // Maximum retries for connection and queue
+let retry_delay: string = ""; // Back-off time for message retry
+
+class MessageConsumer extends  BaseRabbitMQClient{
+    private readonly messageProducer: MessageProducer;
+    constructor() {
+        super();
+        this.messageProducer = new MessageProducer()
+    }
+    /**
+   * Funvction for initialize consumer queue
+   * @param consumerQueues
+   */
+    public async initializeConsumers() {
+        try {
+            Logger.info('Reached in initialize consumer', `initializeConsumers`);
+            let consume_queues = configData?.consume_queues;
+            // Consume messages from all queues
+            for (const queue in configData?.consume_queues) {
+                if (Object.prototype.hasOwnProperty.call(consume_queues, queue)) {
+                    // Call function Consume messages with retry
+                    await this.consumerMessage(queue);
+                }
+            }
+        } catch (error: unknown) {
+            Logger.error('Error initializing consumers:', 'initializeConsumers', (error as Error).message);
+            return { error: (error as Error).message };
+        }
+    }
+
+
+
+    /**
+     * Function to consume message with retry
+     * @param queueName
+     */
+    private async consumerMessage(queueName: string) {
+        Logger.info("Reached: Consuming messages from the main queue", 'consumerMessage')
+        await this.channel?.consume(queueName, async (message: any) => {
+            if (message) {
+                let msgData: any = message.content.toString();
+                const success: boolean = await this.consumerHandler({ queueName, message: msgData });
+                try {
+                    if (!success) {
+                        const boundPublishMessage = this.messageProducer.publishMessage.bind(this);
+                        const boundConsumerHandler = this.consumerHandler.bind(this);
+                        retry_delay = configData?.retry_delay;
+                        const reqData: PublishMessageInputType = { queueName, message };
+                        // Instantiate RetryManager
+                        const retryManager = RetryManager.getInstance<PublishMessageInputType>(max_retries, retry_delay);
+                        retryManager.performActionWithRetry(boundPublishMessage, reqData, boundConsumerHandler)
+                    } else {
+                        Logger.info(`Acknowledge the successful processing`, 'consumerMessage');
+                        this.channel?.ack(message); // Acknowledge the successful processing
+                    }
+                } catch (error) {
+                    Logger.error(`Error processing message`, 'consumerMessage', { message: (error as Error).message });
+                    this.channel?.nack(message, false, false); // Move message to DLQ after failure
+                }
+            }
+        });
+    };
+
+    /**
+     * Function for consumer massage handler
+     * @param channel
+     * @param queue
+     * @param message
+     * @returns 
+     */
+    private async consumerHandler(request: PublishMessageInputType): Promise<boolean> {
+        Logger.info(`${JSON.stringify(request)}`, 'consumerHandler');
+        return true;
+    }
+}
+
+export default MessageConsumer;

package/src/messageBroker/MessageProducer.ts

@@ -0,0 +1,142 @@
+import MessageModel from "../models/MessageModel";
+import { generateCorrelationId } from "../Util/commonUtil";
+import { Logger } from "../Util/logger";
+import BaseRabbitMQClient from "./BaseRabbitMQClient";
+import ConnectionManager from "./ConnectionManager";
+import { PublishMessageInputType } from "./types/PublishMessageInputType";
+
+class MessageProducer extends BaseRabbitMQClient{
+    private readonly correlationId:string;
+    public connectionManager:ConnectionManager;
+    constructor() {
+        super();
+        this.correlationId= generateCorrelationId();
+        this.connectionManager = new ConnectionManager();
+    }
+
+
+    
+    /**
+      * Function to publish a message with retry
+      * @param queueName 
+      * @param message 
+      * @returns 
+    */
+    public async publishMessage(request: PublishMessageInputType): Promise<boolean> {
+        const queueName: string = request.queueName;
+        const data: MessageModel = request.message;
+        console.log(data.message, queueName, 'message')
+        Logger.info('Reached:publishMessage', 'publishMessage');
+        const messageBuffer = Buffer.from(JSON.stringify(data?.message));
+        this.channel = this.connectionManager.getChannel();
+        try {
+            const isSent = await new Promise<boolean>((resolve, reject) => {
+                this.connection?.on('close', (err: any) => {
+                    Logger.error(`RabbitMQ: bindConnectionEventHandler:close`, `Connection closed`, err);
+        
+                });
+               let sent = this.channel?.sendToQueue('update_metadata_queue', Buffer.from(JSON.stringify('Hello world test')), {
+                    persistent: true, // Ensures the message is persisted
+                    // correlationId: data?.message?.correlationId,
+                });
+                console.log("publish message successfully")
+                // console.log(sent, 'send')
+                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);
+                }
+            });
+            console.log(isSent)
+            return true;;
+        } catch (error) {
+            console.log(error)
+            Logger.error(`Error sending message: ${error}`, 'sendMessage', error);
+            return false;
+        }
+    }
+
+    /**
+      * Function to publish a message with retry
+      * @param exchangeName 
+      * @param routingKey
+      * @param message 
+      * @param options
+      * @returns 
+    */
+    public async publishMessageToExchange(
+       request: PublishMessageInputType
+    ): Promise<boolean> {
+        const exchangeName:string | undefined = request?.exchangeName ?? '';
+        const queueName:string = request.queueName;
+        const data:MessageModel = request?.message
+        // const options:object | null = request?.options; // Optional parameter for retry count if you wnats to override the default retry count
+        // const messageObj = {
+        //     message,
+        //     correlationId:this.correlationId,
+        // }
+        Logger.info('Reached:publishMessageToExchange', 'publishMessageToExchange');
+        // Publish the message
+        const messageBuffer = Buffer.from(JSON.stringify(data.message));
+        try {
+            const isSent = await new Promise<boolean>((resolve, reject) => {
+                // this.channel?.on
+                const sent = this.channel?.publish(exchangeName, queueName, messageBuffer,{
+                    persistent: true, // Ensures the message is persisted
+                    correlationId: this.correlationId,
+                });
+                if (sent) {
+                    Logger.debug(`Message sent successfully`, 'publishMessageToExchange', { data, queueName });
+                    resolve(true);
+                } else {
+                    Logger.error(`Failed to publish message to exchange.`, 'publishMessageToExchange', { message: messageBuffer.toString() });
+                    reject(false);
+                }
+            });
+            return isSent;
+        } catch (error) {
+            Logger.error(`Error sending message: ${error}`, 'sendMessage');
+            return false;
+        }
+    };
+
+    /**
+     * Funciton to message handler
+     */
+
+    public async messageHandler(request:PublishMessageInputType):Promise<boolean>{
+        Logger.info(`${JSON.stringify(request)}`, 'messageHandler');
+        return true;
+    }
+
+     /**
+      * Function to connect create to RabbitMQ
+      */
+    //  public async createConnection(): Promise<ConnectionWrapper> {
+    //     try {
+    //         Logger.info('Reached to createConnection', 'createConnection');
+    //         this.configManager.loadConfig(config?.RABBITMQ?.CONFIG_PATH);
+    //         let url: string = `amqp://${this.configData?.username}:${this.configData?.password}@${this.configData?.host}`;
+    //         // Create a connection to RabbitMQ server
+    //         this.connection = await amqp.connect(url, { heartbeat: this.configData?.heartbeat });
+    //         isConnectionOpen = true; 
+    //         // check the connection status
+    //         this.bindConnectionEventHandler();
+    //         // create channel
+    //         this.channel = await this.connection.createConfirmChannel();
+    //         Logger.info('RabbitMQ connected successfully! ', 'createConnection');
+    //         // create exchange and queue and bind with exchange
+    //         await this.setupQueuesAndExchanges();
+    //         const connectionWrapper: ConnectionWrapper = { connection: this.connection, channel: this.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;
+    //     }
+    // }
+}
+
+export default MessageProducer;