@nest-omni/core 1.0.56 → 2.0.1-0

package/src/filters/bad-request.filter.ts

@@ -0,0 +1,77 @@
+import type { ArgumentsHost, ExceptionFilter } from '@nestjs/common';
+import { Catch, HttpException } from '@nestjs/common';
+import { Request, Response } from 'express';
+import { EntityNotFoundError } from 'typeorm';
+import { I18nContext, I18nValidationException } from 'nestjs-i18n';
+
+@Catch()
+export class HttpExceptionFilter implements ExceptionFilter {
+  catch(exception, host: ArgumentsHost) {
+    const i18n = I18nContext.current(host);
+    const ctx = host.switchToHttp();
+    const response: Response = ctx.getResponse();
+    const request: Request = ctx.getRequest();
+    let statusCode =
+      exception instanceof HttpException ? exception.getStatus() : 500;
+    let error =
+      exception instanceof HttpException
+        ? exception.message
+        : 'Internal server error';
+
+    if (exception instanceof EntityNotFoundError) {
+      statusCode = 404;
+      error = 'Entity not found';
+    }
+
+    if (statusCode === 500) {
+      console.error({
+        message: exception.message,
+        stack: exception.stack,
+        connection: {
+          localAddress: request.socket?.localAddress,
+          remoteAddress: request.socket?.remoteAddress,
+          bytesRead: request.socket?.bytesRead,
+          bytesWritten: request.socket?.bytesWritten,
+        },
+        headers: request.headers,
+      });
+    }
+
+    const getFirstError = (error, property = '') => {
+      if (error?.children?.length > 0) {
+        const firstError = error.children[0];
+        firstError['property'] = `${property}.${firstError['property']}`;
+        return getFirstError(firstError, firstError.property);
+      }
+
+      return error;
+    };
+
+    if (exception instanceof I18nValidationException) {
+      const firstErros = getFirstError(
+        exception.errors[0],
+        exception.errors[0].property,
+      );
+      const constraint = Object.values(firstErros.constraints)[0] as string;
+      const [translationKey, argsString] = constraint.split('|');
+      const args = !!argsString ? JSON.parse(argsString) : {};
+      error = i18n.translate(translationKey, {
+        args: {
+          property: firstErros.property,
+          value: firstErros.value,
+          constraints: firstErros.constraints,
+          ...args,
+        },
+      });
+    }
+
+    const parseJson = {
+      code: statusCode,
+      msg: error,
+      requestId: request.id,
+      timestamp: new Date().toISOString(),
+    };
+
+    return response.status(200).json(parseJson);
+  }
+}

package/src/filters/constraint-errors.ts

@@ -0,0 +1,5 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+
+export const constraintErrors: Record<string, string> = {
+  UQ_97672ac88f789774dd47f7c8be3: 'error.unique.email',
+};

package/src/filters/index.ts

@@ -0,0 +1,3 @@
+export * from './bad-request.filter';
+export * from './constraint-errors';
+export * from './query-failed.filter';

package/src/filters/query-failed.filter.ts

@@ -0,0 +1,32 @@
+import type { ArgumentsHost, ExceptionFilter } from '@nestjs/common';
+import { Catch, HttpStatus } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { STATUS_CODES } from 'http';
+import { QueryFailedError } from 'typeorm';
+
+import { constraintErrors } from './constraint-errors';
+
+@Catch(QueryFailedError)
+export class QueryFailedFilter implements ExceptionFilter<QueryFailedError> {
+  constructor(public reflector: Reflector) {}
+
+  catch(
+    exception: QueryFailedError & { constraint?: string },
+    host: ArgumentsHost,
+  ) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+
+    const status = exception.constraint?.startsWith('UQ')
+      ? HttpStatus.CONFLICT
+      : HttpStatus.INTERNAL_SERVER_ERROR;
+
+    response.status(status).json({
+      code: status,
+      error: STATUS_CODES[status],
+      msg: exception.constraint
+        ? constraintErrors[exception.constraint]
+        : undefined,
+    });
+  }
+}

