@hastehaul/common 2.0.46 → 2.0.48

package/build/connections-wrappers/redis-wrapper.d.ts

@@ -1,14 +1,13 @@
-import IORedis from 'ioredis';
 export declare class RedisClient {
     private master;
     private replicas;
-    private _redisClient?;
     private static instance;
     private constructor();
-    static getInstance(masterHost: string, replicaHosts: string[]): RedisClient;
-    executeMasterOperation(command: string, ...args: any[]): Promise<any>;
-    executeReplicaOperation(command: string, ...args: any[]): Promise<any>;
-    executeOperation(client: IORedis, command: string, ...args: any[]): Promise<any>;
+    get client(): RedisClient;
+    static connect(masterHost: string, replicaHosts: string[]): Promise<RedisClient>;
+    private executeMasterOperation;
+    private executeReplicaOperation;
+    private executeOperation;
     set(key: string, value: string): Promise<any>;
     get(key: string): Promise<any>;
     del(key: string): Promise<any>;

package/build/connections-wrappers/redis-wrapper.js

@@ -38,23 +38,48 @@ class RedisClient {
     constructor(masterHost, replicaHosts) {
         this.master = new ioredis_1.default({ host: masterHost, port: 6379 });
         this.replicas = replicaHosts.map(replicaHost => new ioredis_1.default({ host: replicaHost, port: 6379 }));
-        this.master.on("connect", () => console.info("Redis Server Connected!"));
-        this.master.on("error", (error) => console.error("Error in Redis", error.message));
-        this.replicas.forEach((client) => {
-            client.on('connect', () => console.log('Replica connected'));
-            client.on('error', (error) => console.log('Replica connected', error.message));
+        const masterConnected = new Promise((resolve) => {
+            this.master.on('connect', () => {
+                console.log('Master connected');
+                resolve();
+            });
+            this.master.on('error', (error) => {
+                console.log('Master connection error:', error.message);
+                resolve();
+            });
+        });
+        const replicaPromises = this.replicas.map((replica) => {
+            return new Promise((resolve) => {
+                replica.on('connect', () => {
+                    console.log('Replica connected');
+                    resolve();
+                });
+                replica.on('error', (error) => {
+                    console.log('Replica connection error:', error.message);
+                    resolve();
+                });
+            });
+        });
+        // Wait for all connections to be established
+        Promise.all([masterConnected, ...replicaPromises]).then(() => {
+            console.log('All connections established');
         });
     }
-    //   get client(): IORedis {
-    //     if(!this._redisClient) throw new Error("Cannot access Redis Client before connecting")
-    //     return this._redisClient;
-    //   }
-    static getInstance(masterHost, replicaHosts) {
-        if (!RedisClient.instance) {
-            RedisClient.instance = new RedisClient(masterHost, replicaHosts);
-        }
+    get client() {
+        if (!RedisClient.instance)
+            throw new Error("Cannot access Redis Client before connecting");
         return RedisClient.instance;
     }
+    static connect(masterHost, replicaHosts) {
+        return new Promise((resolve) => {
+            if (!RedisClient.instance) {
+                const redisClient = new RedisClient(masterHost, replicaHosts);
+                RedisClient.instance = redisClient;
+                resolve(redisClient);
+            }
+            resolve(RedisClient.instance);
+        });
+    }
     executeMasterOperation(command, ...args) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.executeOperation(this.master, command, ...args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hastehaul/common",
-  "version": "2.0.46",
+  "version": "2.0.48",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",