@mondart/nestjs-common-module 1.1.47 → 1.1.48

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

@@ -1,10 +1,7 @@
 import { DynamicModule } from '@nestjs/common';
 import { CachingModuleAsyncOptions, CachingModuleOptions } from './caching.interface';
 export declare class CachingModule {
-    static forRoot(options: CachingModuleOptions): DynamicModule;
-    static forRootAsync(options: CachingModuleAsyncOptions): DynamicModule;
+    static register(options: CachingModuleOptions): DynamicModule;
+    static registerAsync(options: CachingModuleAsyncOptions): DynamicModule;
     private static createAsyncProviders;
-    private static createProviders;
-    private static createAsyncOptionsProvider;
-    private static createOptionsProvider;
 }

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

@@ -12,27 +12,21 @@ 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 kafka_interface_1 = require("../kafka/kafka.interface");
 const redisStore = require("cache-manager-redis-store");
 let CachingModule = CachingModule_1 = class CachingModule {
-    static forRoot(options) {
+    static register(options) {
+        const cacheModuleOptions = {
+            isGlobal: true,
+            store: redisStore,
+            ttl: options.ttl,
+            host: options.host,
+            port: options.port,
+            password: options.password,
+            max: 10000,
+        };
         return {
             module: CachingModule_1,
-            imports: [
-                cache_manager_1.CacheModule.register({
-                    isGlobal: true,
-                    useFactory: async (options) => ({
-                        store: redisStore,
-                        ttl: options.ttl,
-                        host: options.host,
-                        port: options.port,
-                        password: options.password,
-                        max: 10000,
-                        isGlobal: true,
-                    }),
-                    inject: [caching_interface_1.CACHING_MODULE_OPTIONS],
-                }),
-            ],
+            imports: [cache_manager_1.CacheModule.register(cacheModuleOptions)],
             providers: [
                 {
                     provide: caching_interface_1.CACHING_MODULE_OPTIONS,
@@ -43,7 +37,7 @@ let CachingModule = CachingModule_1 = class CachingModule {
             exports: [caching_service_1.CachingService],
         };
     }
-    static forRootAsync(options) {
+    static registerAsync(options) {
         return {
             module: CachingModule_1,
             imports: [...options.imports],
@@ -52,39 +46,34 @@ let CachingModule = CachingModule_1 = class CachingModule {
         };
     }
     static createAsyncProviders(options) {
-        if (options.useExisting || options.useFactory) {
-            return [this.createAsyncOptionsProvider(options)];
-        }
-        return [
-            this.createAsyncOptionsProvider(options),
-            {
-                provide: options.useClass,
-                useClass: options.useClass,
-            },
-        ];
-    }
-    static createProviders(options) {
-        return [this.createOptionsProvider(options)];
-    }
-    static createAsyncOptionsProvider(options) {
         if (options.useFactory) {
-            return {
-                provide: caching_interface_1.CACHING_MODULE_OPTIONS,
-                useFactory: options.useFactory,
-                inject: options.inject || [],
-            };
+            return [
+                {
+                    provide: caching_interface_1.CACHING_MODULE_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                },
+            ];
         }
-        return {
-            provide: caching_interface_1.CACHING_MODULE_OPTIONS,
-            useFactory: async (optionsFactory) => await optionsFactory.createModuleOptions(),
-            inject: [options.useExisting || options.useClass],
-        };
-    }
-    static createOptionsProvider(options) {
-        return {
-            provide: kafka_interface_1.KAFKA_MODULE_OPTIONS,
-            useFactory: async (optionsFactory) => await optionsFactory.createModuleOptions(),
-        };
+        const useClass = options.useClass || options.useExisting;
+        if (useClass) {
+            return [
+                {
+                    provide: caching_interface_1.CACHING_MODULE_OPTIONS,
+                    useFactory: async (optionsFactory) => await optionsFactory.createModuleOptions(),
+                    inject: [options.useExisting || options.useClass],
+                },
+                ...(options.useClass
+                    ? [
+                        {
+                            provide: options.useClass,
+                            useClass: options.useClass,
+                        },
+                    ]
+                    : []),
+            ];
+        }
+        throw new Error('Invalid CachingModuleAsyncOptions');
     }
 };
 exports.CachingModule = CachingModule;

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

@@ -3,7 +3,7 @@ export declare class CachingService {
     private cacheManager;
     constructor(cacheManager: Cache);
     getRedisClient(): import("cache-manager").Store;
-    get<T>(key: string): Promise<T>;
+    get<T>(key: string): Promise<T | undefined>;
     set<T>(key: string, value: T, ttlSeconds: number): Promise<void>;
     del(key: string): Promise<void>;
 }

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

@@ -27,13 +27,13 @@ let CachingService = class CachingService {
         if (result) {
             return JSON.parse(result);
         }
-        return result;
+        return undefined;
     }
     async set(key, value, ttlSeconds) {
-        return await this.cacheManager.set(key, JSON.stringify(value), ttlSeconds * 1000);
+        await this.cacheManager.set(key, JSON.stringify(value), ttlSeconds);
     }
     async del(key) {
-        return await this.cacheManager.del(key);
+        await this.cacheManager.del(key);
     }
 };
 exports.CachingService = CachingService;