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

package/dist/src/messageBroker/RabbitMQClient.js

@@ -0,0 +1,67 @@
+"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.RabbitMQClient = void 0;
+// Import the amqplib library for RabbitMQ
+const logger_1 = require("../Util/logger");
+const BaseRabbitMQClient_1 = __importDefault(require("./BaseRabbitMQClient"));
+const ConnectionManager_1 = __importDefault(require("./ConnectionManager"));
+class RabbitMQClient extends BaseRabbitMQClient_1.default {
+    constructor() {
+        super();
+    }
+    /**
+     * Function to initialize the RabbitMQ connection
+     */
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.Logger.info('Reached to initialize', 'initialize');
+                // Create a connection to RabbitMQ server
+                const connectionManager = yield ConnectionManager_1.default.getInstance();
+                yield connectionManager.createConnection();
+                logger_1.Logger.info('RabbitMQ connection created', 'initialize');
+            }
+            catch (error) {
+                // Log and rethrow any errors that occur during initialization
+                logger_1.Logger.error('Failed to create RabbitMQ connection', 'initialize', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Function to close the connection and channel
+     */
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                logger_1.Logger.info('Reached to disconnect', 'disconnect');
+                // Close the channel
+                yield ((_a = this.channel) === null || _a === void 0 ? void 0 : _a.close());
+                // Close the connection
+                yield ((_b = this.connection) === null || _b === void 0 ? void 0 : _b.close());
+                logger_1.Logger.info('RabbitMQ connection closed', 'disconnect');
+            }
+            catch (error) {
+                // Log and rethrow any errors that occur during closing
+                logger_1.Logger.error('Failed to close RabbitMQ connection', 'disconnect', error);
+                throw error;
+            }
+        });
+    }
+    ;
+}
+exports.RabbitMQClient = RabbitMQClient;
+//# sourceMappingURL=RabbitMQClient.js.map

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

@@ -0,0 +1,23 @@
+type ActionType<T> = (input: T) => void;
+declare class RetryManager<T> {
+    private static instance;
+    private readonly max_retry;
+    private readonly retry_delay;
+    constructor(max_retry: number, retry_delay: string);
+    /**
+     * Function for create singlton class instance and return instance
+     * @param max_retry
+     * @param retry_delay
+     * @returns
+     */
+    static getInstance<T>(max_retry: number, retry_delay: string): RetryManager<T>;
+    /**
+     * Function for perform action with retry
+     * @param actionHandler
+     * @param context
+     * @param failActionHandler
+     * @returns
+     */
+    performActionWithRetry(actionHandler: ActionType<T>, context: T, failActionHandler: ActionType<T>): Promise<boolean>;
+}
+export default RetryManager;

package/dist/src/messageBroker/RetryManager.js

@@ -0,0 +1,72 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("../Util/logger");
+class RetryManager {
+    constructor(max_retry, retry_delay) {
+        this.max_retry = max_retry;
+        this.retry_delay = retry_delay === null || retry_delay === void 0 ? void 0 : retry_delay.split("|");
+    }
+    /**
+     * Function for create singlton class instance and return instance
+     * @param max_retry
+     * @param retry_delay
+     * @returns
+     */
+    static getInstance(max_retry, retry_delay) {
+        if (!RetryManager.instance) {
+            RetryManager.instance = new RetryManager(max_retry, retry_delay);
+        }
+        return RetryManager.instance;
+    }
+    /**
+     * Function for perform action with retry
+     * @param actionHandler
+     * @param context
+     * @param failActionHandler
+     * @returns
+     */
+    performActionWithRetry(actionHandler, context, failActionHandler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.info("Reached: in perform action with retry", "performActionWithRetry");
+            let attempt = 0;
+            while (attempt < this.max_retry) {
+                try {
+                    actionHandler(context);
+                    return true;
+                }
+                catch (error) {
+                    attempt++;
+                    logger_1.Logger.error(`Failed to publish message. Attempt ${attempt} of ${this.max_retry}. Error:`, 'performActionWithRetry', { message: error.message });
+                    if (attempt >= this.max_retry) {
+                        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
+                        failActionHandler(context);
+                        return false;
+                    }
+                    // Wait before retrying (Exponential Backoff)
+                    let retryDelay;
+                    if (this.retry_delay.length - 1 === attempt) {
+                        retryDelay = Number(this.retry_delay[attempt - 1]);
+                    }
+                    else {
+                        retryDelay = Number(this.retry_delay[this.retry_delay.length - 1]);
+                    }
+                    logger_1.Logger.info(`Retrying in ${retryDelay / 1000} seconds...`, 'performActionWithRetry');
+                    yield new Promise((resolve) => setTimeout(resolve, retryDelay));
+                }
+            }
+            return false;
+        });
+    }
+}
+exports.default = RetryManager;
+//# sourceMappingURL=RetryManager.js.map

