@mondart/nestjs-common-module 1.1.47 → 1.1.49

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,20 @@ 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 = {
+            store: redisStore,
+            ttl: Number(options.ttl),
+            host: options.host,
+            port: Number(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,
@@ -40,51 +33,60 @@ let CachingModule = CachingModule_1 = class CachingModule {
                 },
                 caching_service_1.CachingService,
             ],
-            exports: [caching_service_1.CachingService],
+            exports: [caching_service_1.CachingService, cache_manager_1.CacheModule],
         };
     }
-    static forRootAsync(options) {
+    static registerAsync(options) {
         return {
             module: CachingModule_1,
-            imports: [...options.imports],
+            imports: [
+                ...(options.imports || []),
+                cache_manager_1.CacheModule.registerAsync({
+                    imports: options.imports || [],
+                    useFactory: async (cachingOptions) => ({
+                        store: redisStore,
+                        ttl: Number(cachingOptions.ttl),
+                        host: cachingOptions.host,
+                        port: Number(cachingOptions.port),
+                        password: cachingOptions.password,
+                        max: 10000,
+                    }),
+                    inject: [caching_interface_1.CACHING_MODULE_OPTIONS],
+                }),
+            ],
             providers: [...this.createAsyncProviders(options), caching_service_1.CachingService],
-            exports: [...this.createAsyncProviders(options), caching_service_1.CachingService],
+            exports: [caching_service_1.CachingService, cache_manager_1.CacheModule],
         };
     }
     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;

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

@@ -1,2 +1,3 @@
 export * from './caching.module';
 export * from './caching.service';
+export * from './caching.interface';

package/dist/lib/caching/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./caching.module"), exports);
 __exportStar(require("./caching.service"), exports);
+__exportStar(require("./caching.interface"), exports);