package/src/health-checker/health-checker.controller.ts

@@ -0,0 +1,51 @@
+import Redis from 'ioredis';
+import { Controller, Get } from '@nestjs/common';
+import type { HealthCheckResult } from '@nestjs/terminus';
+import {
+  HealthCheck,
+  HealthCheckService,
+  TypeOrmHealthIndicator,
+} from '@nestjs/terminus';
+
+import { ServiceHealthIndicator } from './health-indicators/service.indicator';
+import { ApiOperation } from '@nestjs/swagger';
+import { RedisHealthIndicator } from '@mvmdev/nestjs-redis-health';
+import { ApiConfigService } from '../shared/services';
+
+@Controller('health')
+export class HealthCheckerController {
+  private readonly redis: Redis;
+
+  constructor(
+    private configService: ApiConfigService,
+    private healthCheckService: HealthCheckService,
+    private ormIndicator: TypeOrmHealthIndicator,
+    private serviceIndicator: ServiceHealthIndicator,
+    private redisIndicator: RedisHealthIndicator,
+  ) {
+    if (this.configService.isRedisEnabled) {
+      this.redis = new Redis(this.configService.ioRedisConfig);
+    }
+  }
+
+  @Get()
+  @HealthCheck()
+  @ApiOperation({ summary: 'Service health check' })
+  async check(): Promise<HealthCheckResult> {
+    const indicator = [
+      () => this.ormIndicator.pingCheck('database', { timeout: 1500 }),
+    ];
+
+    if (this.configService.isRedisEnabled) {
+      indicator.push(() =>
+        this.redisIndicator.checkHealth('redis', {
+          type: 'redis',
+          client: this.redis,
+          timeout: 1500,
+        }),
+      );
+    }
+
+    return this.healthCheckService.check(indicator);
+  }
+}

package/src/health-checker/health-checker.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { TerminusModule } from '@nestjs/terminus';
+import { RedisHealthModule } from '@mvmdev/nestjs-redis-health';
+import { HealthCheckerController } from './health-checker.controller';
+import { ServiceHealthIndicator } from './health-indicators/service.indicator';
+import { ApiConfigService } from '../shared/services';
+
+@Module({
+  imports: [TerminusModule, RedisHealthModule],
+  controllers: [HealthCheckerController],
+  providers: [ApiConfigService, ServiceHealthIndicator],
+})
+export class HealthCheckerModule {}

package/src/health-checker/health-indicators/service.indicator.ts

@@ -0,0 +1,44 @@
+import { Inject, Injectable, Optional } from '@nestjs/common';
+import { ClientProxy } from '@nestjs/microservices';
+import type { HealthIndicatorResult } from '@nestjs/terminus';
+import { HealthCheckError, HealthIndicator } from '@nestjs/terminus';
+import { firstValueFrom } from 'rxjs';
+import { timeout } from 'rxjs/operators';
+
+@Injectable()
+export class ServiceHealthIndicator extends HealthIndicator {
+  constructor(
+    @Optional()
+    @Inject('NATS_SERVICE')
+    private readonly clientProxy?: ClientProxy,
+  ) {
+    super();
+  }
+
+  async isHealthy(eventName: string): Promise<HealthIndicatorResult> {
+    try {
+      if (!this.clientProxy) {
+        return {
+          [eventName]: {
+            status: 'down',
+          },
+        };
+      }
+
+      const result = await firstValueFrom(
+        this.clientProxy.send(eventName, { check: true }).pipe(timeout(10000)),
+        {
+          defaultValue: undefined,
+        },
+      );
+
+      return {
+        [eventName]: result,
+      };
+    } catch (error) {
+      throw new HealthCheckError(`${eventName} failed`, {
+        [eventName]: error,
+      });
+    }
+  }
+}

package/src/helpers/common.helper.ts

