@mondart/nestjs-common-module 1.1.46 → 1.1.47

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 import 'reflect-metadata';
-export * from './caching';
 export * from './constants';
 export * from './controllers';
 export * from './decorators';

package/dist/index.js

@@ -15,7 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
-__exportStar(require("./caching"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./controllers"), exports);
 __exportStar(require("./decorators"), exports);

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

@@ -0,0 +1,17 @@
+import { ModuleMetadata, Type } from '@nestjs/common';
+export declare const CACHING_MODULE_OPTIONS = "CACHING_MODULE_OPTIONS";
+export interface CachingModuleOptions {
+    ttl: number;
+    host: string;
+    port: string;
+    password: string;
+}
+export interface CachingModuleFactory {
+    createModuleOptions: () => Promise<CachingModuleOptions> | CachingModuleOptions;
+}
+export interface CachingModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    inject?: any[];
+    useClass?: Type<CachingModuleFactory>;
+    useExisting?: Type<CachingModuleFactory>;
+    useFactory?: (...args: any[]) => Promise<CachingModuleOptions> | CachingModuleOptions;
+}

package/dist/lib/caching/caching.interface.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CACHING_MODULE_OPTIONS = void 0;
+exports.CACHING_MODULE_OPTIONS = 'CACHING_MODULE_OPTIONS';

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

@@ -0,0 +1,10 @@
+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;
+    private static createAsyncProviders;
+    private static createProviders;
+    private static createAsyncOptionsProvider;
+    private static createOptionsProvider;
+}

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

@@ -0,0 +1,94 @@
+"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 CachingModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachingModule = void 0;
+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) {
+        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],
+                }),
+            ],
+            providers: [
+                {
+                    provide: caching_interface_1.CACHING_MODULE_OPTIONS,
+                    useValue: options,
+                },
+                caching_service_1.CachingService,
+            ],
+            exports: [caching_service_1.CachingService],
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: CachingModule_1,
+            imports: [...options.imports],
+            providers: [...this.createAsyncProviders(options), caching_service_1.CachingService],
+            exports: [...this.createAsyncProviders(options), caching_service_1.CachingService],
+        };
+    }
+    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: 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(),
+        };
+    }
+};
+exports.CachingModule = CachingModule;
+exports.CachingModule = CachingModule = CachingModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], CachingModule);

package/dist/lib/index.d.ts

@@ -1,2 +1,3 @@
 export * from './kafka';
 export * from './saga';
+export * from './caching';

package/dist/lib/index.js

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

package/dist/lib/saga/decorators/saga.decorator.d.ts

@@ -1,4 +1,4 @@
 import 'reflect-metadata';
 import { Type } from '@nestjs/common';
-import { WithSaga } from '../types/saga.type';
+import { WithSaga } from '../types';
 export declare function Saga<S>(command: Type<S>): <X, T extends Type<WithSaga<X, S, unknown>>>(target: T) => T;

package/dist/lib/saga/decorators/saga.decorator.js

@@ -3,13 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Saga = Saga;
 require("reflect-metadata");
 const common_1 = require("@nestjs/common");
-const saga_handler_const_1 = require("../constant/saga-handler.const");
+const constant_1 = require("../constant");
 function Saga(command) {
     return (target) => {
         target.prototype.execute = function execute(cmd) {
             return this.saga.execute(cmd);
         };
-        Reflect.defineMetadata(saga_handler_const_1.__SAGA_HANDLER__, command, target);
+        Reflect.defineMetadata(constant_1.__SAGA_HANDLER__, command, target);
         return (0, common_1.Injectable)({ scope: common_1.Scope.REQUEST })(target);
     };
 }

package/dist/lib/saga/helpers/saga-exception-converter.helper.d.ts

@@ -1,3 +1,3 @@
 export declare class SagaExceptionConverterHelper {
-    static toHttpException(httpExceptionName: string, exception: any): void;
+    static toHttpException(exception: any): void;
 }

package/dist/lib/saga/helpers/saga-exception-converter.helper.js

@@ -4,11 +4,11 @@ exports.SagaExceptionConverterHelper = void 0;
 const exceptions = require("@nestjs/common/exceptions");
 const common_1 = require("@nestjs/common");
 class SagaExceptionConverterHelper {
-    static toHttpException(httpExceptionName, exception) {
-        if (exceptions[httpExceptionName])
-            throw new exceptions[httpExceptionName](exception);
+    static toHttpException(exception) {
+        if (exceptions[exception?.name])
+            throw new exceptions[exception?.name](exception?.response);
         else
-            throw new common_1.InternalServerErrorException(exception);
+            throw new common_1.InternalServerErrorException(exception?.response);
     }
 }
 exports.SagaExceptionConverterHelper = SagaExceptionConverterHelper;

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

@@ -1,5 +1,5 @@
 import { DynamicModule } from '@nestjs/common';
-import { SagaModuleRegisterParams } from './interfaces/saga-module-register.interface';
+import { SagaModuleRegisterParams } from './interfaces';
 export declare class SagaModule {
     static register(params: SagaModuleRegisterParams): DynamicModule;
 }

package/dist/lib/saga/saga.module.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SagaModule = void 0;
 const cqrs_1 = require("@nestjs/cqrs");
 const core_1 = require("@nestjs/core");
-const saga_handler_const_1 = require("./constant/saga-handler.const");
+const constant_1 = require("./constant");
 class SagaModule {
     static register(params) {
         return {
@@ -21,7 +21,7 @@ class SagaModule {
             providers: [
                 ...(params.providers || []),
                 ...params.sagas.flatMap((saga) => {
-                    const cmdType = Reflect.getMetadata(saga_handler_const_1.__SAGA_HANDLER__, saga);
+                    const cmdType = Reflect.getMetadata(constant_1.__SAGA_HANDLER__, saga);
                     let SagaCommandHandler = class SagaCommandHandler {
                         constructor(moduleRef) {
                             this.moduleRef = moduleRef;