@nest-omni/core 3.1.1-12 → 3.1.1-14

package/redis-lock/redis-lock.module.js

@@ -0,0 +1,117 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var RedisLockModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisLockModule = exports.REDIS_LOCK_SERVICE = void 0;
+const common_1 = require("@nestjs/common");
+const redis_lock_service_1 = require("./redis-lock.service");
+const redis_lock_decorator_1 = require("./redis-lock.decorator");
+exports.REDIS_LOCK_SERVICE = Symbol('REDIS_LOCK_SERVICE');
+let RedisLockModule = RedisLockModule_1 = class RedisLockModule {
+    constructor() { }
+    static forRoot(options) {
+        const { isGlobal = true, redisClient, defaultTtl, defaultKeyPrefix, defaultRetryCount, defaultRetryDelay, } = options;
+        return {
+            module: RedisLockModule_1,
+            global: isGlobal,
+            providers: [
+                {
+                    provide: 'REDIS_LOCK_CLIENT',
+                    useValue: redisClient,
+                },
+                {
+                    provide: exports.REDIS_LOCK_SERVICE,
+                    useFactory: () => {
+                        const service = new redis_lock_service_1.RedisLockService();
+                        service.setRedisClient(redisClient);
+                        if (defaultTtl) {
+                            service.setDefaultTtl(defaultTtl);
+                        }
+                        if (defaultKeyPrefix) {
+                            service.setDefaultKeyPrefix(defaultKeyPrefix);
+                        }
+                        if (defaultRetryCount !== undefined) {
+                            service.setDefaultRetryCount(defaultRetryCount);
+                        }
+                        if (defaultRetryDelay !== undefined) {
+                            service.setDefaultRetryDelay(defaultRetryDelay);
+                        }
+                        return service;
+                    },
+                },
+                {
+                    provide: redis_lock_service_1.RedisLockService,
+                    useExisting: exports.REDIS_LOCK_SERVICE,
+                },
+            ],
+            exports: [exports.REDIS_LOCK_SERVICE, redis_lock_service_1.RedisLockService],
+        };
+    }
+    static forRootAsync(options) {
+        var _a;
+        return {
+            module: RedisLockModule_1,
+            global: (_a = options.isGlobal) !== null && _a !== void 0 ? _a : true,
+            imports: options.imports || [],
+            providers: [
+                {
+                    provide: 'REDIS_LOCK_MODULE_OPTIONS',
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                },
+                {
+                    provide: 'REDIS_LOCK_CLIENT',
+                    useFactory: (moduleOptions) => moduleOptions.redisClient,
+                    inject: ['REDIS_LOCK_MODULE_OPTIONS'],
+                },
+                {
+                    provide: exports.REDIS_LOCK_SERVICE,
+                    useFactory: (moduleOptions) => {
+                        const service = new redis_lock_service_1.RedisLockService();
+                        service.setRedisClient(moduleOptions.redisClient);
+                        if (moduleOptions.defaultTtl) {
+                            service.setDefaultTtl(moduleOptions.defaultTtl);
+                        }
+                        if (moduleOptions.defaultKeyPrefix) {
+                            service.setDefaultKeyPrefix(moduleOptions.defaultKeyPrefix);
+                        }
+                        if (moduleOptions.defaultRetryCount !== undefined) {
+                            service.setDefaultRetryCount(moduleOptions.defaultRetryCount);
+                        }
+                        if (moduleOptions.defaultRetryDelay !== undefined) {
+                            service.setDefaultRetryDelay(moduleOptions.defaultRetryDelay);
+                        }
+                        return service;
+                    },
+                    inject: ['REDIS_LOCK_MODULE_OPTIONS'],
+                },
+                {
+                    provide: redis_lock_service_1.RedisLockService,
+                    useExisting: exports.REDIS_LOCK_SERVICE,
+                },
+            ],
+            exports: [exports.REDIS_LOCK_SERVICE, redis_lock_service_1.RedisLockService],
+        };
+    }
+    onModuleInit() {
+        const globalInstance = redis_lock_service_1.RedisLockService.getGlobalInstance();
+        if (globalInstance) {
+            this.redisLockService = globalInstance;
+            (0, redis_lock_decorator_1.setLockService)(this.redisLockService);
+        }
+    }
+};
+exports.RedisLockModule = RedisLockModule;
+exports.RedisLockModule = RedisLockModule = RedisLockModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({}),
+    __metadata("design:paramtypes", [])
+], RedisLockModule);