@@ -0,0 +1,49 @@
+import { networkInterfaces } from 'os';
+
+/**
+ * 将枚举值转换成数组
+ * @param Enum 枚举
+ */
+export function enumToArray<E>(Enum: any): E[] {
+  return Object.keys(Enum)
+    .filter((key) => typeof Enum[key as any] === 'number')
+    .map((key) => Enum[key]);
+}
+
+/**
+ * 生成随机字符串
+ * @param {number} length 生成长度
+ * @param {string} charSet 指定字符集
+ * @returns {string} 生成字符串
+ */
+export const randomString = (length: number = 8, charSet?: string): string => {
+  charSet =
+    charSet || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  let randomString = '';
+  for (let i = 0; i < length; i++) {
+    const randomPoz = Math.floor(Math.random() * charSet.length);
+    randomString += charSet.substring(randomPoz, randomPoz + 1);
+  }
+  return randomString;
+};
+
+/**
+ * 获取服务部署 IP 地址
+ */
+export function getIPAdress(): string {
+  const interfaces = networkInterfaces();
+
+  for (const devName in interfaces) {
+    const iface = interfaces[devName];
+    for (let i = 0; i < iface.length; i++) {
+      const alias = iface[i];
+      if (
+        alias.family === 'IPv4' &&
+        alias.address !== '127.0.0.1' &&
+        !alias.internal
+      ) {
+        return alias.address;
+      }
+    }
+  }
+}

package/src/helpers/date.helper.ts

@@ -0,0 +1,64 @@
+import { ColumnOptions } from 'typeorm/decorator/options/ColumnOptions';
+import * as moment from 'moment';
+import * as _ from 'lodash';
+
+export function timestamp(value?: number) {
+  if (!value) {
+    value = moment.now();
+  }
+  return Math.round(value / 1000);
+}
+
+export function strToTimeStamp(str: string | Date) {
+  if (_.isEmpty(str)) {
+    return 0;
+  }
+  return moment(str).unix();
+}
+
+export function getTodayTimeStamp() {
+  const startTime = strToTimeStamp(moment().format('YYYY-MM-DD 00:00:00'));
+  const endTime = strToTimeStamp(moment().format('YYYY-MM-DD 23:59:59'));
+  return {
+    startTime,
+    endTime,
+  };
+}
+
+export function unixtimestampToDate(value: number): Date {
+  return moment(value * 1000).toDate();
+}
+
+export function formatDateTime(
+  value: number | string,
+  format: string = 'YYYY-MM-DD HH:mm:ss',
+  holder: string | null = '',
+): string {
+  if (value === 'now') {
+    return moment().format(format);
+  }
+
+  if (typeof value === 'string') {
+    return value;
+  }
+
+  if (value > 0) {
+    return moment(value * 1000).format(format);
+  }
+
+  return holder;
+}
+
+export function timestampColumn(name: string): ColumnOptions {
+  return {
+    type: 'int',
+    name,
+    nullable: false,
+    default: 0,
+    transformer: {
+      to: (value) =>
+        value === 0 || /\d{10}/.test(value) ? value : strToTimeStamp(value),
+      from: (value?: number) => (!value ? value : formatDateTime),
+    },
+  };
+}

package/src/helpers/index.ts

@@ -0,0 +1,2 @@
+export * from './date.helper';
+export * from './common.helper';

package/src/i18n/en_US/validation.json

