feat: enable typescript strict mode for null-checking

lib/indicator/redis-health.indicator.ts

@@ -1,5 +1,9 @@
 import { Injectable, Inject } from '@nestjs/common';
-import { HealthIndicator, HealthIndicatorResult, HealthCheckError } from '@nestjs/terminus';
+import {
+  HealthIndicator,
+  HealthIndicatorResult,
+  HealthCheckError,
+} from '@nestjs/terminus';
 import Redis from 'ioredis';
 
 import { REDIS_HEALTH_INDICATOR } from '../redis.constants';
@@ -15,7 +19,10 @@ export class RedisHealthIndicator extends HealthIndicator {
       await this.redis.ping();
       return this.getStatus(key, true);
     } catch (error) {
-      throw new HealthCheckError('Redis check failed', this.getStatus(key, false, { message: error.message }));
+      throw new HealthCheckError(
+        'Redis check failed',
+        this.getStatus(key, false, { message: error?.['message'] }),
+      );
     }
   }
 }

lib/redis.core-module.ts

@@ -1,14 +1,23 @@
 import { DynamicModule, Module, Global, Provider } from '@nestjs/common';
-import { RedisModuleAsyncOptions, RedisModuleOptions, RedisModuleOptionsFactory } from './redis.interfaces';
-import { createRedisConnection, getRedisOptionsToken, getRedisConnectionToken } from './redis.utils'
+import {
+  RedisModuleAsyncOptions,
+  RedisModuleOptions,
+  RedisModuleOptionsFactory,
+} from './redis.interfaces';
+import {
+  createRedisConnection,
+  getRedisOptionsToken,
+  getRedisConnectionToken,
+} from './redis.utils';
 
 @Global()
 @Module({})
 export class RedisCoreModule {
-
   /* forRoot */
-  static forRoot(options: RedisModuleOptions, connection?: string): DynamicModule {
-
+  static forRoot(
+    options: RedisModuleOptions,
+    connection?: string,
+  ): DynamicModule {
     const redisOptionsProvider: Provider = {
       provide: getRedisOptionsToken(connection),
       useValue: options,
@@ -21,76 +30,91 @@ export class RedisCoreModule {
 
     return {
       module: RedisCoreModule,
-      providers: [
-        redisOptionsProvider,
-        redisConnectionProvider,
-      ],
-      exports: [
-        redisOptionsProvider,
-        redisConnectionProvider,
-      ],
+      providers: [redisOptionsProvider, redisConnectionProvider],
+      exports: [redisOptionsProvider, redisConnectionProvider],
     };
   }
 
   /* forRootAsync */
-  public static forRootAsync(options: RedisModuleAsyncOptions, connection: string): DynamicModule {
-
+  public static forRootAsync(
+    options: RedisModuleAsyncOptions,
+    connection?: string,
+  ): DynamicModule {
     const redisConnectionProvider: Provider = {
       provide: getRedisConnectionToken(connection),
       useFactory(options: RedisModuleOptions) {
-        return createRedisConnection(options)
+        return createRedisConnection(options);
       },
       inject: [getRedisOptionsToken(connection)],
     };
 
     return {
       module: RedisCoreModule,
       imports: options.imports,
-      providers: [...this.createAsyncProviders(options, connection), redisConnectionProvider],
+      providers: [
+        ...this.createAsyncProviders(options, connection),
+        redisConnectionProvider,
+      ],
       exports: [redisConnectionProvider],
     };
   }
 
   /* createAsyncProviders */
-  public static createAsyncProviders(options: RedisModuleAsyncOptions, connection?: string): Provider[] {
-
-    if(!(options.useExisting || options.useFactory || options.useClass)) {
-      throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+  public static createAsyncProviders(
+    options: RedisModuleAsyncOptions,
+    connection?: string,
+  ): Provider[] {
+    if (
+      options.useExisting == null &&
+      options.useExisting == null &&
+      options.useExisting == null
+    ) {
+      throw new Error(
+        'Invalid configuration. Must provide useFactory, useClass or useExisting',
+      );
     }
 
-    if (options.useExisting || options.useFactory) {
-      return [
-        this.createAsyncOptionsProvider(options, connection)
-      ];
+    if (options.useExisting == null) {
+      return [this.createAsyncOptionsProvider(options, connection)];
     }
 
     return [
       this.createAsyncOptionsProvider(options, connection),
-      { provide: options.useClass, useClass: options.useClass },
+      { provide: options.useExisting, useClass: options.useExisting },
     ];
   }
 
   /* createAsyncOptionsProvider */
-  public static createAsyncOptionsProvider(options: RedisModuleAsyncOptions, connection?: string): Provider {
-
-    if(!(options.useExisting || options.useFactory || options.useClass)) {
-      throw new Error('Invalid configuration. Must provide useFactory, useClass or useExisting');
+  public static createAsyncOptionsProvider(
+    options: RedisModuleAsyncOptions,
+    connection?: string,
+  ): Provider {
+    if (
+      options.useExisting == null &&
+      options.useExisting == null &&
+      options.useExisting == null
+    ) {
+      throw new Error(
+        'Invalid configuration. Must provide useFactory, useClass or useExisting',
+      );
     }
 
-    if (options.useFactory) {
+    if (options.useFactory != null) {
       return {
         provide: getRedisOptionsToken(connection),
         useFactory: options.useFactory,
-        inject: options.inject || [],
+        inject: options.inject ?? [],
       };
     }
 
     return {
       provide: getRedisOptionsToken(connection),
-      async useFactory(optionsFactory: RedisModuleOptionsFactory): Promise<RedisModuleOptions> {
+      async useFactory(
+        optionsFactory: RedisModuleOptionsFactory,
+      ): Promise<RedisModuleOptions> {
         return await optionsFactory.createRedisModuleOptions();
       },
-      inject: [options.useClass || options.useExisting],
+      inject: [options.useClass ?? options.useExisting],
     };
   }
 }

tsconfig.json

@@ -13,17 +13,9 @@
     "sourceMap": false,
     "outDir": "./dist",
     "rootDir": "./lib",
-    "lib": ["es7"]
+    "lib": ["es7"],
+    "strict": true
   },
-  "include": [
-    "lib/**/*"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
+  "include": ["lib/**/*"],
+  "exclude": ["node_modules"]
 }
-
-
-
-
-