@mondart/nestjs-common-module 2.2.3 → 2.2.5

package/dist/lib/caching/caching.interface.d.ts

@@ -1,10 +1,11 @@
 import { ModuleMetadata, Type } from '@nestjs/common';
 export declare const CACHING_MODULE_OPTIONS = "CACHING_MODULE_OPTIONS";
 export interface CachingModuleOptions {
-    ttl: number;
     host: string;
     port: number;
     password: string;
+    namespace?: string;
+    ttl?: number;
 }
 export interface CachingModuleFactory {
     createModuleOptions: () => Promise<CachingModuleOptions> | CachingModuleOptions;

package/dist/lib/caching/caching.module.js

@@ -12,6 +12,7 @@ const common_1 = require("@nestjs/common");
 const caching_service_1 = require("./caching.service");
 const cache_manager_1 = require("@nestjs/cache-manager");
 const caching_interface_1 = require("./caching.interface");
+const redis_1 = require("@keyv/redis");
 let CachingModule = CachingModule_1 = class CachingModule {
     static register(options) {
         return {
@@ -20,10 +21,17 @@ let CachingModule = CachingModule_1 = class CachingModule {
                 cache_manager_1.CacheModule.register({
                     isGlobal: true,
                     useFactory: async (cachingOptions) => ({
-                        host: cachingOptions.host,
-                        port: cachingOptions.port,
-                        password: cachingOptions.password,
-                        ttl: cachingOptions.ttl,
+                        stores: [
+                            new redis_1.Keyv({
+                                store: new redis_1.default({
+                                    url: `redis://${cachingOptions.host}:${cachingOptions.port}`,
+                                    password: cachingOptions.password,
+                                }),
+                            }, {
+                                namespace: cachingOptions.namespace,
+                                ttl: cachingOptions.ttl,
+                            }),
+                        ],
                     }),
                 }),
             ],
@@ -47,11 +55,17 @@ let CachingModule = CachingModule_1 = class CachingModule {
                 cache_manager_1.CacheModule.registerAsync({
                     imports: [asyncOptionsProvider],
                     useFactory: async (cachingOptions) => ({
-                        host: cachingOptions.host,
-                        port: cachingOptions.port,
-                        password: cachingOptions.password,
-                        ttl: cachingOptions.ttl,
-                        max: 10000,
+                        stores: [
+                            new redis_1.Keyv({
+                                store: new redis_1.default({
+                                    url: `redis://${cachingOptions.host}:${cachingOptions.port}`,
+                                    password: cachingOptions.password,
+                                }),
+                            }, {
+                                namespace: cachingOptions.namespace,
+                                ttl: cachingOptions.ttl,
+                            }),
+                        ],
                     }),
                     inject: [caching_interface_1.CACHING_MODULE_OPTIONS],
                 }),

package/dist/lib/caching/caching.service.d.ts

@@ -1,10 +1,12 @@
 import { Cache } from 'cache-manager';
+import { Keyv } from '@keyv/redis';
 export declare class CachingService {
     private cacheManager;
+    private readonly logger;
     constructor(cacheManager: Cache);
-    getStores(): import("keyv").Keyv<any>[];
+    getStore(): Keyv<any>;
     get<T>(key: string): Promise<T | undefined>;
-    getMany<T>(keys: string[]): Promise<T[] | undefined>;
+    getMany<T>(keys?: string[]): Promise<T[] | undefined>;
     set<T>(key: string, value: T, ttlSeconds?: number): Promise<string>;
     setMany<T>(list: {
         key: string;

package/dist/lib/caching/caching.service.js

@@ -11,16 +11,30 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
+var CachingService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CachingService = void 0;
 const common_1 = require("@nestjs/common");
 const cache_manager_1 = require("@nestjs/cache-manager");
-let CachingService = class CachingService {
+const redis_1 = require("@keyv/redis");
+let CachingService = CachingService_1 = class CachingService {
     constructor(cacheManager) {
         this.cacheManager = cacheManager;
+        this.logger = new common_1.Logger(CachingService_1.name, {
+            timestamp: true,
+        });
+        if (this.cacheManager.stores?.length === 0) {
+            throw new Error('Cache manager is not initialized');
+        }
+        if (!(this.cacheManager.stores?.[0] instanceof redis_1.Keyv)) {
+            throw new Error('Cache manager is not a Keyv instance');
+        }
+        this.cacheManager.stores[0].opts.store.on('error', (error) => {
+            this.logger.error('Redis error:', error);
+        });
     }
-    getStores() {
-        return this.cacheManager.stores;
+    getStore() {
+        return this.cacheManager.stores?.[0];
     }
     async get(key) {
         const result = await this.cacheManager.get(key);
@@ -64,7 +78,7 @@ let CachingService = class CachingService {
     }
 };
 exports.CachingService = CachingService;
-exports.CachingService = CachingService = __decorate([
+exports.CachingService = CachingService = CachingService_1 = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Inject)(cache_manager_1.CACHE_MANAGER)),
     __metadata("design:paramtypes", [Object])