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

package/dist/src/messageBroker/ConnectionManager.js

@@ -0,0 +1,227 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Import the amqplib library for RabbitMQ
+const amqp = __importStar(require("amqplib"));
+const logger_1 = require("../Util/logger");
+const ConfigManager_1 = __importDefault(require("../config/ConfigManager"));
+const config_1 = __importDefault(require("../config"));
+let isConnectionOpen = false;
+let MAX_RETRIES = 1;
+class ConnectionManager {
+    constructor() {
+        this.configData = {};
+        this.configManager = ConfigManager_1.default.getInstance();
+        this.init();
+    }
+    /**
+     * Function for get channel
+     */
+    getChannel() {
+        return this.channel;
+    }
+    /**
+     * Function for get channel
+     */
+    getConnection() {
+        return this.connection;
+    }
+    /**
+     * Function for create and return intance
+     * @returns
+     */
+    static getInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ConnectionManager.instance) {
+                ConnectionManager.instance = new ConnectionManager();
+            }
+            return ConnectionManager.instance;
+        });
+    }
+    /**
+      * Function to connect create to RabbitMQ
+      */
+    createConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            try {
+                logger_1.Logger.info('Reached to createConnection', 'createConnection');
+                this.configManager.loadConfig((_a = config_1.default === null || config_1.default === void 0 ? void 0 : config_1.default.RABBITMQ) === null || _a === void 0 ? void 0 : _a.CONFIG_PATH);
+                let url = `amqp://${(_b = this.configData) === null || _b === void 0 ? void 0 : _b.username}:${(_c = this.configData) === null || _c === void 0 ? void 0 : _c.password}@${(_d = this.configData) === null || _d === void 0 ? void 0 : _d.host}`;
+                // Create a connection to RabbitMQ server
+                this.connection = yield amqp.connect(url, { heartbeat: (_e = this.configData) === null || _e === void 0 ? void 0 : _e.heartbeat });
+                isConnectionOpen = true;
+                // check the connection status
+                this.bindConnectionEventHandler();
+                // create channel
+                this.channel = yield this.connection.createConfirmChannel();
+                logger_1.Logger.info('RabbitMQ connected successfully! ', 'createConnection');
+                // create exchange and queue and bind with exchange
+                yield this.setupQueuesAndExchanges();
+                const connectionWrapper = { connection: this.connection, channel: this.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() {
+        var _a, _b;
+        try {
+            (_a = this.connection) === null || _a === void 0 ? void 0 : _a.on('close', (err) => {
+                logger_1.Logger.error(`RabbitMQ: bindConnectionEventHandler:close`, `Connection closed`, err);
+                isConnectionOpen = false;
+            });
+            (_b = this.connection) === null || _b === void 0 ? void 0 : _b.on('error', (err) => {
+                logger_1.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
+    */
+    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* () {
+            var _a;
+            logger_1.Logger.info('Reached to initialize', 'initialize');
+            let retries = 0;
+            MAX_RETRIES = (_a = this.configData) === null || _a === void 0 ? void 0 : _a.max_retries;
+            // Retrie times connection
+            while (retries < MAX_RETRIES) {
+                try {
+                    yield this.createConnection();
+                    return { connection: this.connection, channel: this.channel };
+                }
+                catch (err) {
+                    retries++;
+                    logger_1.Logger.error('initialize:Failed to connect to RabbitMQ', `Attempt ${retries} of ${MAX_RETRIES}.`);
+                    if (retries >= MAX_RETRIES) {
+                        logger_1.Logger.error('Max retries reached, cannot connect to RabbitMQ.', 'initialize');
+                        return { connection: this.connection, channel: this.channel };
+                    }
+                    // Wait before retrying (e.g., 10 seconds)
+                    yield new Promise(resolve => setTimeout(resolve, 10000));
+                }
+            }
+        });
+    }
+    ;
+    /**
+      * Function to setup the queues and exchanges
+      * @params array
+      * @rtrun
+    */
+    setupQueuesAndExchanges() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            logger_1.Logger.info('Reached to setupQueuesAndExchanges', 'setupQueuesAndExchanges');
+            try {
+                let exchanges = this.configData.exchanges;
+                let queues = this.configData.queues;
+                let bindings = this.configData.bindings;
+                // Declare the exchange with dlx 
+                for (let data of exchanges) {
+                    yield ((_a = this.channel) === null || _a === void 0 ? void 0 : _a.assertExchange(data === null || data === void 0 ? void 0 : data.name, data.type, { durable: data.durable, autoDelete: data.autoDelete }));
+                    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 ((_b = this.channel) === null || _b === void 0 ? void 0 : _b.assertQueue(data === null || data === void 0 ? void 0 : data.name, { durable: data.durable, exclusive: data.exclusive, autoDelete: data.autoDelete, arguments: data.arguments }));
+                    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) {
+                    (_c = bindings[obj]) === null || _c === void 0 ? void 0 : _c.forEach((key) => __awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        yield ((_a = this.channel) === null || _a === void 0 ? void 0 : _a.bindQueue(key === null || key === void 0 ? void 0 : key.queue, obj, 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);
+                throw error;
+            }
+        });
+    }
+    ;
+    /**
+     * Function for load the config data
+     */
+    init() {
+        var _a;
+        this.configManager.loadConfig((_a = config_1.default === null || config_1.default === void 0 ? void 0 : config_1.default.RABBITMQ) === null || _a === void 0 ? void 0 : _a.CONFIG_PATH);
+        this.configData = this.configManager.getConfig();
+    }
+}
+exports.default = ConnectionManager;
+//# sourceMappingURL=ConnectionManager.js.map

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

@@ -0,0 +1,34 @@
+import { IMessageBrokerClient } from './interface/IMessageBrokerClient';
+import { PublishMessageInputType } from './types/PublishMessageInputType';
+export declare class MessageBrokerClient implements IMessageBrokerClient {
+    private readonly rabbitMQClient;
+    private readonly messageProducer;
+    private readonly configManager;
+    private readonly isEnabledRabbitMQ;
+    private readonly configData;
+    constructor();
+    /**
+     * Function to initialize the RabbitMQ connection
+     */
+    initialize(): Promise<void>;
+    /**
+     * Function to close the connection and channel
+     */
+    disconnect(): void;
+    /**
+     * Function to publish a message with retry
+     * @param request
+     * @returns
+     */
+    publishMessage(request: PublishMessageInputType): Promise<boolean>;
+    /**
+     * Function to publish a message with retry to exchange
+     * @param request
+     * @returns
+     */
+    publishMessageToExchange(request: PublishMessageInputType): Promise<boolean>;
+    /***
+     * Function to check if the connection is established
+     */
+    isConnected(): Promise<boolean>;
+}

package/dist/src/messageBroker/MessageBrokerClient.js

@@ -0,0 +1,102 @@
+"use strict";
+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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageBrokerClient = void 0;
+const config_1 = __importDefault(require("../config"));
+const ConfigManager_1 = __importDefault(require("../config/ConfigManager"));
+const ConnectionManager_1 = __importDefault(require("./ConnectionManager"));
+const MessageProducer_1 = __importDefault(require("./MessageProducer"));
+const RabbitMQClient_1 = require("./RabbitMQClient");
+const RetryManager_1 = __importDefault(require("./RetryManager"));
+const connectionManager = ConnectionManager_1.default.getInstance();
+class MessageBrokerClient {
+    constructor() {
+        var _a;
+        // private readonly retryManager: RetryManager<T>;
+        this.isEnabledRabbitMQ = false;
+        this.configData = {};
+        this.rabbitMQClient = new RabbitMQClient_1.RabbitMQClient();
+        this.messageProducer = new MessageProducer_1.default();
+        this.isEnabledRabbitMQ = ((_a = config_1.default === null || config_1.default === void 0 ? void 0 : config_1.default.RABBITMQ) === null || _a === void 0 ? void 0 : _a.IS_ENABLED) === 'true';
+        this.configManager = ConfigManager_1.default.getInstance();
+        this.configData = this.configManager.getConfig();
+    }
+    /**
+     * Function to initialize the RabbitMQ connection
+     */
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isEnabledRabbitMQ) {
+                this.rabbitMQClient.initialize();
+            }
+        });
+    }
+    /**
+     * Function to close the connection and channel
+     */
+    disconnect() {
+        if (this.isEnabledRabbitMQ) {
+            this.rabbitMQClient.disconnect();
+        }
+    }
+    /**
+     * Function to publish a message with retry
+     * @param request
+     * @returns
+     */
+    publishMessage(request) {
+        var _a, _b;
+        if (this.isEnabledRabbitMQ) {
+            const boundPublishMessage = this.messageProducer.publishMessage.bind(this);
+            const boundConsumerHandler = this.messageProducer.messageHandler.bind(this);
+            let retry_delay = (_a = this.configData) === null || _a === void 0 ? void 0 : _a.retry_delay;
+            let max_retries = (_b = this.configData) === null || _b === void 0 ? void 0 : _b.max_retries;
+            // Instantiate RetryManager
+            const retryManager = RetryManager_1.default.getInstance(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) {
+        var _a, _b;
+        if (this.isEnabledRabbitMQ) {
+            const boundPublishMessage = this.messageProducer.publishMessageToExchange.bind(this);
+            const boundConsumerHandler = this.messageProducer.messageHandler.bind(this);
+            let retry_delay = (_a = this.configData) === null || _a === void 0 ? void 0 : _a.retry_delay;
+            let max_retries = (_b = this.configData) === null || _b === void 0 ? void 0 : _b.max_retries;
+            // Instantiate RetryManager
+            const retryManager = RetryManager_1.default.getInstance(max_retries, retry_delay);
+            retryManager.performActionWithRetry(boundPublishMessage, request, boundConsumerHandler);
+        }
+        return Promise.resolve(false);
+    }
+    /***
+     * Function to check if the connection is established
+     */
+    isConnected() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isEnabledRabbitMQ) {
+                return (yield connectionManager) ? (yield connectionManager).isConnected() : Promise.resolve(false);
+            }
+            return Promise.resolve(false);
+        });
+    }
+}
+exports.MessageBrokerClient = MessageBrokerClient;
+//# sourceMappingURL=MessageBrokerClient.js.map