package/{setup → redis-lock}/redis-lock.service.d.ts

@@ -1,4 +1,5 @@
-import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import { OnModuleInit } from '@nestjs/common';
+import type Redis from 'ioredis';
 export interface LockOptions {
     ttl?: number;
     retryCount?: number;
@@ -13,33 +14,22 @@ export interface LockResult {
     error?: string;
     autoExtendTimer?: NodeJS.Timeout;
 }
-export interface RedisOptions {
-    host?: string;
-    port?: number;
-    password?: string;
-    db?: number;
-    retryDelay?: number;
-    maxRetries?: number;
-    reconnectOnError?: (err: Error) => boolean;
-}
-export declare class RedisLockService implements OnModuleInit, OnModuleDestroy {
+export declare class RedisLockService implements OnModuleInit {
     private static globalInstance;
-    private static globalConfig;
     private readonly logger;
     private redis;
-    private redisOptions;
-    private isConnected;
-    private isConnecting;
-    private connectionPromise;
     private readonly defaultOptions;
-    private readonly defaultRedisOptions;
-    constructor(redisOptions?: RedisOptions);
-    static initializeGlobalInstance(config?: RedisOptions): RedisLockService;
+    constructor();
     static getGlobalInstance(): RedisLockService | null;
     static getOrCreateGlobalInstance(): RedisLockService;
     static setGlobalInstance(instance: RedisLockService): void;
     onModuleInit(): Promise<void>;
     onModuleDestroy(): Promise<void>;
+    setRedisClient(redis: Redis): void;
+    setDefaultTtl(ttl: number): void;
+    setDefaultKeyPrefix(prefix: string): void;
+    setDefaultRetryCount(count: number): void;
+    setDefaultRetryDelay(delay: number): void;
     acquireLock(key: string, options?: LockOptions): Promise<LockResult>;
     releaseLock(key: string, lockValue: string, keyPrefix?: string): Promise<boolean>;
     extendLock(key: string, lockValue: string, ttl: number, keyPrefix?: string): Promise<boolean>;
@@ -50,9 +40,7 @@ export declare class RedisLockService implements OnModuleInit, OnModuleDestroy {
         ttl: number | null;
     }>;
     forceRelease(key: string, keyPrefix?: string): Promise<boolean>;
-    getRedisOptions(): RedisOptions;
     private getRedis;
-    private createRedisConnection;
     private generateLockValue;
     private buildLockKey;
     private sleep;

package/{setup → redis-lock}/redis-lock.service.js

@@ -21,14 +21,10 @@ var RedisLockService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisLockService = void 0;
 const common_1 = require("@nestjs/common");
-const ioredis_1 = require("ioredis");
 let RedisLockService = RedisLockService_1 = class RedisLockService {
-    constructor(redisOptions) {
+    constructor() {
         this.logger = new common_1.Logger(RedisLockService_1.name);
         this.redis = null;
-        this.isConnected = false;
-        this.isConnecting = false;
-        this.connectionPromise = null;
         this.defaultOptions = {
             ttl: 300000,
             retryCount: 0,
@@ -37,46 +33,16 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
             throwOnFailure: false,
             autoExtend: 0,
         };
-        this.defaultRedisOptions = {
-            host: process.env.REDIS_HOST || 'localhost',
-            port: parseInt(process.env.REDIS_PORT || '6379', 10),
-            password: process.env.REDIS_PASSWORD,
-            db: parseInt(process.env.REDIS_DB || '0', 10),
-            retryDelay: 2000,
-            maxRetries: 10,
-            reconnectOnError: (err) => {
-                this.logger.warn('Redis reconnection error:', err.message);
-                return true;
-            },
-        };
-        this.redisOptions = redisOptions ||
-            RedisLockService_1.globalConfig || Object.assign({}, this.defaultRedisOptions);
         if (!RedisLockService_1.globalInstance) {
             RedisLockService_1.globalInstance = this;
         }
     }
-    static initializeGlobalInstance(config) {
-        if (!RedisLockService_1.globalInstance) {
-            new RedisLockService_1(config || RedisLockService_1.globalConfig);
-        }
-        return RedisLockService_1.globalInstance;
-    }
     static getGlobalInstance() {
         return RedisLockService_1.globalInstance;
     }
     static getOrCreateGlobalInstance() {
         if (!RedisLockService_1.globalInstance) {
-            if (!RedisLockService_1.globalConfig) {
-                RedisLockService_1.globalConfig = {
-                    host: process.env.REDIS_HOST || 'localhost',
-                    port: parseInt(process.env.REDIS_PORT || '6379', 10),
-                    password: process.env.REDIS_PASSWORD,
-                    db: parseInt(process.env.REDIS_DB || '0', 10),
-                    retryDelay: 2000,
-                    maxRetries: 10,
-                };
-            }
-            return RedisLockService_1.initializeGlobalInstance();
+            RedisLockService_1.globalInstance = new RedisLockService_1();
         }
         return RedisLockService_1.globalInstance;
     }
@@ -85,18 +51,35 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
     }
     onModuleInit() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.log('RedisLockService initialized, will connect on first use');
+            if (!this.redis) {
+                this.logger.warn('RedisLockService initialized but no Redis client provided. Redis Lock functionality will not work.');
+            }
+            else {
+                this.logger.log('RedisLockService initialized with Redis client');
+            }
         });
     }
     onModuleDestroy() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.redis) {
-                yield this.redis.quit();
-                this.isConnected = false;
-                this.logger.log('Redis connection closed');
-            }
+            this.logger.log('RedisLockService destroyed');
         });
     }
