fix(client): ensure Redis is ready in all lifecycle hooks

Author: CSenshi

packages/client/src/lib/module.int.spec.ts

@@ -1,5 +1,14 @@
+import {
+  BeforeApplicationShutdown,
+  Injectable,
+  OnApplicationBootstrap,
+  OnApplicationShutdown,
+  OnModuleDestroy,
+  OnModuleInit,
+} from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { Test, TestingModule } from '@nestjs/testing';
+import { InjectRedis } from './decorators';
 import { RedisModule } from './module';
 import { RedisToken } from './tokens';
 import { Redis, RedisModuleOptions } from './types';
@@ -452,3 +461,122 @@ describe('Multi-connection Integration', () => {
     expect(ping2).toBe('PONG');
   });
 });
+
+describe('RedisModule Service Lifecycle Integration', () => {
+  // Test service that implements all lifecycle hooks
+  @Injectable()
+  class TestLifecycleService
+    implements
+      OnModuleInit,
+      OnApplicationBootstrap,
+      OnModuleDestroy,
+      OnApplicationShutdown,
+      BeforeApplicationShutdown
+  {
+    constructor(
+      @InjectRedis() readonly redis: Redis,
+      private readonly prefix = 'root',
+    ) {}
+
+    async beforeApplicationShutdown(signal?: string) {
+      await this.redis.set(
+        `${this.prefix}:lifecycle:beforeShutdown`,
+        `application-before-shutdown-${signal || `unknown`}`,
+      );
+    }
+
+    async onModuleInit(): Promise<void> {
+      await this.redis.set(
+        `${this.prefix}:lifecycle:init`,
+        `module-initialized`,
+      );
+    }
+
+    async onApplicationBootstrap(): Promise<void> {
+      await this.redis.set(
+        `${this.prefix}:lifecycle:bootstrap`,
+        `application-bootstrapped`,
+      );
+    }
+
+    async onModuleDestroy(): Promise<void> {
+      await this.redis.set(
+        `${this.prefix}:lifecycle:destroy`,
+        `module-destroyed`,
+      );
+    }
+
+    async onApplicationShutdown(signal?: string): Promise<void> {
+      await this.redis.set(
+        `${this.prefix}:lifecycle:shutdown`,
+        `application-shutdown-${signal || 'unknown'}`,
+      );
+    }
+  }
+
+  let module: TestingModule;
+  let asyncModule: TestingModule;
+
+  beforeEach(async () => {
+    // Create the testing module with the lifecycle service
+    module = await Test.createTestingModule({
+      imports: [
+        RedisModule.forRoot({ options: { url: process.env.REDIS_URL } }),
+      ],
+      providers: [
+        {
+          provide: TestLifecycleService,
+          inject: [RedisToken()],
+          useFactory: (redis: Redis) => new TestLifecycleService(redis, 'sync'),
+        },
+      ],
+    }).compile();
+
+    asyncModule = await Test.createTestingModule({
+      imports: [
+        RedisModule.forRootAsync({
+          useFactory: () => ({ options: { url: process.env.REDIS_URL } }),
+          inject: [],
+        }),
+      ],
+      providers: [
+        {
+          provide: TestLifecycleService,
+          inject: [RedisToken()],
+          useFactory: (redis: Redis) =>
+            new TestLifecycleService(redis, 'async'),
+        },
+      ],
+    }).compile();
+  });
+
+  describe('Service Lifecycle with Redis', () => {
+    it('should have Redis available in onModuleInit', async () => {
+      await module.init();
+      await asyncModule.init();
+
+      await module.close();
+      await asyncModule.close();
+    });
+
+    it('should disconnect Redis after onApplicationShutdown', async () => {
+      const service = module.get(TestLifecycleService);
+      const asyncService = asyncModule.get(TestLifecycleService);
+
+      await module.init();
+      await asyncModule.init();
+
+      // Verify that the redis client is connected
+      expect(service.redis.isReady).toBe(true);
+      expect(asyncService.redis.isReady).toBe(true);
+
+      // Trigger application shutdown
+      await module.close();
+      await asyncModule.close();
+
+      // Verify that the redis client is disconnected
+      expect(service.redis.isReady).toBe(false);
+      expect(asyncService.redis.isReady).toBe(false);
+    });
+  });
+});

packages/client/src/lib/module.ts

@@ -2,7 +2,6 @@ import {
   DynamicModule,
   FactoryProvider,
   Module,
-  OnApplicationBootstrap,
   OnApplicationShutdown,
 } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
@@ -18,7 +17,7 @@ import { Redis, RedisModuleForRootOptions, RedisModuleOptions } from './types';
 @Module({})
 export class RedisModule
   extends ConfigurableModuleClass
-  implements OnApplicationBootstrap, OnApplicationShutdown
+  implements OnApplicationShutdown
 {
   protected connectionToken?: string;
 
@@ -66,36 +65,32 @@ export class RedisModule
   ): FactoryProvider {
     return {
       provide: RedisToken(connectionName),
-      useFactory: (config: RedisModuleOptions): Redis => {
-        switch (config?.type) {
-          case 'client':
-          case undefined:
-            return createClient(config?.options);
-          case 'cluster':
-            return createCluster(config.options);
-          case 'sentinel':
-            return createSentinel(config.options);
-          default:
-            throw new Error(
-              // @ts-expect-error check for config type
-              `Unsupported Redis type: ${config?.type}. Supported types are 'client', 'cluster' and 'sentinel'`,
-            );
+      useFactory: async (config: RedisModuleOptions): Promise<Redis> => {
+        function getClient(): Redis {
+          switch (config?.type) {
+            case 'client':
+            case undefined:
+              return createClient(config?.options);
+            case 'cluster':
+              return createCluster(config.options);
+            case 'sentinel':
+              return createSentinel(config.options);
+            default:
+              throw new Error(
+                // @ts-expect-error check for config type
+                `Unsupported Redis type: ${config?.type}. Supported types are 'client', 'cluster' and 'sentinel'`,
+              );
+          }
         }
+
+        const client = getClient();
+        await client.connect();
+        return client;
       },
       inject: [MODULE_OPTIONS_TOKEN],
     };
   }
 
-  async onApplicationBootstrap() {
-    if (!this.connectionToken) {
-      throw new Error(
-        'Connection token is not defined. Ensure to call forRoot or forRootAsync.',
-      );
-    }
-
-    await this.moduleRef.get<Redis>(this.connectionToken).connect();
-  }
-
   async onApplicationShutdown() {
     if (!this.connectionToken) {
       throw new Error(