package/dist/src/messageBroker/MessageConsumer.d.ts

@@ -0,0 +1,26 @@
+import BaseRabbitMQClient from "./BaseRabbitMQClient";
+declare class MessageConsumer extends BaseRabbitMQClient {
+    private readonly messageProducer;
+    constructor();
+    /**
+   * Funvction for initialize consumer queue
+   * @param consumerQueues
+   */
+    initializeConsumers(): Promise<{
+        error: string;
+    } | undefined>;
+    /**
+     * Function to consume message with retry
+     * @param queueName
+     */
+    private consumerMessage;
+    /**
+     * Function for consumer massage handler
+     * @param channel
+     * @param queue
+     * @param message
+     * @returns
+     */
+    private consumerHandler;
+}
+export default MessageConsumer;

package/dist/src/messageBroker/MessageConsumer.js

@@ -0,0 +1,102 @@
+"use strict";
+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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("../Util/logger");
+const RetryManager_1 = __importDefault(require("./RetryManager"));
+const MessageProducer_1 = __importDefault(require("./MessageProducer"));
+const BaseRabbitMQClient_1 = __importDefault(require("./BaseRabbitMQClient"));
+let configData = {};
+let max_retries = 0; // Maximum retries for connection and queue
+let retry_delay = ""; // Back-off time for message retry
+class MessageConsumer extends BaseRabbitMQClient_1.default {
+    constructor() {
+        super();
+        this.messageProducer = new MessageProducer_1.default();
+    }
+    /**
+   * Funvction for initialize consumer queue
+   * @param consumerQueues
+   */
+    initializeConsumers() {
+        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 (const queue in configData === null || configData === void 0 ? void 0 : configData.consume_queues) {
+                    if (Object.prototype.hasOwnProperty.call(consume_queues, queue)) {
+                        // Call function Consume messages with retry
+                        yield this.consumerMessage(queue);
+                    }
+                }
+            }
+            catch (error) {
+                logger_1.Logger.error('Error initializing consumers:', 'initializeConsumers', error.message);
+                return { error: error.message };
+            }
+        });
+    }
+    /**
+     * Function to consume message with retry
+     * @param queueName
+     */
+    consumerMessage(queueName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            logger_1.Logger.info("Reached: Consuming messages from the main queue", 'consumerMessage');
+            yield ((_a = this.channel) === null || _a === void 0 ? void 0 : _a.consume(queueName, (message) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                if (message) {
+                    let msgData = message.content.toString();
+                    const success = yield this.consumerHandler({ queueName, message: msgData });
+                    try {
+                        if (!success) {
+                            const boundPublishMessage = this.messageProducer.publishMessage.bind(this);
+                            const boundConsumerHandler = this.consumerHandler.bind(this);
+                            retry_delay = configData === null || configData === void 0 ? void 0 : configData.retry_delay;
+                            const reqData = { queueName, message };
+                            // Instantiate RetryManager
+                            const retryManager = RetryManager_1.default.getInstance(max_retries, retry_delay);
+                            retryManager.performActionWithRetry(boundPublishMessage, reqData, boundConsumerHandler);
+                        }
+                        else {
+                            logger_1.Logger.info(`Acknowledge the successful processing`, 'consumerMessage');
+                            (_a = this.channel) === null || _a === void 0 ? void 0 : _a.ack(message); // Acknowledge the successful processing
+                        }
+                    }
+                    catch (error) {
+                        logger_1.Logger.error(`Error processing message`, 'consumerMessage', { message: error.message });
+                        (_b = this.channel) === null || _b === void 0 ? void 0 : _b.nack(message, false, false); // Move message to DLQ after failure
+                    }
+                }
+            })));
+        });
+    }
+    ;
+    /**
+     * Function for consumer massage handler
+     * @param channel
+     * @param queue
+     * @param message
+     * @returns
+     */
+    consumerHandler(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info(`${JSON.stringify(request)}`, 'consumerHandler');
+            return true;
+        });
+    }
+}
+exports.default = MessageConsumer;
+//# sourceMappingURL=MessageConsumer.js.map

