@nest-omni/core 1.0.56 → 2.0.1-0

package/src/shared/services/api-config.service.ts

@@ -0,0 +1,336 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import type { TypeOrmModuleOptions } from '@nestjs/typeorm';
+import { isNil } from 'lodash';
+import session from 'express-session';
+import { Params } from 'nestjs-pino';
+import { redisStore } from 'cache-manager-ioredis-yet';
+import { BullRootModuleOptions } from '@nestjs/bull/dist/interfaces/bull-module-options.interface';
+import RedisStore from 'connect-redis';
+import Redis from 'ioredis';
+import { AxiosProxyConfig } from 'axios';
+import { CorsOptions } from '@nestjs/common/interfaces/external/cors-options.interface';
+import { SnakeNamingStrategy } from '../../common';
+
+@Injectable()
+export class ApiConfigService {
+  static rootPath: string;
+
+  constructor(private configService: ConfigService) {}
+
+  static getRootPath(): string {
+    if (!ApiConfigService.rootPath) {
+      throw new Error(`rootPath is not set`);
+    }
+    return ApiConfigService.rootPath;
+  }
+
+  get isDev(): boolean {
+    return this.nodeEnv === 'dev';
+  }
+
+  get apiVersion(): string {
+    return this.getString('API_VERSION');
+  }
+
+  get isProd(): boolean {
+    return this.nodeEnv === 'prod';
+  }
+
+  get isSit(): boolean {
+    return this.nodeEnv === 'sit';
+  }
+
+  get isUat(): boolean {
+    return this.nodeEnv === 'uat';
+  }
+
+  get isTest(): boolean {
+    return this.nodeEnv === 'test';
+  }
+
+  getNumber(key: string, defaultValue?: number): number {
+    const value = this.get(key, defaultValue);
+
+    try {
+      return Number(value);
+    } catch {
+      throw new Error(`key:${key}, value:${value} - is not a number`);
+    }
+  }
+
+  getBoolean(key: string, defaultValue?: boolean): boolean {
+    const value = this.get(key, defaultValue);
+
+    return ApiConfigService.toBoolean(value);
+  }
+
+  static toBoolean(value: string, defaultValue = null): boolean {
+    try {
+      return Boolean(JSON.parse(value));
+    } catch {
+      if (!isNil(defaultValue)) {
+        return defaultValue;
+      }
+      throw new Error(`value:${value} - is not a boolean`);
+    }
+  }
+
+  getString(key: string): string {
+    const value = this.get(key);
+
+    return value.replace(/\\n/g, '\n');
+  }
+
+  get nodeEnv(): string {
+    return this.getString('NODE_ENV');
+  }
+
+  get fallbackLanguage(): string {
+    return this.getString('FALLBACK_LANGUAGE');
+  }
+
+  get typeormConfig(): TypeOrmModuleOptions {
+    return {
+      autoLoadEntities: true,
+      keepConnectionAlive: !this.isDev,
+      type: 'mysql',
+      host: this.getString('DB_HOST'),
+      port: this.getNumber('DB_PORT'),
+      username: this.getString('DB_USERNAME'),
+      password: this.getString('DB_PASSWORD'),
+      database: this.getString('DB_DATABASE'),
+      subscribers: [],
+      synchronize: this.isDev,
+      migrationsRun: true,
+      logging: this.getBoolean('DB_LOG_ENABLED'),
+      maxQueryExecutionTime: 3000,
+      namingStrategy: new SnakeNamingStrategy(),
+      timezone: this.getString('TZ'),
+      cache: this.getBoolean('DB_CACHE_ENABLED')
+        ? {
+            type: 'ioredis',
+            options: this.ioRedisConfig,
+          }
+        : false,
+    };
+  }
+
+  get documentationEnabled(): boolean {
+    return this.getBoolean('SWAGGER_ENABLED');
+  }
+
+  get documentationPath(): string {
+    return this.getString('SWAGGER_PATH');
+  }
+
+  get viewsEnabled(): boolean {
+    return this.getBoolean('VIEWS_ENABLED');
+  }
+
+  get sessionEnabled(): boolean {
+    return this.getBoolean('SESSION_ENABLED');
+  }
+
+  get corsEnabled(): boolean {
+    try {
+      return this.getBoolean('CORS_ENABLED');
+    } catch (error) {
+      return false;
+    }
+  }
+
+  get corsConfig(): CorsOptions {
+    const allowedDomains = this.getString('CORS_ORIGIN').split(',');
+    return {
+      origin: (origin, callback) => {
+        if (!origin) {
+          return callback(null, true);
+        }
+
+        // 支持通配符匹配逻辑
+        const isAllowed = allowedDomains.some((domain) => {
+          // 处理包含通配符的情况（如 *.example.com）
+          if (domain.includes('*')) {
+            // 将通配符转换为正则表达式
+            const regexPattern = domain
+              .replace(/\./g, '\\.')
+              .replace(':*', '(:\\d+)?') // 处理端口通配符
+              .replace('*\\.', '(.*\\.)?');
+            const fullRegex = new RegExp(`^https?:\/\/${regexPattern}$`, 'i');
+            return fullRegex.test(origin);
+          }
+
+          // 完全匹配（包含端口匹配）
+          return origin === domain || origin.startsWith(`${domain}:`);
+        });
+
+        isAllowed
+          ? callback(null, origin)
+          : callback(new BadRequestException('Not allowed by CORS'));
+      },
+      methods: this.getString('CORS_METHODS'),
+      allowedHeaders: this.getString('CORS_ALLOWED_HEADERS'),
+      exposedHeaders: this.getString('CORS_EXPOSED_HEADERS'),
+      credentials: this.getBoolean('CORS_CREDENTIALS'),
+      optionsSuccessStatus: 200,
+    };
+  }
+
+  get sessionConfig(): session.SessionOptions {
+    const config: session.SessionOptions = {
+      secret: this.getString('SESSION_KEY'),
+      resave: false,
+      saveUninitialized: false,
+    };
+
+    if (this.getBoolean('SESSION_REDIS_ENABLED')) {
+      config.store = new RedisStore({
+        client: new Redis(this.ioRedisConfig),
+        prefix: this.getString('SESSION_REDIS_PREFIX'),
+      });
+    }
+
+    return config;
+  }
+
+  get authConfig() {
+    return {
+      privateKey: this.getString('JWT_PRIVATE_KEY'),
+      publicKey: this.getString('JWT_PUBLIC_KEY'),
+      jwtExpirationTime: this.getNumber('JWT_EXPIRATION_TIME'),
+    };
+  }
+
+  get appConfig() {
+    return {
+      port: this.getString('PORT'),
+    };
+  }
+
+  get apiKey(): string {
+    return this.getString('API_KEY');
+  }
+
+  get ioRedisConfig() {
+    return {
+      host: this.getString('REDIS_HOST'),
+      port: this.getNumber('REDIS_PORT'),
+      username: this.getString('REDIS_USERNAME'),
+      password: this.getString('REDIS_PASSWORD'),
+      db: this.getNumber('REDIS_DB'),
+    };
+  }
+
+  /**
+   * 是否使用Redis，用于health check
+   */
+  get isRedisEnabled(): boolean {
+    return (
+      this.getBoolean('BULL_ENABLED') ||
+      this.getBoolean('CACHE_ENABLED') ||
+      this.getBoolean('DB_CACHE_ENABLED') ||
+      (this.sessionEnabled && this.getBoolean('SESSION_REDIS_ENABLED'))
+    );
+  }
+
+  get bullConfig(): BullRootModuleOptions {
+    return {
+      redis: {
+        ...this.ioRedisConfig,
+        // 增加重连策略
+        retryStrategy: (times: number) => Math.min(times * 1000, 5000),
+      },
+      prefix: this.getString('BULL_PREFIX'),
+      defaultJobOptions: {
+        removeOnComplete: true,
+        removeOnFail: true,
+        attempts: this.getNumber('BULL_JOB_ATTEMPTS', 5),
+        backoff: {
+          type: 'exponential',
+          delay: this.getNumber('BULL_JOB_BACKOFF_DELAY_MS', 5000),
+        },
+        timeout: this.getNumber('BULL_JOB_TIMEOUT_MS', 30 * 1000), // 默认30秒超时
+      },
+      settings: {
+        // 增强稳定性配置
+        maxStalledCount: 2, // 最大卡住重试次数
+        guardInterval: 5000, // 检查卡住任务间隔
+        retryProcessDelay: 1000, // 进程重启后的重试延迟
+      },
+      // 增加队列级限流配置
+      limiter: {
+        max: this.getNumber('BULL_MAX_CONCURRENT_JOBS', 100), // 最大并发任务数
+        duration: 1000, // 时间窗口
+      },
+    };
+  }
+
+  async cacheConfig() {
+    return {
+      isGlobal: true,
+      store: await redisStore({
+        ...this.ioRedisConfig,
+        ttl: this.getNumber('CACHE_TTL'),
+      }),
+    };
+  }
+
+  get pinoConfig(): Params {
+    const transport = this.isDev
+      ? {
+          target: 'pino-pretty',
+        }
+      : null;
+
+    return {
+      pinoHttp: {
+        genReqId: (req: any) => req.id,
+        transport,
+        level: this.isDev ? 'debug' : 'info',
+        customLogLevel: function (res) {
+          if (res.statusCode >= 500) return 'error';
+          if (res.statusCode >= 400) return 'warn';
+          return 'info';
+        },
+        wrapSerializers: true,
+        customProps: (req: any, res: any) => {
+          return {
+            env: this.nodeEnv,
+            appName: this.getString('NAME'),
+            user: req?.user,
+            'req.body': req?.body,
+            'res.body': res?.body,
+          };
+        },
+        redact: {
+          paths: ['req.headers.authorization', 'req.headers.apikey'],
+          remove: true,
+        },
+      },
+    };
+  }
+
+  get axiosProxyConfig(): AxiosProxyConfig | false {
+    if (!this.getBoolean('DIRECT_PROXY_ENABLED')) {
+      return false;
+    }
+    return {
+      host: this.getString('DIRECT_PROXY_HOST'),
+      port: this.getNumber('DIRECT_PROXY_PORT'),
+    };
+  }
+
+  private get(key: string, defaultValue?: any): string {
+    const value = this.configService.get<string>(key);
+
+    if (isNil(value)) {
+      if (defaultValue) {
+        return defaultValue;
+      }
+      throw new Error(`key:'${key}' - environment does not set`); // probably we should call process.exit() too to avoid locking the service
+    }
+
+    return value;
+  }
+}

