@modernlock/common 1.0.27 → 1.0.28

package/build/config/elasticsearch.d.ts

@@ -0,0 +1 @@
+export declare function checkElasticSearchConnection(): Promise<void>;

package/build/config/elasticsearch.js

@@ -0,0 +1,41 @@
+"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 });
+exports.checkElasticSearchConnection = void 0;
+const elasticsearch_1 = require("@elastic/elasticsearch");
+const logger_1 = require("../utils/logger");
+const log = (0, logger_1.winstonLogger)(process.env.ELASTIC_SEARCH_URL, "reservationElasticsearchServer", "debug");
+const elasticSearchClient = new elasticsearch_1.Client({
+    node: process.env.ELASTIC_SEARCH_URL,
+    // auth: {
+    //   username: process.env.ELASTIC_USERNAME as string,
+    //   password: process.env.ELASTIC_PASSWORD as string
+    // }
+});
+function checkElasticSearchConnection() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let isConnected = false;
+        while (!isConnected) {
+            try {
+                const health = yield elasticSearchClient.cluster.health({});
+                log.info(`ReservationService elasticsearch health status - ${health.status}`);
+                console.log(`ReservationService elasticsearch health status - ${health.status}`);
+                isConnected = true;
+            }
+            catch (error) {
+                log.error("Connection to elasticSearch faild. Retrying....");
+                log.log("error", "ReservationService checkConnection() method:", error);
+            }
+        }
+    });
+}
+exports.checkElasticSearchConnection = checkElasticSearchConnection;
+;

package/build/config/elasticsearchConnection.d.ts

@@ -0,0 +1,11 @@
+export declare class ElasticsearchConnection {
+    private client;
+    private url;
+    private isConnected;
+    private isConnecting;
+    private reconnectRetries;
+    connect(url: string, username?: string, password?: string): Promise<void>;
+    connectWithRetries(url: string): Promise<void>;
+    private reconnect;
+}
+export declare const elasticsearchConnection: ElasticsearchConnection;

package/build/config/elasticsearchConnection.js

@@ -0,0 +1,81 @@
+"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 });
+exports.elasticsearchConnection = exports.ElasticsearchConnection = void 0;
+const elasticsearch_1 = require("@elastic/elasticsearch");
+const MAX_RETRIES = 5; // Maximum number of reconnection attempts
+const INITIAL_DELAY_MS = 1000; //
+class ElasticsearchConnection {
+    constructor() {
+        this.isConnected = false;
+        this.isConnecting = false;
+        this.reconnectRetries = 0; // Number of reconnection attempts
+    }
+    connect(url, username, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected || this.isConnecting)
+                return;
+            this.isConnecting = true;
+            this.client = new elasticsearch_1.Client({
+                node: url,
+                // auth: {
+                //   username: process.env.ELASTIC_USERNAME as string,
+                //   password: process.env.ELASTIC_PASSWORD as string
+                // }
+            });
+            try {
+                const health = yield this.client.cluster.health({});
+                this.url = url;
+                this.isConnected = true;
+            }
+            catch (error) {
+                console.log("Failed to connect to elastic search", error);
+                this.isConnecting = false;
+                this.reconnect();
+            }
+        });
+    }
+    ;
+    connectWithRetries(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.connect(url);
+                console.log('Connected to elastic search');
+            }
+            catch (error) {
+                console.error('Failed to connect to elastic search:', error);
+                // Implement reconnection logic with exponential backoff
+                if (this.reconnectRetries < MAX_RETRIES) {
+                    const delay = INITIAL_DELAY_MS * Math.pow(2, this.reconnectRetries);
+                    console.log(`Retrying connection in ${delay} ms (attempt ${this.reconnectRetries + 1} of ${MAX_RETRIES})`);
+                    this.reconnectRetries++;
+                    setTimeout(() => {
+                        this.connectWithRetries(url);
+                    }, delay);
+                }
+                else {
+                    console.error(`Max reconnection attempts (${MAX_RETRIES}) reached. Could not reconnect to elastic search.`);
+                }
+            }
+        });
+    }
+    reconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnecting && !this.isConnected) {
+                console.log("Attempting to reconnect to elastic search...");
+                this.connectWithRetries(this.url);
+            }
+        });
+    }
+    ;
+}
+exports.ElasticsearchConnection = ElasticsearchConnection;
+exports.elasticsearchConnection = new ElasticsearchConnection();

package/build/index.d.ts

@@ -28,3 +28,5 @@ export * from "./utils/jwtEncryption";
 export * from "./utils/logger";
 export * from "./logger/custom-logger";
 export * from "./logger/transporterOptions";
+export * from "./config/elasticsearch";
+export * from "./config/elasticsearchConnection";

package/build/index.js

@@ -44,3 +44,5 @@ __exportStar(require("./utils/jwtEncryption"), exports);
 __exportStar(require("./utils/logger"), exports);
 __exportStar(require("./logger/custom-logger"), exports);
 __exportStar(require("./logger/transporterOptions"), exports);
+__exportStar(require("./config/elasticsearch"), exports);
+__exportStar(require("./config/elasticsearchConnection"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modernlock/common",
-  "version": "1.0.27",
+  "version": "1.0.28",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "files": [