@@ -0,0 +1,41 @@
+{
+  "NOT_EMPTY": "{property} cannot be empty",
+  "NOT_EQUALS": "{property} should not be equal to {constraints.1}",
+  "LENGTH": "{property} needs to be at least {constraints.0} and at most  {constraints.1} characters long",
+  "MIN_LENGTH": "{property} needs to be at least {constraints.0} characters long",
+  "MAX_LENGTH": "{property} needs to be at most {constraints.0} characters long",
+  "INVALID_EMAIL": " {property} is invalid email",
+  "INVALID_BOOLEAN": "{property} is not a boolean",
+  "MIN": "{property} with value: \"{value}\" needs to be at least {constraints.0}",
+  "MAX": "{property} with value: \"{value}\" needs to be less than {constraints.0}",
+  "NOT_FOUND": "Not Found",
+  "DELETE_FAILED": "Gagal menghapus data",
+  "FILE_NOT_EMPTY": "File tidak boleh kosong",
+  "FILE_ONLY_EXCEL": "Hanya menerima extensi xlsx, xls",
+  "EMAIL_EXISTS": "email already exits",
+  "CONFIRM_PASSWORD_NOT_MATCH": "confirm password not match",
+  "INVALID_STRING": "{property} must be a string",
+  "INVALID_DATETIME": "{property} is not a valid date",
+  "IS_NUMBER": "{property} must be a number",
+  "IS_ENUM": "{property} must be one of the following values: {constraints.1}",
+  "IS_STRING": "{property} must be a string",
+  "IS_ARRAY": "{property} must be an array",
+  "IS_URL": "{property} must be a URL",
+  "IS_UUID": "{property} must be a UUID",
+  "IS_DATE": "{property} must be a Date instance",
+  "MIN_DATE": "{property} should be later than {constraints.0}",
+  "MIN_DATE_NOW": "{property} should be later than the current time",
+  "MAX_DATE": "{property} should be earlier than {constraints.0}",
+  "MAX_DATE_NOW": "{property} should be earlier than current time",
+  "IS_IN": "{property} must be one of the following values: {constraints.1}",
+  "IS_INT": "{property} must be an integer number",
+  "IS_POSITIVE": "{property} must be a positive number",
+  "IS_NOT_EMPTY": "{property} should not be empty",
+  "IS_UNIQUE": "{property} with the same value `{value}` exists",
+  "IS_EXISTS": "{property} value `{value}` does not exists",
+  "IS_FQDN": "{property} value `{value}` not a valid FQDN",
+  "IS_IP": "{property} value `{value}` not a valid IP",
+  "IS_OBJECT": "{property} value `{value}` not a valid Object",
+  "IS_TIME_ZONE": "{property} value `{value}` must be a valid IANA time-zone",
+  "IS_LOCALE": "{property} value `{value}` must be a valid locale"
+}

package/src/i18n/zh_CN/validation.json