package/src/shared/services/generator.service.ts

@@ -0,0 +1,13 @@
+import { Injectable } from '@nestjs/common';
+import { v1 as uuid } from 'uuid';
+
+@Injectable()
+export class GeneratorService {
+  public uuid(): string {
+    return uuid();
+  }
+
+  public fileName(ext: string): string {
+    return this.uuid() + '.' + ext;
+  }
+}

package/src/shared/services/index.ts

@@ -0,0 +1,4 @@
+export * from './api-config.service';
+export * from './generator.service';
+export * from './translation.service';
+export * from './validator.service';

package/src/shared/services/translation.service.ts

@@ -0,0 +1,59 @@
+import { Injectable } from '@nestjs/common';
+import { isArray, isString, map } from 'lodash';
+import type { TranslateOptions } from 'nestjs-i18n';
+import { I18nService } from 'nestjs-i18n';
+
+import { AbstractDto } from '../../common/dto/abstract.dto';
+import { STATIC_TRANSLATION_DECORATOR_KEY } from '../../decorators';
+import type { ITranslationDecoratorInterface } from '../../interfaces';
+import { ContextProvider } from '../../providers';
+
+@Injectable()
+export class TranslationService {
+  constructor(private readonly i18n: I18nService) {}
+
+  async translate(key: string, options?: TranslateOptions): Promise<string> {
+    return this.i18n.translate(`${key}`, {
+      ...options,
+      lang: ContextProvider.getLanguage(),
+    });
+  }
+
+  async translateNecessaryKeys<T extends AbstractDto>(dto: T): Promise<T> {
+    if (isString(dto)) {
+      return dto;
+    }
+    await Promise.all(
+      map(dto, async (value, key) => {
+        if (isString(value)) {
+          const translateDec: ITranslationDecoratorInterface | undefined =
+            Reflect.getMetadata(STATIC_TRANSLATION_DECORATOR_KEY, dto, key);
+
+          if (translateDec) {
+            return this.translate(
+              `${translateDec.translationKey ?? key}.${value}`,
+            );
+          }
+
+          return;
+        }
+
+        if (value instanceof AbstractDto) {
+          return this.translateNecessaryKeys(value);
+        }
+
+        if (isArray(value)) {
+          return Promise.all(
+            map(value, (v) => {
+              if (v instanceof AbstractDto) {
+                return this.translateNecessaryKeys(v);
+              }
+            }),
+          );
+        }
+      }),
+    );
+
+    return dto;
+  }
+}