+    setRedisClient(redis) {
+        this.redis = redis;
+        this.logger.log('Redis client set for RedisLockService');
+    }
+    setDefaultTtl(ttl) {
+        this.defaultOptions.ttl = ttl;
+    }
+    setDefaultKeyPrefix(prefix) {
+        this.defaultOptions.keyPrefix = prefix;
+    }
+    setDefaultRetryCount(count) {
+        this.defaultOptions.retryCount = count;
+    }
+    setDefaultRetryDelay(delay) {
+        this.defaultOptions.retryDelay = delay;
+    }
     acquireLock(key_1) {
         return __awaiter(this, arguments, void 0, function* (key, options = {}) {
             const redis = yield this.getRedis();
@@ -279,68 +262,12 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
             }
         });
     }
-    getRedisOptions() {
-        return Object.assign({}, this.redisOptions);
-    }
     getRedis() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.redis && this.isConnected) {
-                return this.redis;
+            if (!this.redis) {
+                throw new Error('RedisLockService requires a Redis client to be set. Please provide a Redis client through the module configuration.');
             }
-            if (this.isConnecting && this.connectionPromise) {
-                return this.connectionPromise;
-            }
-            this.isConnecting = true;
-            this.connectionPromise = this.createRedisConnection()
-                .then((redis) => {
-                this.isConnecting = false;
-                this.isConnected = true;
-                return redis;
-            })
-                .catch((error) => {
-                this.isConnecting = false;
-                this.connectionPromise = null;
-                throw error;
-            });
-            return this.connectionPromise;
-        });
-    }
-    createRedisConnection() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                const redis = new ioredis_1.default({
-                    host: this.redisOptions.host,
-                    port: this.redisOptions.port,
-                    password: this.redisOptions.password,
-                    db: this.redisOptions.db,
-                    retryStrategy: (times) => {
-                        this.logger.warn(`Redis connection retry attempt ${times}`);
-                        if (times > (this.redisOptions.maxRetries || 10)) {
-                            this.logger.error('Max retries reached, giving up on Redis connection');
-                            this.isConnected = false;
-                            return undefined;
-                        }
-                        const delay = Math.min(times * (this.redisOptions.retryDelay || 2000), 30000);
-                        this.logger.log(`Retrying Redis connection in ${delay}ms`);
-                        return delay;
-                    },
-                    reconnectOnError: this.redisOptions.reconnectOnError,
-                });
-                const onConnect = () => {
-                    this.logger.log(`Connected to Redis at ${this.redisOptions.host}:${this.redisOptions.port}`);
-                    this.isConnected = true;
-                    resolve(redis);
-                };
-                const onError = (err) => {
-                    this.logger.error('Redis connection error:', err.message);
-                    if (!this.isConnected) {
-                        reject(err);
-                    }
-                };
-                redis.once('connect', onConnect);
-                redis.once('error', onError);
-                this.redis = redis;
-            });
+            return this.redis;
         });
     }
     generateLockValue() {
@@ -355,8 +282,7 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
 };
 exports.RedisLockService = RedisLockService;
 RedisLockService.globalInstance = null;
-RedisLockService.globalConfig = null;
 exports.RedisLockService = RedisLockService = RedisLockService_1 = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [Object])
+    __metadata("design:paramtypes", [])
 ], RedisLockService);