package/dist/src/messageBroker/MessageProducer.d.ts

@@ -0,0 +1,29 @@
+import BaseRabbitMQClient from "./BaseRabbitMQClient";
+import ConnectionManager from "./ConnectionManager";
+import { PublishMessageInputType } from "./types/PublishMessageInputType";
+declare class MessageProducer extends BaseRabbitMQClient {
+    private readonly correlationId;
+    connectionManager: ConnectionManager;
+    constructor();
+    /**
+      * Function to publish a message with retry
+      * @param queueName
+      * @param message
+      * @returns
+    */
+    publishMessage(request: PublishMessageInputType): Promise<boolean>;
+    /**
+      * Function to publish a message with retry
+      * @param exchangeName
+      * @param routingKey
+      * @param message
+      * @param options
+      * @returns
+    */
+    publishMessageToExchange(request: PublishMessageInputType): Promise<boolean>;
+    /**
+     * Funciton to message handler
+     */
+    messageHandler(request: PublishMessageInputType): Promise<boolean>;
+}
+export default MessageProducer;

package/dist/src/messageBroker/MessageProducer.js

@@ -0,0 +1,130 @@
+"use strict";
+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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commonUtil_1 = require("../Util/commonUtil");
+const logger_1 = require("../Util/logger");
+const BaseRabbitMQClient_1 = __importDefault(require("./BaseRabbitMQClient"));
+const ConnectionManager_1 = __importDefault(require("./ConnectionManager"));
+class MessageProducer extends BaseRabbitMQClient_1.default {
+    constructor() {
+        super();
+        this.correlationId = (0, commonUtil_1.generateCorrelationId)();
+        this.connectionManager = new ConnectionManager_1.default();
+    }
+    /**
+      * Function to publish a message with retry
+      * @param queueName
+      * @param message
+      * @returns
+    */
+    publishMessage(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queueName = request.queueName;
+            const data = request.message;
+            console.log(data.message, queueName, 'message');
+            logger_1.Logger.info('Reached:publishMessage', 'publishMessage');
+            const messageBuffer = Buffer.from(JSON.stringify(data === null || data === void 0 ? void 0 : data.message));
+            this.channel = this.connectionManager.getChannel();
+            try {
+                const isSent = yield new Promise((resolve, reject) => {
+                    var _a, _b;
+                    (_a = this.connection) === null || _a === void 0 ? void 0 : _a.on('close', (err) => {
+                        logger_1.Logger.error(`RabbitMQ: bindConnectionEventHandler:close`, `Connection closed`, err);
+                    });
+                    let sent = (_b = this.channel) === null || _b === void 0 ? void 0 : _b.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_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);
+                    }
+                });
+                console.log(isSent);
+                return true;
+                ;
+            }
+            catch (error) {
+                console.log(error);
+                logger_1.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
+    */
+    publishMessageToExchange(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            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 messageObj = {
+            //     message,
+            //     correlationId:this.correlationId,
+            // }
+            logger_1.Logger.info('Reached:publishMessageToExchange', 'publishMessageToExchange');
+            // Publish the message
+            const messageBuffer = Buffer.from(JSON.stringify(data.message));
+            try {
+                const isSent = yield new Promise((resolve, reject) => {
+                    var _a;
+                    // this.channel?.on
+                    const sent = (_a = this.channel) === null || _a === void 0 ? void 0 : _a.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);
+                    }
+                });
+                return isSent;
+            }
+            catch (error) {
+                logger_1.Logger.error(`Error sending message: ${error}`, 'sendMessage');
+                return false;
+            }
+        });
+    }
+    ;
+    /**
+     * Funciton to message handler
+     */
+    messageHandler(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info(`${JSON.stringify(request)}`, 'messageHandler');
+            return true;
+        });
+    }
+}
+exports.default = MessageProducer;
+//# sourceMappingURL=MessageProducer.js.map

package/dist/src/messageBroker/RabbitMQClient.d.ts

@@ -0,0 +1,12 @@
+import BaseRabbitMQClient from './BaseRabbitMQClient';
+export declare class RabbitMQClient extends BaseRabbitMQClient {
+    constructor();
+    /**
+     * Function to initialize the RabbitMQ connection
+     */
+    initialize(): Promise<void>;
+    /**
+     * Function to close the connection and channel
+     */
+    disconnect(): Promise<void>;
+}