fix(router,admin,hermes): new redis options compatibility

libraries/grpc-sdk/src/index.ts

@@ -1,5 +1,7 @@
 import {
   Admin,
+  Authentication,
+  Authorization,
   Chat,
   Config,
   Core,
@@ -10,8 +12,6 @@ import {
   Router,
   SMS,
   Storage,
-  Authorization,
-  Authentication,
 } from './modules';
 import Crypto from 'crypto';
 import { EventBus } from './utilities/EventBus';
@@ -46,6 +46,7 @@ export default class ConduitGrpcSdk {
   private readonly _core?: Core;
   private readonly _config?: Config;
   private readonly _admin?: Admin;
+  private _redisManager: RedisManager | null = null;
   private _redisDetails?:
     | RedisOptions
     | { nodes: { host: string; port: number }[]; options: ClusterOptions };
@@ -398,18 +399,17 @@ export default class ConduitGrpcSdk {
     }
     return promise
       .then(() => {
-        let redisManager: RedisManager;
         if (this._redisDetails!.hasOwnProperty('nodes')) {
-          redisManager = new RedisManager(this._redisDetails);
+          this._redisManager = new RedisManager(this._redisDetails);
         } else {
           const redisHost = this.urlRemap ?? (this._redisDetails as RedisOptions).host;
-          redisManager = new RedisManager({
+          this._redisManager = new RedisManager({
             host: redisHost,
             ...this._redisDetails,
           });
         }
-        this._eventBus = new EventBus(redisManager);
-        this._stateManager = new StateManager(redisManager, this.name);
+        this._eventBus = new EventBus(this._redisManager);
+        this._stateManager = new StateManager(this._redisManager, this.name);
         return this._eventBus;
       })
       .catch((err: Error) => {
@@ -418,6 +418,14 @@ export default class ConduitGrpcSdk {
       });
   }
 
+  get redisManager(): RedisManager {
+    if (this._redisManager) {
+      return this._redisManager;
+    } else {
+      throw new Error('Redis not available');
+    }
+  }
+
   /**
    * Gets all the registered modules from the config and creates clients for them.
    * This will only work on known modules, since the primary usage for the sdk is internal

libraries/hermes/src/Socket/Socket.ts

@@ -2,7 +2,7 @@ import { Application, NextFunction, Request, Response } from 'express';
 import { createServer, Server as httpServer } from 'http';
 import { Server as IOServer, ServerOptions, Socket } from 'socket.io';
 import { createAdapter } from '@socket.io/redis-adapter';
-import IORedis, { Redis } from 'ioredis';
+import { Cluster, Redis } from 'ioredis';
 import { ConduitRouter } from '../Router';
 import { isNil } from 'lodash';
 import {
@@ -20,8 +20,8 @@ export class SocketController extends ConduitRouter {
   private io: IOServer;
   private readonly options: Partial<ServerOptions>;
   private _registeredNamespaces: Map<string, ConduitSocket>;
-  private readonly pubClient: Redis;
-  private readonly subClient: Redis;
+  private readonly pubClient: Redis | Cluster;
+  private readonly subClient: Redis | Cluster;
   private globalMiddlewares: ((
     req: Request,
     res: Response,
@@ -32,7 +32,6 @@ export class SocketController extends ConduitRouter {
     private readonly port: number,
     grpcSdk: ConduitGrpcSdk,
     expressApp: Application,
-    redisDetails: { host: string; port: number },
     private readonly metrics?: {
       registeredRoutes?: {
         name: string;
@@ -49,7 +48,7 @@ export class SocketController extends ConduitRouter {
       },
     };
     this.io = new IOServer(this.httpServer, this.options);
-    this.pubClient = new IORedis(redisDetails.port, redisDetails.host);
+    this.pubClient = grpcSdk.redisManager.getClient();
     this.subClient = this.pubClient.duplicate();
     this.io.adapter(createAdapter(this.pubClient, this.subClient));
     this.httpServer.listen(this.port);

libraries/hermes/src/index.ts

@@ -99,16 +99,12 @@ export class ConduitRoutingController {
     this._graphQLRouter = new GraphQLController(this.grpcSdk, this.metrics);
   }
 
-  initSockets(redisHost: string, redisPort: number) {
+  initSockets() {
     if (this._socketRouter) return;
     this._socketRouter = new SocketController(
       this.socketPort,
       this.grpcSdk,
       this.expressApp,
-      {
-        host: redisHost,
-        port: redisPort,
-      },
       this.metrics,
     );
   }

modules/router/src/Router.ts

@@ -133,10 +133,7 @@ export default class ConduitDefaultRouter extends ManagedModule<Config> {
       this._internalRouter.stopRest();
     }
     if (config.transports.sockets) {
-      this._internalRouter.initSockets(
-        this.grpcSdk.redisDetails.host,
-        this.grpcSdk.redisDetails.port,
-      );
+      this._internalRouter.initSockets();
       atLeastOne = true;
     } else {
       this._internalRouter.stopSockets();

modules/router/src/security/handlers/rate-limiter/index.ts

@@ -1,13 +1,13 @@
-import IORedis, { Redis } from 'ioredis';
+import { Cluster, Redis } from 'ioredis';
 
 import { RateLimiterRedis } from 'rate-limiter-flexible';
-import { ConduitError } from '@conduitplatform/grpc-sdk';
+import ConduitGrpcSdk, { ConduitError } from '@conduitplatform/grpc-sdk';
 
 export class RateLimiter {
   private _limiter: any;
 
-  constructor(redisHost: string, redisPort: number) {
-    const redisClient: Redis = new IORedis(redisPort, redisHost, {
+  constructor(private readonly grpcSdk: ConduitGrpcSdk) {
+    const redisClient: Redis | Cluster = this.grpcSdk.redisManager.getClient({
       enableOfflineQueue: false,
     });
     this._limiter = new RateLimiterRedis({

modules/router/src/security/index.ts

@@ -16,8 +16,7 @@ export default class SecurityModule {
 
     this.router.registerGlobalMiddleware(
       'rateLimiter',
-      new RateLimiter(this.grpcSdk.redisDetails.host, this.grpcSdk.redisDetails.port)
-        .limiter,
+      new RateLimiter(this.grpcSdk).limiter,
       true,
     );
     this.router.registerGlobalMiddleware('helmetMiddleware', helmet());

packages/admin/src/index.ts

@@ -195,10 +195,7 @@ export default class AdminModule extends IConduitAdmin {
       this._router.stopGraphQL();
     }
     if (ConfigController.getInstance().config.transports.sockets) {
-      this._router.initSockets(
-        this.grpcSdk.redisDetails.host,
-        this.grpcSdk.redisDetails.port,
-      );
+      this._router.initSockets();
     } else {
       this._router.stopSockets();
     }