@platform-x/hep-message-broker-client 1.0.0

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

@@ -0,0 +1,706 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageBrokerClient = void 0;
+// Import the amqplib library for RabbitMQ
+const amqp = __importStar(require("amqplib"));
+const config_1 = __importDefault(require("../../config"));
+const logger_1 = require("../../Util/logger");
+const ConfigManager_1 = __importDefault(require("../../config/ConfigManager"));
+// Remove lodash delay import
+let configManager = ConfigManager_1.default.getInstance();
+// Declare variables for the connection and channel
+let connection;
+let channel;
+// Declare variable for check connection
+let isConnectionOpen = false;
+let configData = {};
+const RABBITMQ = config_1.default === null || config_1.default === void 0 ? void 0 : config_1.default.RABBITMQ;
+let maxRetries = RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.MAX_RETRIES;
+let retry_delay = (_a = RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.TTL) === null || _a === void 0 ? void 0 : _a.split("|");
+// let dlx_exchange:string = RABBITMQ.DLX_EXCHANGE;
+let dlx_queue = RABBITMQ.DLX_QUEUE;
+// let retry_exchange:string = RABBITMQ.RETRY_EXCHANGE;
+// let retry_queue:string = RABBITMQ.RETRY_QUEUE;
+let connectionRetry = 1;
+let retryCountHeader = 'x-retry-count';
+class MessageBrokerClient {
+    // private readonly correlationId: string;
+    // constructor() {
+    // this.correlationId = generateCorrelationId();
+    // }
+    /**
+      * Function to check the status of the connection
+      * @returns boolean
+    */
+    isConnected() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return isConnectionOpen;
+        });
+    }
+    ;
+    /**
+      * Function to initialize the connection, channel and setup the queues and exchanges
+      * @param reqData
+      * @returns
+    */
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info('Reached to initialize', 'initialize');
+            configData = configManager.getConfig();
+            // dlx_exchange = configData?.dlx_exchange;
+            dlx_queue = configData === null || configData === void 0 ? void 0 : configData.dlx_queue;
+            // retry_exchange = configData?.retry_exchange;
+            // retry_queue = configData?.retry_queue;
+            let retries = 0;
+            // Retrie times connection 
+            while (retries < maxRetries) {
+                try {
+                    if (RABBITMQ.CONNECTION_ERROR === 'true' || RABBITMQ.CONNECTION_ERROR === true) {
+                        throw new Error("Error in connection");
+                    }
+                    yield this.createConnection();
+                    return { connection: connection, channel: channel };
+                }
+                catch (err) {
+                    retries++;
+                    logger_1.Logger.error('initialize:Failed to connect to RabbitMQ', `Attempt ${retries} of ${maxRetries}.`);
+                    if (retries >= maxRetries) {
+                        logger_1.Logger.error('Max retries reached, cannot connect to RabbitMQ.', 'initialize');
+                        return { connection, channel };
+                    }
+                    // Wait before retrying (e.g., 10 seconds)
+                    yield new Promise(resolve => setTimeout(resolve, 10000));
+                }
+            }
+        });
+    }
+    ;
+    /**
+      * Function to publish a message with retry
+      * @param request
+      * @param classInstance
+      * @param messagePublisherErrorHandler
+      * @returns
+    */
+    publishMessage(request
+    // , classInstance:any, messagePublisherErrorHandler:string
+    ) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info('Reached:publishMessage', 'publishMessage');
+            // Logger.debug('Reached:publishMessageToExchange', 'publishMessageToExchange',{classInstance, messagePublisherErrorHandler});
+            try {
+                if (isConnectionOpen) {
+                    logger_1.Logger.info('Check connection open or not', 'publishMessage');
+                    const queueName = request.queueName;
+                    const data = request.message;
+                    const messageBuffer = Buffer.from(JSON.stringify(data === null || data === void 0 ? void 0 : 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_1.Logger.info('Max retries check', 'publishMessage');
+                    const isSent = yield new Promise((resolve, reject) => {
+                        let sent = channel.sendToQueue(queueName, Buffer.from(messageBuffer), {
+                            persistent: true, // Ensures the message is persisted
+                            // correlationId: this.correlationId,
+                        });
+                        if (sent) {
+                            logger_1.Logger.debug(`Message sent successfully`, 'publishMessage', { data, queueName });
+                            resolve(true);
+                        }
+                        else {
+                            logger_1.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_1.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
+    */
+    publishMessageToExchange(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            logger_1.Logger.info('Reached:publishMessageToExchange', 'publishMessageToExchange');
+            // Publish the message
+            // Logger.debug('Reached:publishMessageToExchange', 'publishMessageToExchange',{classInstance, messagePublisherErrorHandler});
+            try {
+                if (isConnectionOpen) {
+                    // let attempt: number = 0;
+                    const exchangeName = (_a = request === null || request === void 0 ? void 0 : request.exchangeName) !== null && _a !== void 0 ? _a : '';
+                    const queueName = request.queueName;
+                    const data = request === null || request === void 0 ? void 0 : request.message;
+                    // const options:object | null = request?.options; // Optional parameter for retry count if you wnats to override the default retry count
+                    const messageBuffer = Buffer.from(JSON.stringify(data.message));
+                    // let retries: number = typeof data.message === 'object' && data.message !== null ? (data.message as { retries: number }).retries ?? 0 : 0;
+                    // while (attempt < maxRetries) {
+                    const isSent = yield new Promise((resolve, reject) => {
+                        const sent = channel.publish(exchangeName, queueName, messageBuffer, {
+                            persistent: true, // Ensures the message is persisted
+                            // correlationId: this.correlationId,
+                        });
+                        if (sent) {
+                            logger_1.Logger.debug(`Message sent successfully`, 'publishMessageToExchange', { data, queueName });
+                            resolve(true);
+                        }
+                        else {
+                            logger_1.Logger.error(`Failed to publish message to exchange.`, 'publishMessageToExchange', { 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.', 'publishMessageToExchange', request);
+                    //     // Optionally: Log or persist the failed message to a DB, file, or other storage for manual intervention
+                    //     this.sendMessageToDeadLatter(attempt, data, queueName);
+                    //     this.messagePublisherErrorHandler(request); // we need to comment this line
+                    // if (typeof classInstance[messagePublisherErrorHandler] === 'function') {
+                    //   classInstance[messagePublisherErrorHandler](data); // Dynamically call the method
+                    // } else {
+                    //   Logger.info(`Method ${messagePublisherErrorHandler} not found in classInstance.`, 'publishMessageToExchange');
+                    // }
+                    //     return false;
+                    //   }else{
+                    //     await this.publishMessageRetryQueue(request, (attempt+1));
+                    //     attempt++;
+                    //   }
+                    // }
+                    // }
+                }
+            }
+            catch (error) {
+                logger_1.Logger.error(`Error sending message: ${error}`, 'sendMessage');
+                throw new Error("Failed to publish message to exchange");
+            }
+        });
+    }
+    ;
+    /**
+     * Funciton to message handler
+     */
+    // TO Do rename function name messagePublisherErrorHandler
+    messagePublisherErrorHandler(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info(`${JSON.stringify(request)}`, 'messagePublisherErrorHandler');
+            return Promise.resolve(true);
+        });
+    }
+    /**
+     * Funvction for initialize consumer queue
+     * @param consumerQueues
+     */
+    initializeConsumers(classInstance, consumerHandler, consumerErrorHandler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.Logger.info('Reached in initialize consumer', `initializeConsumers`);
+                let consume_queues = configData === null || configData === void 0 ? void 0 : configData.consume_queues;
+                // Consume messages from all queues
+                for (let queueName in configData === null || configData === void 0 ? void 0 : configData.consume_queues) {
+                    if (Object.prototype.hasOwnProperty.call(consume_queues, queueName)) {
+                        // Call function Consume messages with retry
+                        yield this.consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler);
+                    }
+                }
+            }
+            catch (error) {
+                logger_1.Logger.error('Error initializing consumers:', 'initializeConsumers', error.message);
+                throw new Error(error.message);
+            }
+        });
+    }
+    /**
+         * Function for perform action with retry
+         * @param actionHandler
+         * @param context
+         * @param failActionHandler
+         * @returns
+         */
+    performActionWithRetry(actionHandler, failActionHandler, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info("Reached: in perform action with retry ", "performActionWithRetry");
+            let attempt = 0;
+            while (attempt < maxRetries) {
+                try {
+                    actionHandler(context);
+                    return true;
+                }
+                catch (error) {
+                    attempt++;
+                    logger_1.Logger.error(`Failed to publish message. Attempt ${attempt} of ${maxRetries}. Error:`, 'performActionWithRetry', { message: error.message });
+                    let queueName = context === null || context === void 0 ? void 0 : context.queueName;
+                    const data = context === null || context === void 0 ? void 0 : context.message;
+                    if (attempt >= maxRetries) {
+                        logger_1.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;
+                    retryDelay = Number(retry_delay[attempt - 1]);
+                    let count = retry_delay.length - 1 === attempt ? retry_delay.length - 1 : retry_delay[attempt - 1];
+                    retryDelay = Number(count);
+                    this.sendMessageToRetryQueue(attempt, data, retryDelay, queueName);
+                    logger_1.Logger.info(`Retrying in ${retryDelay / 1000} seconds...`, 'performActionWithRetry');
+                    yield new Promise((resolve) => setTimeout(resolve, retryDelay));
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Function to consume message with retry
+     * @param queueName
+     */
+    consumeMessage(queueName, classInstance, consumerHandler, consumerErrorHandler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info("Reached: Consuming messages from the queue", 'consumeMessage');
+            let attempt = 0;
+            if (isConnectionOpen) {
+                return yield channel.consume(queueName, (message) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    if (message) {
+                        let msgData = JSON.parse(message.content.toString());
+                        const headers = message.properties.headers || {};
+                        attempt = headers[retryCountHeader] || 0;
+                        const data = { body: (_a = msgData === null || msgData === void 0 ? void 0 : msgData.result) === null || _a === void 0 ? void 0 : _a.data, queue_name: queueName, language: msgData === null || msgData === void 0 ? void 0 : msgData.language, correlationId: msgData === null || msgData === void 0 ? void 0 : msgData.correlationId, retries: msgData === null || msgData === void 0 ? void 0 : msgData.retries, item_id: msgData === null || msgData === void 0 ? void 0 : msgData.item_id, metadatakey: msgData === null || msgData === void 0 ? void 0 : msgData.metadatakey };
+                        try {
+                            let success = false;
+                            if (RABBITMQ.CONSUMER_ERROR !== 'true' && RABBITMQ.CONSUMER_ERROR !== true) {
+                                logger_1.Logger.info("Consumer handler call for process the request", 'consumeMessage');
+                                // success = await this.consumerHandler({ queueName, message: msgData });
+                                if (typeof classInstance[consumerHandler] === 'function') {
+                                    success = yield classInstance[consumerHandler]({ queueName, message: msgData }); // Dynamically call the method
+                                }
+                                else {
+                                    logger_1.Logger.info(`Method ${consumerHandler} not found in classInstance.`, 'consumerMessage');
+                                }
+                            }
+                            if (!success) {
+                                const retryCount = message.properties.headers['x-retry-count'] || 0;
+                                // while (retryCount < maxRetries) {
+                                attempt = retryCount ? retryCount : attempt;
+                                if (retryCount >= maxRetries) {
+                                    logger_1.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_1.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 === null || data === void 0 ? void 0 : data.retries) >= 0) {
+                                    data.retries = attempt;
+                                }
+                                // Wait before retrying (Exponential Backoff)
+                                let retryDelay;
+                                let count = retry_delay.length === attempt ? retry_delay[retry_delay.length - 1] : retry_delay[attempt - 1];
+                                retryDelay = Number(count);
+                                yield this.sendMessageToRetryQueue(attempt, data, retryDelay, queueName);
+                                logger_1.Logger.info(`Retrying in ${retryDelay / 1000} seconds...`, 'consumeMessage');
+                                yield new Promise((resolve) => setTimeout(resolve, retryDelay));
+                            }
+                            else {
+                                logger_1.Logger.info(`Acknowledge the successful processing`, 'consumeMessage');
+                            }
+                            // Acknowledge the successful processing
+                            channel.ack(message);
+                        }
+                        catch (error) {
+                            let errorMessage = error.message;
+                            logger_1.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_1.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
+     */
+    sendMessageToDeadLatter(attempt, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info("Reached: send message on dead later queue", 'sendMessageToDeadLater');
+            try {
+                if (isConnectionOpen) {
+                    return channel.sendToQueue(dlx_queue, Buffer.from(JSON.stringify(data)), {
+                        persistent: true,
+                        headers: {
+                            'x-retry-count': attempt - 1
+                        },
+                    });
+                }
+            }
+            catch (error) {
+                logger_1.Logger.error("Error in send message on dead later queue", 'sendMessageToDeadLater', { message: error.message });
+                throw error;
+            }
+        });
+    }
+    /***
+     * Function to send message to retry queue
+     * @param attempt
+     * @param data
+     * @param retryDelay
+     * @param queueName
+     * @returns
+     */
+    sendMessageToRetryQueue(attempt, data, retryDelay, queueName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info("Reached: send message on retry queue", 'sendMessageToRetryQueue');
+            try {
+                if (isConnectionOpen) {
+                    const isSent = yield new Promise((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_1.Logger.debug(`Message sent successfully`, 'publishMessage', { data, queueName });
+                            resolve(true);
+                        }
+                        else {
+                            logger_1.Logger.error(`Failed to publish message.`, 'publishMessage', { message: data.toString() });
+                            reject(false);
+                        }
+                    });
+                    return isSent;
+                }
+            }
+            catch (error) {
+                logger_1.Logger.error("Error in send message on retry queue", 'sendMessageToRetryQueue', { message: error.message });
+                throw error;
+            }
+        });
+    }
+    /**
+     * Function to find the queue, exchange and add binding
+     * @param queueName
+     * @param exchangeName
+     * @returns
+     */
+    findQueueAndExchange(queueName, exchangeName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            logger_1.Logger.info('Reached to findQueueAndExchange', 'findQueueAndExchange');
+            try {
+                let exchanges = configData === null || configData === void 0 ? void 0 : configData.exchanges;
+                let queues = configData.queues;
+                let bindings = configData.bindings;
+                // Declare the queues with dlx
+                for (let data of queues) {
+                    if ((data === null || data === void 0 ? void 0 : data.name) === queueName) {
+                        yield this.createQueue(data);
+                    }
+                    logger_1.Logger.info(`${data === null || data === void 0 ? void 0 : data.name} queue created `, 'findQueueAndExchange');
+                }
+                // Declare the exchange with dlx 
+                for (let data of exchanges) {
+                    if ((data === null || data === void 0 ? void 0 : data.name) === exchangeName) {
+                        yield this.createExchange(data);
+                    }
+                    logger_1.Logger.info(`${data === null || data === void 0 ? void 0 : data.name} exchange created`, 'findQueueAndExchange');
+                }
+                // Declare the bindings for queues and exchanges with routing keys
+                for (let obj in bindings) {
+                    (_a = bindings[obj]) === null || _a === void 0 ? void 0 : _a.forEach((key) => __awaiter(this, void 0, void 0, function* () {
+                        if (obj === exchangeName && (key === null || key === void 0 ? void 0 : key.queue) === queueName) {
+                            yield this.bindQueueAndExchanges(obj, key === null || key === void 0 ? void 0 : key.queue, key === null || key === void 0 ? void 0 : key.routingKey);
+                        }
+                        logger_1.Logger.info(`${key === null || key === void 0 ? void 0 : key.queue} bind with exchange name ${obj} and routing key ${key === null || key === void 0 ? void 0 : key.routingKey}`, 'findQueueAndExchange');
+                    }));
+                }
+            }
+            catch (error) {
+                logger_1.Logger.error("Error on setup queues, exchanges and binding", 'findQueueAndExchange', error.message);
+                throw error;
+            }
+        });
+    }
+    /**
+      * Function to setup the queues and exchanges
+      * @params array
+      * @rtrun
+    */
+    setupQueuesAndExchanges() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            logger_1.Logger.info('Reached to setupQueuesAndExchanges', 'setupQueuesAndExchanges');
+            try {
+                let exchanges = configData.exchanges;
+                let queues = configData.queues;
+                let bindings = configData.bindings;
+                // Declare the exchange with dlx 
+                for (let data of exchanges) {
+                    yield this.createExchange(data);
+                    logger_1.Logger.info(`${data === null || data === void 0 ? void 0 : data.name} exchange created`, 'setupQueuesAndExchanges');
+                }
+                // Declare the queues with dlx
+                for (let data of queues) {
+                    yield this.createQueue(data);
+                    logger_1.Logger.info(`${data === null || data === void 0 ? void 0 : data.name} queue created `, 'setupQueuesAndExchanges');
+                }
+                // Declare the bindings for queues and exchanges with routing keys
+                for (let obj in bindings) {
+                    (_a = bindings[obj]) === null || _a === void 0 ? void 0 : _a.forEach((key) => __awaiter(this, void 0, void 0, function* () {
+                        yield this.bindQueueAndExchanges(obj, key === null || key === void 0 ? void 0 : key.queue, key === null || key === void 0 ? void 0 : key.routingKey);
+                        logger_1.Logger.info(`${key === null || key === void 0 ? void 0 : key.queue} bind with exchange name ${obj} and routing key ${key === null || key === void 0 ? void 0 : key.routingKey}`, 'setupQueuesAndExchanges');
+                    }));
+                }
+            }
+            catch (error) {
+                logger_1.Logger.error("Error on setup queues, exchanges and binding", 'setupQueuesAndExchanges', error.message);
+            }
+        });
+    }
+    ;
+    /**
+     * Function to binding queue and exchange
+     * @param exchangeName
+     * @param queueName
+     * @param routingKey
+     */
+    bindQueueAndExchanges(exchangeName, queueName, routingKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield channel.bindQueue(queueName, exchangeName, routingKey, { 'toQueue': queueName, 'x-match': 'any' });
+            }
+            catch (error) {
+                logger_1.Logger.error('Error in bind Queue and exchange', 'bindQueueAndExchanges', { message: error.message });
+            }
+        });
+    }
+    /**
+    * Function to create the queue
+    * @param data
+    */
+    createQueue(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield channel.assertQueue(data === null || data === void 0 ? void 0 : data.name, { durable: data.durable, exclusive: data.exclusive, autoDelete: data.autoDelete, arguments: data.arguments });
+            }
+            catch (error) {
+                logger_1.Logger.error('Error in Create Queue', 'createQueue', { message: error.message });
+            }
+        });
+    }
+    /**
+    * Function to create the exchange
+    * @param data
+    */
+    createExchange(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield channel.assertExchange(data === null || data === void 0 ? void 0 : data.name, data.type, { durable: data.durable, autoDelete: data.autoDelete });
+            }
+            catch (error) {
+                logger_1.Logger.error('Error in Create exchange', 'createExchange', { message: 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
+      */
+    createConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.Logger.info('Reached to createConnection', 'createConnection');
+                configManager.loadConfig(RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.CONFIG_PATH);
+                let url = `amqp://${RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.USER}:${RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.PASS}@${RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.HOST}`;
+                // Create a connection to RabbitMQ server
+                connection = yield amqp.connect(url, { heartbeat: RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.HEARTBEAT });
+                isConnectionOpen = true;
+                // check the connection status
+                this.bindConnectionEventHandler();
+                // create channel
+                channel = yield connection.createConfirmChannel();
+                channel.prefetch(RABBITMQ === null || RABBITMQ === void 0 ? void 0 : RABBITMQ.PREFETCH_COUNT);
+                logger_1.Logger.info('RabbitMQ connected successfully! ', 'createConnection');
+                // create exchange and queue and bind with exchange
+                yield this.setupQueuesAndExchanges();
+                const connectionWrapper = { connection, channel };
+                return connectionWrapper;
+            }
+            catch (error) {
+                // Log and rethrow any errors that occur during connection
+                logger_1.Logger.error('Failed to connect to RabbitMQ', 'connection', error === null || error === void 0 ? void 0 : error.message);
+                return { connection: null, channel: null };
+            }
+        });
+    }
+    /**
+     * Function for bind connection event handler on close and error setupQueuesAndExchanges
+     * @returns
+     */
+    bindConnectionEventHandler() {
+        try {
+            connection.on('close', (err) => __awaiter(this, void 0, void 0, function* () {
+                logger_1.Logger.error(`RabbitMQ: bindConnectionEventHandler:close`, `Connection closed`, err);
+                isConnectionOpen = false;
+                if (connectionRetry <= maxRetries) {
+                    yield this.createConnection();
+                    connectionRetry++;
+                }
+            }));
+            connection.on('error', (err) => __awaiter(this, void 0, void 0, function* () {
+                logger_1.Logger.error(`RabbitMQ: bindConnectionEventHandler:error`, `Connection error`, err);
+                isConnectionOpen = false;
+                if (connectionRetry <= maxRetries) {
+                    yield this.createConnection();
+                    connectionRetry++;
+                }
+            }));
+            return isConnectionOpen;
+        }
+        catch (error) {
+            isConnectionOpen = false;
+            return isConnectionOpen;
+        }
+    }
+}
+exports.MessageBrokerClient = MessageBrokerClient;
+//# sourceMappingURL=MessageBrokerClient.js.map