feat: add Redis cluster support and enhance Redis service functionality

Author: iamnivekx

eslint.config.mjs

@@ -27,7 +27,14 @@ export default tseslint.config(
       globals: globals.jest
     }
   },
-  eslintPluginPrettierRecommended,
+  {
+    ...eslintPluginPrettierRecommended,
+    rules: {
+      'prettier/prettier': 'off',
+      'arrow-parens': ['error', 'always'],
+      '@typescript-eslint/no-base-to-string': 'off'
+    }
+  },
   {
     linterOptions: {
       reportUnusedDisableDirectives: 'error'

examples/nest-redis-example/src/app.service.ts

@@ -16,7 +16,7 @@ export class AppService {
     const info = await redis.info();
     return {
       message: 'Redis connection successful',
-      serverInfo: info.split('\r\n').slice(0, 10), // 只返回前10行信息
+      serverInfo: info,
     };
   }
 

packages/node-redis/lib/index.ts

@@ -5,8 +5,10 @@ export { RedisModule } from './redis.module';
 export { RedisService } from './redis.service';
 
 // Types and Interfaces
-export type { RedisClientType } from 'redis';
-export type { RedisModuleOptions, RedisModuleAsyncOptions, RedisOptionsFactory, RedisOptions } from './interfaces';
+export type { RedisClientType, RedisClusterType, RedisClusterOptions } from 'redis';
+export type { RedisOptions } from './interfaces/redis-options.interface';
+export type { RedisModuleOptions, RedisModuleAsyncOptions } from './interfaces/redis-module-options.interface';
+export type { RedisOptionsFactory } from './interfaces/redis-factory.interface';
 
 // Constants
 export { REDIS_CLIENT } from './redis.constants';

packages/node-redis/lib/interfaces/redis-options.interface.ts

@@ -1,4 +1,4 @@
-import { RedisClientOptions, RedisModules, RedisFunctions, RedisScripts } from 'redis';
+import { RedisClientOptions, RedisModules, RedisFunctions, RedisScripts, RedisClusterOptions } from 'redis';
 
 /**
  * Interface defining Redis options.
@@ -15,4 +15,9 @@ export interface RedisOptions<
    * See [`redis`](https://www.iana.org/assignments/uri-schemes/prov/redis) and [`rediss`](https://www.iana.org/assignments/uri-schemes/prov/rediss) IANA registration for more details
    */
   url?: string;
+
+  /**
+   * Redis cluster configuration
+   */
+  cluster?: RedisClusterOptions;
 }

packages/node-redis/lib/redis.providers.ts

@@ -1,5 +1,5 @@
 import { Provider, Type } from '@nestjs/common';
-import { createClient, RedisClientType } from 'redis';
+import { createClient, createCluster, RedisClientType, RedisClusterType } from 'redis';
 import { REDIS_CLIENT } from './redis.constants';
 import { RedisOptions } from './interfaces';
 import { MODULE_OPTIONS_TOKEN } from './redis.module-definition';
@@ -8,7 +8,13 @@ import { RedisOptionsFactory } from './interfaces/redis-factory.interface';
 
 export const createRedisClient = (): Provider => ({
   provide: REDIS_CLIENT,
-  useFactory: async (options: RedisOptions): Promise<RedisClientType> => {
+  useFactory: async (options: RedisOptions): Promise<RedisClientType | RedisClusterType> => {
+    if (options.cluster) {
+      const cluster = createCluster(options.cluster);
+      await cluster.connect();
+      return cluster as unknown as RedisClusterType;
+    }
+
     const client = createClient(options) as RedisClientType;
     await client.connect();
     return client;

packages/node-redis/lib/redis.service.spec.ts

@@ -10,7 +10,14 @@ describe('RedisService', () => {
     module = await Test.createTestingModule({
       imports: [
         RedisModule.forRoot({
-          url: 'redis://localhost:6379'
+          cluster: {
+            rootNodes: [
+              {
+                url: 'redis://127.0.0.1:7380',
+                password: 'mycluster'
+              }
+            ]
+          }
         })
       ]
     }).compile();
@@ -36,9 +43,10 @@ describe('RedisService', () => {
     try {
       const result = await client.ping();
       expect(result).toBe('PONG');
-    } catch (error: unknown) {
-      // If Redis is not available, skip the test
-      console.log('Redis not available, skipping connection test');
+    } catch (error) {
+      console.log(`Redis not available, skipping connection test: ${String(error)}`);
+      // Skip test if Redis is not available
+      return;
     }
   });
 
@@ -62,8 +70,8 @@ describe('RedisService', () => {
       // Verify deletion
       const afterDelete = await client.get(testKey);
       expect(afterDelete).toBeNull();
-    } catch (error: unknown) {
-      console.log('Redis operations failed, skipping test:', (error as Error).message);
+    } catch (error) {
+      console.log(`Redis operations failed, skipping test: ${String(error)}`);
     }
   });
 
@@ -86,7 +94,7 @@ describe('RedisService', () => {
       // Cleanup
       await client.del(counterKey);
     } catch (error: unknown) {
-      console.log('Redis counter operations failed, skipping test:', (error as Error).message);
+      console.log(`Redis counter operations failed, skipping test: ${String(error)}`);
     }
   });
 
@@ -103,13 +111,13 @@ describe('RedisService', () => {
       expect(immediate).toBe('expiry-test');
 
       // Wait for expiry
-      await new Promise(resolve => setTimeout(resolve, 1100));
+      await new Promise((resolve) => setTimeout(resolve, 1100));
 
       // Should not exist after expiry
       const afterExpiry = await client.get(expiryKey);
       expect(afterExpiry).toBeNull();
     } catch (error: unknown) {
-      console.log('Redis expiry operations failed, skipping test:', (error as Error).message);
+      console.log(`Redis expiry operations failed, skipping test: ${String(error)}`);
     }
   });
 
@@ -134,7 +142,7 @@ describe('RedisService', () => {
       // Cleanup
       await client.del(listKey);
     } catch (error: unknown) {
-      console.log('Redis list operations failed, skipping test:', (error as Error).message);
+      console.log(`Redis list operations failed, skipping test: ${String(error)}`);
     }
   });
 
@@ -161,7 +169,7 @@ describe('RedisService', () => {
       // Cleanup
       await client.del(hashKey);
     } catch (error: unknown) {
-      console.log('Redis hash operations failed, skipping test:', (error as Error).message);
+      console.log(`Redis hash operations failed, skipping test: ${String(error)}`);
     }
   });
 
@@ -176,9 +184,10 @@ describe('RedisService', () => {
 
       // Cleanup
       await client.del('test:error:key');
-    } catch (error: unknown) {
-      // If Redis is not available, test should not fail
-      console.log('Redis connection test failed, but this is expected if Redis is not running');
+    } catch (error) {
+      console.log(`Redis connection test failed, but this is expected if Redis is not running: ${String(error)}`);
+      // Skip test if Redis is not available
+      return;
     }
   });
 

packages/node-redis/lib/redis.service.ts

@@ -1,29 +1,74 @@
 import { Injectable, Inject } from '@nestjs/common';
-import type { RedisModules, RedisFunctions, RedisScripts, RedisClientType } from 'redis';
+import type { RedisModules, RedisFunctions, RedisScripts, RedisClientType, RedisClusterType } from 'redis';
 import { REDIS_CLIENT } from './redis.constants';
 
 /**
- * The redis connection manager (single instance).
+ * The redis connection manager (single instance or cluster).
  */
 @Injectable()
 export class RedisService<
   M extends RedisModules = RedisModules,
   F extends RedisFunctions = RedisFunctions,
   S extends RedisScripts = RedisScripts
 > {
-  constructor(@Inject(REDIS_CLIENT) private readonly client: RedisClientType<M, F, S>) {}
+  constructor(@Inject(REDIS_CLIENT) private readonly client: RedisClientType<M, F, S> | RedisClusterType<M, F, S>) {}
 
   /**
    * Get the redis client instance.
    */
-  getClient(): RedisClientType<M, F, S> {
+  getClient(): RedisClientType<M, F, S> | RedisClusterType<M, F, S> {
     return this.client;
   }
 
+  /**
+   * Get the redis cluster client instance.
+   */
+  getCluster(): RedisClusterType<M, F, S> {
+    return this.client as unknown as RedisClusterType<M, F, S>;
+  }
+
+  /**
+   * Check if the client is in cluster mode.
+   */
+  isClusterMode(): boolean {
+    // check if the client is a cluster client
+    if ('masters' in this.client) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get client type information.
+   */
+  getClientType(): 'single' | 'cluster' {
+    return this.isClusterMode() ? 'cluster' : 'single';
+  }
+
+  /**
+   * Get cluster information if in cluster mode.
+   */
+  getClusterInfo() {
+    if (!this.isClusterMode()) {
+      return 'single';
+    }
+    const cluster = this.getCluster();
+    try {
+      const masters = cluster.masters;
+      return {
+        type: 'cluster',
+        masters: masters.length,
+        nodes: masters.map((node) => node.toString())
+      };
+    } catch (error) {
+      throw new Error(`Failed to get cluster info: ${String(error)}`);
+    }
+  }
+
   /**
    * Quit the redis client instance.
    */
   async onApplicationShutdown(): Promise<void> {
-    await this.client.quit();
+    await this.client.close();
   }
 }