@mondart/nestjs-common-module 2.2.5 → 2.3.1

package/README.md

@@ -0,0 +1,8 @@
+
+### Make release
+
+#### after push to target version branch run the following command to create a release:
+
+```bash
+$ gh release create vx.x.x --target branch -t vx.x.x --notes ""
+```

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

@@ -3,7 +3,10 @@ export declare const CACHING_MODULE_OPTIONS = "CACHING_MODULE_OPTIONS";
 export interface CachingModuleOptions {
     host: string;
     port: number;
+    username?: string;
     password: string;
+    database?: number;
+    tls?: boolean;
     namespace?: string;
     ttl?: number;
 }

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

@@ -25,6 +25,13 @@ let CachingModule = CachingModule_1 = class CachingModule {
                             new redis_1.Keyv({
                                 store: new redis_1.default({
                                     url: `redis://${cachingOptions.host}:${cachingOptions.port}`,
+                                    socket: {
+                                        host: cachingOptions.host,
+                                        port: cachingOptions.port,
+                                        tls: cachingOptions.tls || false,
+                                    },
+                                    database: cachingOptions.database,
+                                    username: cachingOptions.username || 'default',
                                     password: cachingOptions.password,
                                 }),
                             }, {
@@ -59,6 +66,13 @@ let CachingModule = CachingModule_1 = class CachingModule {
                             new redis_1.Keyv({
                                 store: new redis_1.default({
                                     url: `redis://${cachingOptions.host}:${cachingOptions.port}`,
+                                    socket: {
+                                        host: cachingOptions.host,
+                                        port: cachingOptions.port,
+                                        tls: cachingOptions.tls || false,
+                                    },
+                                    database: cachingOptions.database,
+                                    username: cachingOptions.username || 'default',
                                     password: cachingOptions.password,
                                 }),
                             }, {

package/dist/lib/health-check/health-check-options.interface.d.ts

@@ -0,0 +1,34 @@
+import { ModuleMetadata, Type } from '@nestjs/common';
+import { SASLOptions } from 'kafkajs';
+import tls from 'tls';
+export declare const HEALTH_CHECK_MODULE_OPTIONS = "HEALTH_CHECK_MODULE_OPTIONS";
+export interface HealthCheckModuleOptions {
+    http?: {
+        docsUrl: string;
+    };
+    redis?: {
+        host: string;
+        port: number;
+        password?: string;
+    };
+    bull?: {
+        host: string;
+        port: number;
+        password?: string;
+    };
+    kafka?: {
+        clientId: string;
+        brokers: string[];
+        sasl?: SASLOptions;
+        ssl?: tls.ConnectionOptions;
+    };
+}
+export interface HealthCheckModuleFactory {
+    createModuleOptions: () => Promise<HealthCheckModuleOptions> | HealthCheckModuleOptions;
+}
+export interface HealthCheckModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    inject?: any[];
+    useClass?: Type<HealthCheckModuleFactory>;
+    useExisting?: Type<HealthCheckModuleFactory>;
+    useFactory?: (...args: any[]) => Promise<HealthCheckModuleOptions> | HealthCheckModuleOptions;
+}

package/dist/lib/health-check/health-check-options.interface.js

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

package/dist/lib/health-check/health-check.controller.d.ts

@@ -0,0 +1,15 @@
+import { HealthCheckService, HttpHealthIndicator, MicroserviceHealthIndicator, TypeOrmHealthIndicator } from '@nestjs/terminus';
+import { HealthCheckModuleOptions } from './health-check-options.interface';
+export declare class HealthCheckController {
+    private health;
+    private http;
+    private db;
+    private microservice;
+    private options;
+    constructor(health: HealthCheckService, http: HttpHealthIndicator, db: TypeOrmHealthIndicator, microservice: MicroserviceHealthIndicator, options: HealthCheckModuleOptions);
+    checkHttp(): Promise<import("@nestjs/terminus").HealthCheckResult>;
+    checkTypeOrm(): Promise<import("@nestjs/terminus").HealthCheckResult>;
+    checkRedis(): Promise<import("@nestjs/terminus").HealthCheckResult>;
+    checkBull(): Promise<import("@nestjs/terminus").HealthCheckResult>;
+    checkKafka(): Promise<import("@nestjs/terminus").HealthCheckResult>;
+}

package/dist/lib/health-check/health-check.controller.js

@@ -0,0 +1,120 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthCheckController = void 0;
+const common_1 = require("@nestjs/common");
+const microservices_1 = require("@nestjs/microservices");
+const terminus_1 = require("@nestjs/terminus");
+const health_check_options_interface_1 = require("./health-check-options.interface");
+let HealthCheckController = class HealthCheckController {
+    constructor(health, http, db, microservice, options) {
+        this.health = health;
+        this.http = http;
+        this.db = db;
+        this.microservice = microservice;
+        this.options = options;
+    }
+    checkHttp() {
+        return this.health.check([
+            () => this.http.pingCheck('app-docs', this.options?.http?.docsUrl),
+        ]);
+    }
+    checkTypeOrm() {
+        return this.health.check([async () => this.db.pingCheck('typeorm')]);
+    }
+    checkRedis() {
+        return this.health.check([
+            async () => this.microservice.pingCheck('redis', {
+                transport: microservices_1.Transport.REDIS,
+                options: {
+                    host: this.options?.redis?.host,
+                    port: this.options?.redis?.port,
+                    password: this.options?.redis?.password,
+                },
+            }),
+        ]);
+    }
+    checkBull() {
+        return this.health.check([
+            async () => this.microservice.pingCheck('redis', {
+                transport: microservices_1.Transport.REDIS,
+                options: {
+                    host: this.options?.bull?.host,
+                    port: this.options?.bull?.port,
+                    password: this.options?.bull?.password,
+                },
+            }),
+        ]);
+    }
+    checkKafka() {
+        return this.health.check([
+            async () => this.microservice.pingCheck('kafka', {
+                transport: microservices_1.Transport.KAFKA,
+                timeout: 2000,
+                options: {
+                    client: {
+                        clientId: this.options?.kafka?.clientId,
+                        brokers: this.options?.kafka?.brokers,
+                        sasl: this.options?.kafka?.sasl,
+                        ssl: this.options?.kafka?.ssl,
+                    },
+                },
+            }),
+        ]);
+    }
+};
+exports.HealthCheckController = HealthCheckController;
+__decorate([
+    (0, common_1.Get)('http'),
+    (0, terminus_1.HealthCheck)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], HealthCheckController.prototype, "checkHttp", null);
+__decorate([
+    (0, common_1.Get)('database'),
+    (0, terminus_1.HealthCheck)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], HealthCheckController.prototype, "checkTypeOrm", null);
+__decorate([
+    (0, common_1.Get)('redis'),
+    (0, terminus_1.HealthCheck)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], HealthCheckController.prototype, "checkRedis", null);
+__decorate([
+    (0, common_1.Get)('bull'),
+    (0, terminus_1.HealthCheck)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], HealthCheckController.prototype, "checkBull", null);
+__decorate([
+    (0, common_1.Get)('kafka'),
+    (0, terminus_1.HealthCheck)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], HealthCheckController.prototype, "checkKafka", null);
+exports.HealthCheckController = HealthCheckController = __decorate([
+    (0, common_1.Controller)('health-check'),
+    __param(4, (0, common_1.Inject)(health_check_options_interface_1.HEALTH_CHECK_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [terminus_1.HealthCheckService,
+        terminus_1.HttpHealthIndicator,
+        terminus_1.TypeOrmHealthIndicator,
+        terminus_1.MicroserviceHealthIndicator, Object])
+], HealthCheckController);

package/dist/lib/health-check/health-check.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+import { HealthCheckModuleAsyncOptions, HealthCheckModuleOptions } from './health-check-options.interface';
+export declare class HealthCheckModule {
+    static register(options: HealthCheckModuleOptions): DynamicModule;
+    static registerAsync(options: HealthCheckModuleAsyncOptions): DynamicModule;
+    private static createAsyncOptionsProvider;
+    private static createAsyncProviders;
+}

package/dist/lib/health-check/health-check.module.js

@@ -0,0 +1,85 @@
+"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 HealthCheckModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthCheckModule = void 0;
+const common_1 = require("@nestjs/common");
+const health_check_controller_1 = require("./health-check.controller");
+const terminus_1 = require("@nestjs/terminus");
+const axios_1 = require("@nestjs/axios");
+const health_check_options_interface_1 = require("./health-check-options.interface");
+let HealthCheckModule = HealthCheckModule_1 = class HealthCheckModule {
+    static register(options) {
+        return {
+            module: HealthCheckModule_1,
+            imports: [terminus_1.TerminusModule, axios_1.HttpModule],
+            providers: [
+                terminus_1.HealthCheckService,
+                {
+                    provide: health_check_options_interface_1.HEALTH_CHECK_MODULE_OPTIONS,
+                    useValue: options,
+                },
+            ],
+            controllers: [health_check_controller_1.HealthCheckController],
+            exports: [],
+        };
+    }
+    static registerAsync(options) {
+        const asyncOptionsProvider = this.createAsyncOptionsProvider(options);
+        return {
+            module: HealthCheckModule_1,
+            imports: [...(options.imports || []), asyncOptionsProvider],
+            providers: [],
+            controllers: [health_check_controller_1.HealthCheckController],
+            exports: [],
+        };
+    }
+    static createAsyncOptionsProvider(options) {
+        const providers = this.createAsyncProviders(options);
+        return {
+            module: HealthCheckModule_1,
+            imports: [terminus_1.TerminusModule, axios_1.HttpModule],
+            providers,
+            exports: [terminus_1.TerminusModule, axios_1.HttpModule, health_check_options_interface_1.HEALTH_CHECK_MODULE_OPTIONS],
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                {
+                    provide: health_check_options_interface_1.HEALTH_CHECK_MODULE_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                },
+            ];
+        }
+        const useClass = options.useClass || options.useExisting;
+        if (useClass) {
+            return [
+                {
+                    provide: health_check_options_interface_1.HEALTH_CHECK_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 HealthCheckModuleAsyncOptions');
+    }
+};
+exports.HealthCheckModule = HealthCheckModule;
+exports.HealthCheckModule = HealthCheckModule = HealthCheckModule_1 = __decorate([
+    (0, common_1.Module)({})
+], HealthCheckModule);

package/dist/lib/health-check/index.d.ts

@@ -0,0 +1,3 @@
+export * from './health-check.module';
+export * from './health-check.controller';
+export * from './health-check-options.interface';

package/dist/lib/health-check/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./health-check.module"), exports);
+__exportStar(require("./health-check.controller"), exports);
+__exportStar(require("./health-check-options.interface"), exports);

package/dist/lib/index.d.ts

@@ -3,3 +3,4 @@ export * from './saga';
 export * from './caching';
 export * from './keycloak';
 export * from './core-crud';
+export * from './health-check';

package/dist/lib/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./saga"), exports);
 __exportStar(require("./caching"), exports);
 __exportStar(require("./keycloak"), exports);
 __exportStar(require("./core-crud"), exports);
+__exportStar(require("./health-check"), exports);