moves out connect from redis cache class

Signed-off-by: Konstantina Blazhukova <konstantina.blajukova@gmail.com>

Author: konstantinabl

packages/relay/src/lib/clients/cache/redisCache.ts

@@ -3,7 +3,7 @@
 import { ConfigService } from '@hashgraph/json-rpc-config-service/dist/services';
 import { Logger } from 'pino';
 import { Registry } from 'prom-client';
-import type { RedisClientType } from 'redis';
+import { createClient } from 'redis';
 
 import { Utils } from '../../../utils';
 import { RedisCacheError } from '../../errors/RedisCacheError';
@@ -39,47 +39,20 @@ export class RedisCache implements IRedisCacheClient {
    * The Redis client.
    * @private
    */
-  private readonly client: RedisClientType;
-
-  /**
-   * Boolean showing if the connection to the Redis client has finished.
-   * @private
-   */
-  private connected: Promise<boolean>;
+  private readonly client: ReturnType<typeof createClient>;
 
   /**
    * Creates an instance of `RedisCache`.
    *
    * @param {Logger} logger - The logger instance.
    * @param {Registry} register - The metrics registry.
    */
-  public constructor(logger: Logger, register: Registry, client: RedisClientType) {
+  public constructor(logger: Logger, register: Registry, client: ReturnType<typeof createClient>) {
     this.logger = logger;
     this.register = register;
     this.client = client;
-    this.connected = this.client
-      .connect()
-      .then(() => true)
-      .catch((error) => {
-        this.logger.error(error, 'Redis connection could not be established!');
-        return false;
-      });
-    this.client.on('ready', async () => {
-      this.connected = Promise.resolve(true);
-      const connections = await this.getNumberOfConnections().catch((error) => {
-        this.logger.error(error);
-        return 0;
-      });
-      logger.info(
-        `Connected to Redis server (${ConfigService.get('REDIS_URL')}) successfully! Number of connections: ${connections}`,
-      );
-    });
-    this.client.on('end', () => {
-      this.connected = Promise.resolve(false);
-      logger.info('Disconnected from Redis server!');
-    });
+
     this.client.on('error', (error) => {
-      this.connected = Promise.resolve(false);
       const redisError = new RedisCacheError(error);
       if (redisError.isSocketClosed()) {
         logger.error(`Error occurred with Redis Connection when closing socket: ${redisError.message}`);
@@ -89,8 +62,8 @@ export class RedisCache implements IRedisCacheClient {
     });
   }
 
-  async getConnectedClient(): Promise<RedisClientType> {
-    return this.isConnected().then(() => this.client);
+  async getConnectedClient(): Promise<ReturnType<typeof createClient>> {
+    return this.client.isConnected().then(() => this.client);
   }
 
   /**

packages/relay/src/lib/relay.ts

@@ -131,21 +131,12 @@ export class Relay {
     // Initialize Redis client for cache (DB index defaults to 0)
     const redisUrl = ConfigService.get('REDIS_URL')!;
     const reconnectDelay = ConfigService.get('REDIS_RECONNECT_DELAY_MS');
-    const cacheRedisClient: RedisClientType = createClient({
-      url: redisUrl,
-      socket: {
-        reconnectStrategy: (retries: number) => retries * reconnectDelay,
-      },
-    });
+    const redisClient = this.createAndConnectRedisClient(redisUrl, reconnectDelay);
+
     const chainId = ConfigService.get('CHAIN_ID');
     const duration = constants.HBAR_RATE_LIMIT_DURATION;
     const reservedKeys = HbarSpendingPlanConfigService.getPreconfiguredSpendingPlanKeys(logger);
-    this.cacheService = new CacheService(
-      logger.child({ name: 'cache-service' }),
-      register,
-      reservedKeys,
-      cacheRedisClient,
-    );
+    this.cacheService = new CacheService(logger.child({ name: 'cache-service' }), register, reservedKeys, redisClient);
 
     const hbarSpendingPlanRepository = new HbarSpendingPlanRepository(
       this.cacheService,
@@ -355,4 +346,28 @@ export class Relay {
       this.logger.info(`Operator account '${operator}' has balance: ${balance}`);
     }
   }
+
+  private createAndConnectRedisClient(redisUrl: string, reconnectDelay: number): ReturnType<typeof createClient> {
+    const redisClient = createClient({
+      url: redisUrl,
+      socket: {
+        reconnectStrategy: (retries: number) => retries * reconnectDelay,
+      },
+    });
+    redisClient
+      .connect()
+      .then(() => true)
+      .catch((error) => {
+        this.logger.error(error, 'Redis connection could not be established!');
+        return false;
+      });
+    redisClient.on('ready', () => {
+      this.logger.info(`Redis client connected to ${redisUrl}`);
+    });
+    redisClient.on('error', (error) => {
+      this.logger.error(error, 'Redis connection could not be established!');
+    });
+
+    return redisClient;
+  }
 }

packages/relay/src/lib/services/cacheService/cacheService.ts

@@ -3,7 +3,7 @@
 import { ConfigService } from '@hashgraph/json-rpc-config-service/dist/services';
 import type { Logger } from 'pino';
 import { Counter, Registry } from 'prom-client';
-import type { RedisClientType } from 'redis';
+import { createClient } from 'redis';
 
 import { LocalLRUCache, RedisCache } from '../../clients';
 import { ICacheClient } from '../../clients/cache/ICacheClient';
@@ -83,7 +83,7 @@ export class CacheService {
     logger: Logger,
     register: Registry = new Registry(),
     reservedKeys: Set<string> = new Set(),
-    redisClient?: RedisClientType,
+    redisClient?: ReturnType<typeof createClient>,
   ) {
     this.logger = logger;
     this.register = register;