package/setup/index.d.ts

@@ -2,5 +2,4 @@ export * from './bootstrap.setup';
 export * from './mode.setup';
 export * from './worker.decorator';
 export * from './schedule.decorator';
-export * from './redis-lock.service';
-export * from './redis-lock.decorator';
+export * from '../redis-lock';

package/setup/index.js

@@ -18,5 +18,4 @@ __exportStar(require("./bootstrap.setup"), exports);
 __exportStar(require("./mode.setup"), exports);
 __exportStar(require("./worker.decorator"), exports);
 __exportStar(require("./schedule.decorator"), exports);
-__exportStar(require("./redis-lock.service"), exports);
-__exportStar(require("./redis-lock.decorator"), exports);
+__exportStar(require("../redis-lock"), exports);

package/setup/schedule.decorator.js

@@ -21,7 +21,7 @@ exports.WorkerCronAdvanced = WorkerCronAdvanced;
 const common_1 = require("@nestjs/common");
 const schedule_1 = require("@nestjs/schedule");
 const mode_setup_1 = require("./mode.setup");
-const redis_lock_service_1 = require("./redis-lock.service");
+const redis_lock_service_1 = require("../redis-lock/redis-lock.service");
 function generateLockKey(className, methodName) {
     return `${className}.${methodName}`;
 }

package/shared/serviceRegistryModule.js

@@ -5,6 +5,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceRegistryModule = void 0;
@@ -17,13 +26,15 @@ const common_1 = require("@nestjs/common");
 const typeorm_1 = require("@nestjs/typeorm");
 const schedule_1 = require("@nestjs/schedule");
 const setup_1 = require("@sentry/nestjs/setup");
-const cache_manager_1 = require("@nestjs/cache-manager");
+const cache_1 = require("../cache");
 const transactional_1 = require("@nestjs-cls/transactional");
 const transactional_adapter_typeorm_1 = require("@nestjs-cls/transactional-adapter-typeorm");
 const nestjs_i18n_1 = require("nestjs-i18n");
 const health_checker_1 = require("../health-checker");
+const nestjs_redis_1 = require("@songkeys/nestjs-redis");
 const services_1 = require("./services");
 const nestjs_cls_1 = require("nestjs-cls");
+const redis_lock_1 = require("../redis-lock");
 const typeorm_2 = require("typeorm");
 const providers = [
     services_1.ApiConfigService,
@@ -73,6 +84,14 @@ const modules = [
         resolvers: [new nestjs_i18n_1.QueryResolver(['lang']), nestjs_i18n_1.AcceptLanguageResolver],
     }),
     health_checker_1.HealthCheckerModule,