@@ -0,0 +1,41 @@
+{
+  "NOT_EMPTY": "{property}不能为空",
+  "NOT_EQUALS": "{property}不能等于{constraints.1}",
+  "LENGTH": "{property}长度必须在{constraints.0}到{constraints.1}个字符之间",
+  "MIN_LENGTH": "{property}长度至少为{constraints.0}个字符",
+  "MAX_LENGTH": "{property}长度不能超过{constraints.0}个字符",
+  "INVALID_EMAIL": "{property}不是有效电子邮件",
+  "INVALID_BOOLEAN": "{property}不是布尔值",
+  "MIN": "{property}必须大于{constraints.0}",
+  "MAX": "{property}必须小于{constraints.0}",
+  "NOT_FOUND": "未找到",
+  "DELETE_FAILED": "删除数据失败",
+  "FILE_NOT_EMPTY": "文件不能为空",
+  "FILE_ONLY_EXCEL": "只接受xlsx、xls文件",
+  "EMAIL_EXISTS": "电子邮件已存在",
+  "CONFIRM_PASSWORD_NOT_MATCH": "确认密码不匹配",
+  "INVALID_STRING": "{property}必须是一个字符串",
+  "INVALID_DATETIME": "{property}不是一个有效日期",
+  "IS_NUMBER": "{property}必须是一个数字",
+  "IS_ENUM": "{property}必须是以下值之一：{constraints.1}",
+  "IS_STRING": "{property}必须是一个字符串",
+  "IS_ARRAY": "{property}必须是一个数组",
+  "IS_URL": "{property}必须是一个URL",
+  "IS_UUID": "{property}必须是一个UUID",
+  "IS_DATE": "{property}必须是一个日期实例",
+  "MIN_DATE": "{property}日期不早于{constraints.0}",
+  "MAX_DATE": "{property}日期不晚于{constraints.0}",
+  "MIN_DATE_NOW": "{property}日期不早于当前时间",
+  "MAX_DATE_NOW": "{property}日期不晚于当前时间",
+  "IS_IN": "{property}必须是以下值之一：{constraints}",
+  "IS_INT": "{property}必须是一个整数",
+  "IS_POSITIVE": "{property}必须是一个正数",
+  "IS_NOT_EMPTY": "{property}不能为空",
+  "IS_UNIQUE": "存在相同值为`{value}`的{property}",
+  "IS_EXISTS": "{property}值`{value}`不存在",
+  "IS_FQDN": "{property} 值 `{value}` 必须是有效域名",
+  "IS_IP": "{property} 值 `{value}` 必须是有效IP",
+  "IS_OBJECT": "{property} 值 `{value}` 必须是有效对象",
+  "IS_TIME_ZONE": "{property} 值 `{value}` 必须是有效时区",
+  "IS_LOCALE": "{property} 值 `{value}` 必须是有效语言"
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export * from './constants';
+export * from './decorators';
+export * from './exceptions';
+export * from './filters';
+export * from './interfaces';
+export * from './interceptors';
+export * from './shared';
+export * from './middlewares';
+export * from './validators';
+export * from './common';
+export * from './validator-json';

package/src/interceptors/index.ts

@@ -0,0 +1,2 @@
+export * from './language-interceptor.service';
+export * from './translation-interceptor.service';

package/src/interceptors/language-interceptor.service.ts

@@ -0,0 +1,28 @@
+import type {
+  CallHandler,
+  ExecutionContext,
+  NestInterceptor,
+} from '@nestjs/common';
+import { Injectable, UseInterceptors } from '@nestjs/common';
+import type { Observable } from 'rxjs';
+
+import { LanguageCode } from '../constants';
+import { ContextProvider } from '../providers';
+
+@Injectable()
+export class LanguageInterceptor implements NestInterceptor {
+  intercept(
+    context: ExecutionContext,
+    next: CallHandler,
+  ): Observable<undefined> {
+    const request = context.switchToHttp().getRequest();
+    const lang = request.headers['accept-language'] ?? LanguageCode.en_US;
+    ContextProvider.setLanguage(lang);
+
+    return next.handle();
+  }
+}
+
+export function UseLanguageInterceptor() {
+  return UseInterceptors(LanguageInterceptor);
+}

package/src/interceptors/translation-interceptor.service.ts

@@ -0,0 +1,43 @@
+import type {
+  CallHandler,
+  ExecutionContext,
+  NestInterceptor,
+} from '@nestjs/common';
+import { HttpStatus, Injectable } from '@nestjs/common';
+import type { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Request } from 'express';
+// import { TranslationService } from '../shared/services/translation.service';
+
+// FIXME: add implementation
+@Injectable()
+export class TranslationInterceptor implements NestInterceptor {
+  // constructor(private readonly translationService: TranslationService) {}
+
+  public intercept(
+    context: ExecutionContext,
+    next: CallHandler,
+  ): Observable<any> {
+    const ctx = context.switchToHttp();
+    const req: Request = ctx.getRequest();
+    const res = ctx.getResponse();
+    return next.handle().pipe(
+      map((data) => {
+        // const newData = this.translationService.translateNecessaryKeys(data);
+
+        // status 201 => 200
+        if (res.statusCode === HttpStatus.CREATED) {
+          res.status(HttpStatus.OK);
+        }
+
+        return {
+          code: 200,
+          data,
+          msg: 'success',
+          requestId: req.id,
+          timestamp: new Date().toISOString(),
+        };
+      }),
+    );
+  }
+}

package/src/interfaces/IApiFile.ts

@@ -0,0 +1,4 @@
+export interface IApiFile {
+  name: string;
+  isArray?: boolean;
+}

package/src/interfaces/IFile.ts

@@ -0,0 +1,8 @@
+export interface IFile {
+  encoding: string;
+  buffer: Buffer;
+  fieldname: string;
+  mimetype: string;
+  originalname: string;
+  size: number;
+}

package/src/interfaces/ITranslationDecoratorInterface.ts

@@ -0,0 +1,3 @@
+export interface ITranslationDecoratorInterface {
+  translationKey?: string;
+}

package/src/interfaces/index.ts

@@ -0,0 +1,3 @@
+export * from './IApiFile';
+export * from './IFile';
+export * from './ITranslationDecoratorInterface';

package/src/interfaces/response.ts

@@ -0,0 +1,37 @@
+export type TExceptionOption =
+  | string
+  | {
+      code: number;
+      msg: string;
+      error?: any;
+    };
+
+// 分页数据
+export interface IHttpResultPaginate<T> {
+  list: T;
+  total: number;
+  page: number;
+  pageCount: number;
+  count: number;
+}
+
+// HTTP 状态返回
+export interface IHttpResponseBase {
+  code: number;
+  msg: string;
+  timestamp: string;
+  requestId: string;
+}
+
+// HTTP error
+export type THttpErrorResponse = IHttpResponseBase & {
+  error: any;
+};
+
+// HTTP success
+export type THttpSuccessResponse<T> = IHttpResponseBase & {
+  data: T | IHttpResultPaginate<T>;
+};
+
+// HTTP Response
+export type THttpResponse<T> = THttpErrorResponse | THttpSuccessResponse<T>;

package/src/middlewares/index.ts

@@ -0,0 +1,4 @@
+export * from './request-id.middleware';
+export * from './powerby.middleware';
+export * from './omni-auth.middleware';
+export * from './xml.middleware';

package/src/middlewares/omni-auth.middleware.ts

@@ -0,0 +1,10 @@
+import { getOmniAuthData } from '../decorators/user.decorator';
+import { ContextProvider } from '../providers';
+
+export const OmniAuthMiddleware = () => {
+  return (req, res, next) => {
+    req.user = getOmniAuthData(req);
+    ContextProvider.setAuthUser(req.user);
+    next();
+  };
+};

package/src/middlewares/powerby.middleware.ts

@@ -0,0 +1,6 @@
+export const PowerByMiddleware = (by = 'KN') => {
+  return (req, res, next) => {
+    res.header('x-powered-by', by);
+    next();
+  };
+};

package/src/middlewares/request-id.middleware.ts

@@ -0,0 +1,28 @@
+import { NextFunction, Request, Response } from 'express';
+import { v4 as uuidv4 } from 'uuid';
+import { ContextProvider } from '../providers';
+
+export interface RequestIdConfig {
+  header: string;
+  idGenerator: () => string;
+  setHeader: boolean;
+}
+
+export const RequestIdMiddleware = (
+  config: RequestIdConfig = {
+    header: 'x-request-id',
+    idGenerator: uuidv4,
+    setHeader: true,
+  },
+) => {
+  return (req: Request, res: Response, next: NextFunction) => {
+    const requestId = req.header(config.header) || config.idGenerator();
+    req.headers[config.header] = requestId;
+    req.id = requestId;
+    ContextProvider.setRequestId(requestId);
+    if (config.setHeader) {
+      res.set(config.header, requestId);
+    }
+    next();
+  };
+};

package/src/middlewares/xml.middleware.ts

@@ -0,0 +1,14 @@
+import { Injectable, NestMiddleware } from '@nestjs/common';
+import * as bodyParser from 'body-parser';
+
+const bodyParserMiddleware = bodyParser.text({
+  limit: '1024kb',
+  type: 'application/xml',
+});
+
+@Injectable()
+export class XMLMiddleware implements NestMiddleware {
+  use(req: any, res: any, next: () => void) {
+    bodyParserMiddleware(req, res, next);
+  }
+}