package/dist/src/messageBroker/interface/ConnectionWrapper.d.ts

@@ -0,0 +1,6 @@
+import * as amqp from 'amqplib';
+interface ConnectionWrapper {
+    connection: amqp.Connection;
+    channel: amqp.Channel;
+}
+export default ConnectionWrapper;

package/dist/src/messageBroker/interface/ConnectionWrapper.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ConnectionWrapper.js.map

package/dist/src/messageBroker/interface/IMessageBrokerClient.d.ts

@@ -0,0 +1,7 @@
+import { PublishMessageInputType } from "../types/PublishMessageInputType";
+export interface IMessageBrokerClient {
+    initialize(configData: object | null): void;
+    disconnect(): void;
+    publishMessage(request: PublishMessageInputType): Promise<boolean>;
+    publishMessageToExchange(request: PublishMessageInputType): Promise<boolean>;
+}

package/dist/src/messageBroker/interface/IMessageBrokerClient.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IMessageBrokerClient.js.map

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

@@ -0,0 +1,114 @@
+import * as amqp from 'amqplib';
+import ConnectionWrapper from '../interface/ConnectionWrapper';
+import { PublishMessageInputType } from '../types/PublishMessageInputType';
+import { ActionType } from '../types/ActionType';
+export declare class MessageBrokerClient {
+    /**
+      * Function to check the status of the connection
+      * @returns boolean
+    */
+    isConnected(): Promise<boolean>;
+    /**
+      * Function to initialize the connection, channel and setup the queues and exchanges
+      * @param reqData
+      * @returns
+    */
+    initialize(): Promise<{
+        connection: amqp.Connection;
+        channel: amqp.Channel;
+    } | undefined>;
+    /**
+      * Function to publish a message with retry
+      * @param request
+      * @param classInstance
+      * @param messagePublisherErrorHandler
+      * @returns
+    */
+    publishMessage(request: PublishMessageInputType): Promise<true | undefined>;
+    /**
+      * Function to publish a message with retry
+      * @param request
+      * @param classInstance
+      * @param messagePublisherErrorHandler
+      * @returns
+    */
+    publishMessageToExchange(request: PublishMessageInputType): Promise<true | undefined>;
+    /**
+     * Funciton to message handler
+     */
+    messagePublisherErrorHandler(request: PublishMessageInputType): Promise<boolean>;
+    /**
+     * Funvction for initialize consumer queue
+     * @param consumerQueues
+     */
+    initializeConsumers(classInstance: any, consumerHandler: string, consumerErrorHandler: string): Promise<void>;
+    /**
+         * Function for perform action with retry
+         * @param actionHandler
+         * @param context
+         * @param failActionHandler
+         * @returns
+         */
+    performActionWithRetry<T>(actionHandler: ActionType<T>, failActionHandler: ActionType<T>, context: T): Promise<boolean>;
+    /**
+     * Function to consume message with retry
+     * @param queueName
+     */
+    consumeMessage(queueName: string, classInstance: any, consumerHandler: string, consumerErrorHandler: string): Promise<amqp.Replies.Consume | undefined>;
+    /**
+     * Function to send message to dead later queue
+     * @param attempt
+     * @param data
+     * @param queueName
+     * @retruns
+     */
+    sendMessageToDeadLatter(attempt: number, data: any): Promise<boolean | undefined>;
+    /***
+     * Function to send message to retry queue
+     * @param attempt
+     * @param data
+     * @param retryDelay
+     * @param queueName
+     * @returns
+     */
+    sendMessageToRetryQueue(attempt: number, data: any, retryDelay: any, queueName: string): Promise<boolean | undefined>;
+    /**
+     * Function to find the queue, exchange and add binding
+     * @param queueName
+     * @param exchangeName
+     * @returns
+     */
+    findQueueAndExchange(queueName: string, exchangeName: string): Promise<void>;
+    /**
+      * Function to setup the queues and exchanges
+      * @params array
+      * @rtrun
+    */
+    private setupQueuesAndExchanges;
+    /**
+     * Function to binding queue and exchange
+     * @param exchangeName
+     * @param queueName
+     * @param routingKey
+     */
+    private bindQueueAndExchanges;
+    /**
+    * Function to create the queue
+    * @param data
+    */
+    private createQueue;
+    /**
+    * Function to create the exchange
+    * @param data
+    */
+    private createExchange;
+    /**
+      * Function to connect create to RabbitMQ
+      */
+    createConnection(): Promise<ConnectionWrapper>;
+    /**
+     * Function for bind connection event handler on close and error setupQueuesAndExchanges
+     * @returns
+     */
+    private bindConnectionEventHandler;
+}