+    nestjs_redis_1.RedisModule.forRoot({
+        config: {
+            host: process.env.REDIS_HOST || 'localhost',
+            port: parseInt(process.env.REDIS_PORT) || 6379,
+            password: process.env.REDIS_PASSWORD,
+            db: parseInt(process.env.REDIS_DB) || 0,
+        },
+    }),
 ];
 if (services_1.ApiConfigService.toBoolean(process.env.DB_ENABLED, true)) {
     modules.push(typeorm_1.TypeOrmModule.forRootAsync({
@@ -87,10 +106,50 @@ if (services_1.ApiConfigService.toBoolean(process.env.BULL_ENABLED)) {
     }));
 }
 if (services_1.ApiConfigService.toBoolean(process.env.CACHE_ENABLED)) {
-    modules.push(cache_manager_1.CacheModule.registerAsync({
-        inject: [services_1.ApiConfigService],
+    modules.push(cache_1.CacheModule.forRootAsync({
+        imports: [nestjs_redis_1.RedisModule],
+        inject: [services_1.ApiConfigService, nestjs_redis_1.RedisService, typeorm_2.DataSource],
+        isGlobal: true,
+        useFactory: (config, redisService, dataSource) => __awaiter(void 0, void 0, void 0, function* () {
+            let redisClient = null;
+            try {
+                redisClient = redisService.getClient();
+            }
+            catch (error) {
+                console.error('Redis client not available for cache, using memory cache only:', error);
+            }
+            return {
+                isGlobal: true,
+                redisClient,
+                dataSource,
+                memoryTtl: config.getNumber('CACHE_TTL'),
+                memoryNamespace: config.getString('CACHE_NAMESPACE', 'default'),
+            };
+        }),
+    }));
+}
+if (services_1.ApiConfigService.toBoolean(process.env.SCHEDULE_ENABLED) &&
+    services_1.ApiConfigService.toBoolean(process.env.REDIS_LOCK_ENABLED, true)) {
+    modules.push(redis_lock_1.RedisLockModule.forRootAsync({
+        imports: [nestjs_redis_1.RedisModule],
+        inject: [services_1.ApiConfigService, nestjs_redis_1.RedisService],
         isGlobal: true,
-        useFactory: (config) => config.cacheConfig(),
+        useFactory: (config, redisService) => __awaiter(void 0, void 0, void 0, function* () {
+            let redisClient = null;
+            try {
+                redisClient = redisService.getClient();
+            }
+            catch (error) {
+                console.error('Redis client not available for RedisLock, Redis Lock functionality will not work:', error);
+            }
+            return {
+                redisClient,
+                defaultTtl: config.getNumber('REDIS_LOCK_TTL', 300000),
+                defaultKeyPrefix: config.getString('REDIS_LOCK_KEY_PREFIX', 'lock'),
+                defaultRetryCount: config.getNumber('REDIS_LOCK_RETRY_COUNT', 3),
+                defaultRetryDelay: config.getNumber('REDIS_LOCK_RETRY_DELAY', 200),
+            };
+        }),
     }));
 }
 if (services_1.ApiConfigService.toBoolean(process.env.SCHEDULE_ENABLED)) {

package/shared/services/api-config.service.d.ts

@@ -5,7 +5,6 @@ import { Params } from 'nestjs-pino';
 import { BullRootModuleOptions } from '@nestjs/bull/dist/interfaces/bull-module-options.interface';
 import { AxiosProxyConfig } from 'axios';
 import { CorsOptions } from '@nestjs/common/interfaces/external/cors-options.interface';
-import Keyv from 'keyv';
 export declare class ApiConfigService {
     private configService;
     static rootPath: string;
@@ -51,9 +50,5 @@ export declare class ApiConfigService {
     getNumber(key: string, defaultValue?: number): number;
     getBoolean(key: string, defaultValue?: boolean): boolean;
     getString(key: string, defaultValue?: string): string;
-    cacheConfig(): Promise<{
-        isGlobal: boolean;
-        store: Keyv<any>;
-    }>;
     private get;
 }

package/shared/services/api-config.service.js

@@ -8,15 +8,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var ApiConfigService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiConfigService = void 0;
@@ -26,8 +17,6 @@ const lodash_1 = require("lodash");
 const connect_redis_1 = require("connect-redis");
 const ioredis_1 = require("ioredis");
 const common_2 = require("../../common");
-const keyv_1 = require("keyv");
-const redis_1 = require("@keyv/redis");
 let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
     constructor(configService) {
         this.configService = configService;
@@ -70,6 +59,7 @@ let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
             synchronize: this.isDev,
             migrationsRun: true,
             logging: this.getBoolean('DB_LOG_ENABLED'),
+            logger: this.isDev ? 'formatted-console' : 'simple-console',
             maxQueryExecutionTime: 3000,
             namingStrategy: new common_2.SnakeNamingStrategy(),
             timezone: this.getString('TZ'),
@@ -95,7 +85,7 @@ let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
     }
     get corsEnabled() {
         try {
-            return this.getBoolean('CORS_ENABLED');
+            return this.getBoolean('CORS_ENABLED', false);
         }
         catch (error) {
             console.log(error);
@@ -279,24 +269,10 @@ let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
         const value = this.get(key, defaultValue);
         return value.replace(/\\n/g, '\n');
     }
-    cacheConfig() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const uri = `redis://${this.getString('REDIS_USERNAME') ? this.getString('REDIS_USERNAME') + ':' : ''}${this.getString('REDIS_PASSWORD') ? this.getString('REDIS_PASSWORD') + '@' : ''}${this.getString('REDIS_HOST')}:${this.getNumber('REDIS_PORT')}/${this.getNumber('REDIS_DB')}`;
-            const keyvRedis = new redis_1.default(uri);
-            const store = new keyv_1.default({
-                store: keyvRedis,
-                ttl: this.getNumber('CACHE_TTL'),
-            });
-            return {
-                isGlobal: true,
-                store,
-            };
-        });
-    }
     get(key, defaultValue) {
         const value = this.configService.get(key);
         if ((0, lodash_1.isNil)(value)) {
-            if (defaultValue) {
+            if (defaultValue !== undefined) {
                 return defaultValue;
             }
             throw new Error(`key:'${key}' - environment does not set`);