@mondart/nestjs-common-module 1.1.49 → 1.1.51

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

@@ -3,7 +3,7 @@ export declare const CACHING_MODULE_OPTIONS = "CACHING_MODULE_OPTIONS";
 export interface CachingModuleOptions {
     ttl: number;
     host: string;
-    port: string;
+    port: number;
     password: string;
 }
 export interface CachingModuleFactory {

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

@@ -3,5 +3,6 @@ import { CachingModuleAsyncOptions, CachingModuleOptions } from './caching.inter
 export declare class CachingModule {
     static register(options: CachingModuleOptions): DynamicModule;
     static registerAsync(options: CachingModuleAsyncOptions): DynamicModule;
+    private static createAsyncOptionsProvider;
     private static createAsyncProviders;
 }

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

@@ -12,20 +12,24 @@ 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 redisStore = require("cache-manager-redis-store");
+const cache_manager_ioredis_yet_1 = require("cache-manager-ioredis-yet");
 let CachingModule = CachingModule_1 = class CachingModule {
     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(cacheModuleOptions)],
+            imports: [
+                cache_manager_1.CacheModule.register({
+                    isGlobal: true,
+                    useFactory: async (cachingOptions) => ({
+                        store: await (0, cache_manager_ioredis_yet_1.redisStore)({
+                            host: cachingOptions.host,
+                            port: cachingOptions.port,
+                            password: cachingOptions.password,
+                            ttl: cachingOptions.ttl,
+                        }),
+                    }),
+                }),
+            ],
             providers: [
                 {
                     provide: caching_interface_1.CACHING_MODULE_OPTIONS,
@@ -37,27 +41,44 @@ let CachingModule = CachingModule_1 = class CachingModule {
         };
     }
     static registerAsync(options) {
+        const asyncOptionsProvider = this.createAsyncOptionsProvider(options);
         return {
             module: CachingModule_1,
             imports: [
                 ...(options.imports || []),
+                asyncOptionsProvider,
                 cache_manager_1.CacheModule.registerAsync({
-                    imports: options.imports || [],
+                    imports: [asyncOptionsProvider],
                     useFactory: async (cachingOptions) => ({
-                        store: redisStore,
-                        ttl: Number(cachingOptions.ttl),
-                        host: cachingOptions.host,
-                        port: Number(cachingOptions.port),
-                        password: cachingOptions.password,
+                        store: await (0, cache_manager_ioredis_yet_1.redisStore)({
+                            host: cachingOptions.host,
+                            port: cachingOptions.port,
+                            password: cachingOptions.password,
+                            ttl: cachingOptions.ttl,
+                        }),
                         max: 10000,
                     }),
                     inject: [caching_interface_1.CACHING_MODULE_OPTIONS],
                 }),
             ],
-            providers: [...this.createAsyncProviders(options), caching_service_1.CachingService],
+            providers: [
+                {
+                    provide: caching_service_1.CachingService,
+                    useFactory: (cacheManager) => new caching_service_1.CachingService(cacheManager),
+                    inject: [cache_manager_1.CACHE_MANAGER],
+                },
+            ],
             exports: [caching_service_1.CachingService, cache_manager_1.CacheModule],
         };
     }
+    static createAsyncOptionsProvider(options) {
+        const providers = this.createAsyncProviders(options);
+        return {
+            module: CachingModule_1,
+            providers,
+            exports: [caching_interface_1.CACHING_MODULE_OPTIONS],
+        };
+    }
     static createAsyncProviders(options) {
         if (options.useFactory) {
             return [