package/src/shared/services/validator.service.ts

@@ -0,0 +1,10 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class ValidatorService {
+  public isImage(mimeType: string): boolean {
+    const imageMimeTypes = ['image/jpeg', 'image/png'];
+
+    return imageMimeTypes.includes(mimeType);
+  }
+}

package/src/validator-json/decorators.ts

@@ -0,0 +1,63 @@
+// tslint:disable:ban-types
+import {
+  ReferenceObject,
+  SchemaObject,
+} from '@nestjs/swagger/dist/interfaces/open-api-spec.interface';
+import 'reflect-metadata';
+
+import { IOptions } from './options';
+
+const SCHEMA_KEY = Symbol('class-validator-jsonschema:JSONSchema');
+
+/**
+ * Either a plain JSON Schema object that gets merged into the existing schema,
+ * or a function that receives as parameters the existing schema and global
+ * options, returning an updated schema.
+ */
+export type DecoratorSchema =
+  | ReferenceObject
+  | SchemaObject
+  | ((
+      source: SchemaObject,
+      options: IOptions,
+    ) => ReferenceObject | SchemaObject);
+
+/**
+ * Supplement class or property with additional JSON Schema keywords.
+ *
+ * @param schema JSON Schema object that is merged into the schema derived from
+ * class-validator decorators. In case of conflicts, keywords defined here
+ * overwrite the existing ones. Alternatively you can supply a function that
+ * receives as parameters the existing schema and global options, returning an
+ * updated schema.
+ */
+export function JSONSchema(schema: DecoratorSchema) {
+  return (target: object | Function, key?: string) => {
+    if (key) {
+      setMetadataSchema(schema, target.constructor, key); // Property metadata
+    } else {
+      setMetadataSchema(schema, target, (target as Function).name); // Class metadata
+    }
+  };
+}
+
+/**
+ * Get the JSON Schema stored in given target's metadata.
+ */
+export function getMetadataSchema(
+  target: object | Function,
+  key: string,
+): DecoratorSchema {
+  return Reflect.getMetadata(SCHEMA_KEY, target.constructor, key) || {};
+}
+
+/**
+ * Store given JSON Schema into target object's metadata.
+ */
+function setMetadataSchema(
+  value: DecoratorSchema,
+  target: object | Function,
+  key: string,
+) {
+  return Reflect.defineMetadata(SCHEMA_KEY, value, target, key);
+}