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

package/src/messageBroker/RabbitMQClient.ts

@@ -0,0 +1,47 @@
+// Import the amqplib library for RabbitMQ
+import { Logger } from '../Util/logger';
+import BaseRabbitMQClient from './BaseRabbitMQClient';
+import ConnectionManager from './ConnectionManager';
+
+
+export class RabbitMQClient extends BaseRabbitMQClient {
+    constructor() {
+       super();
+    }
+
+    /**
+     * Function to initialize the RabbitMQ connection
+     */
+    public async initialize() {
+        try {
+            Logger.info('Reached to initialize', 'initialize');
+            // Create a connection to RabbitMQ server
+            const connectionManager = await ConnectionManager.getInstance();
+            await connectionManager.createConnection();
+            Logger.info('RabbitMQ connection created', 'initialize');
+        } catch (error) {
+            // Log and rethrow any errors that occur during initialization
+            Logger.error('Failed to create RabbitMQ connection', 'initialize', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Function to close the connection and channel
+     */
+    public async disconnect() {
+        try {
+            Logger.info('Reached to disconnect', 'disconnect');
+            // Close the channel
+            await this.channel?.close();
+            // Close the connection
+            await this.connection?.close();
+            Logger.info('RabbitMQ connection closed', 'disconnect');
+        } catch (error) {
+            // Log and rethrow any errors that occur during closing
+            Logger.error('Failed to close RabbitMQ connection', 'disconnect', error);
+            throw error;
+        }
+    };
+
+}

package/src/messageBroker/RetryManager.ts

@@ -0,0 +1,64 @@
+import { Logger } from '../Util/logger';
+type ActionType<T> = (input: T) => void;
+
+class RetryManager<T>{
+    private static instance: RetryManager<any>;
+    private readonly max_retry:number;
+    private readonly retry_delay:string[]|string;
+    
+    constructor(max_retry:number, retry_delay:string){
+        this.max_retry =  max_retry;
+        this.retry_delay = retry_delay?.split("|");
+    }
+
+    /**
+     * Function for create singlton class instance and return instance
+     * @param max_retry 
+     * @param retry_delay 
+     * @returns 
+     */
+    public static getInstance<T>(max_retry: number, retry_delay: string): RetryManager<T> {
+        if (!RetryManager.instance) {
+            RetryManager.instance = new RetryManager<T>(max_retry, retry_delay);
+        }
+        return RetryManager.instance as RetryManager<T>;
+    }
+    /**
+     * Function for perform action with retry
+     * @param actionHandler 
+     * @param context 
+     * @param failActionHandler 
+     * @returns 
+     */
+    public async performActionWithRetry(actionHandler:ActionType<T>, context:T, failActionHandler:ActionType<T>):Promise<boolean>{
+        Logger.info("Reached: in perform action with retry", "performActionWithRetry")
+        let attempt: number = 0;
+        while (attempt < this.max_retry) {
+            try {
+                actionHandler(context);
+                return true;
+            } catch (error) {
+                attempt++;
+                Logger.error(`Failed to publish message. Attempt ${attempt} of ${this.max_retry}. Error:`, 'performActionWithRetry', { message: (error as Error).message });
+                if (attempt >= this.max_retry) {
+                    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: number;
+                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.info(`Retrying in ${retryDelay / 1000} seconds...`, 'performActionWithRetry');
+                await new Promise((resolve) => setTimeout(resolve, retryDelay));
+            }
+        }
+        return false;
+    }
+    
+}
+export default RetryManager;

package/src/messageBroker/interface/ConnectionWrapper.ts

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

package/src/messageBroker/interface/IMessageBrokerClient.ts

@@ -0,0 +1,11 @@
+import { PublishMessageInputType } from "../types/PublishMessageInputType";
+
+export interface IMessageBrokerClient {
+    initialize(configData: object | null): void;
+    disconnect(): void;
+    // will create a class for publishOptions instead of object
+    publishMessage(request:PublishMessageInputType): Promise<boolean>;
+    // will create a class for publishOptions instead of object
+    publishMessageToExchange(request: PublishMessageInputType):Promise<boolean>;
+    // publish confirm in publishMessage need to implement
+}