@nest-omni/core 1.0.57 → 2.0.1-0

package/src/providers/context.provider.ts

@@ -0,0 +1,109 @@
+import { ClsServiceManager } from 'nestjs-cls';
+import { IUser } from '../decorators/user.decorator';
+import { BadGatewayException } from '@nestjs/common';
+
+export class ContextProvider {
+  private static readonly nameSpace = 'request';
+
+  private static readonly authUserKey = 'user_key';
+
+  private static readonly routerKey = 'router_key';
+
+  private static readonly languageKey = 'language_key';
+
+  private static readonly requestKey = 'request_key';
+
+  static get<T>(key: string) {
+    const store = ClsServiceManager.getClsService();
+
+    return store.get<T>(ContextProvider.getKeyWithNamespace(key));
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static set(key: string, value: any): void {
+    const store = ClsServiceManager.getClsService();
+
+    store.set(ContextProvider.getKeyWithNamespace(key), value);
+  }
+
+  static getKeyWithNamespace(key: string): string {
+    return `${ContextProvider.nameSpace}.${key}`;
+  }
+
+  static setRouter(user: any): void {
+    ContextProvider.set(ContextProvider.routerKey, user);
+  }
+
+  static getCanLog(): boolean {
+    return ContextProvider.getRouter().canLog;
+  }
+
+  static getRouter(): {
+    action: { feature: string; action: string };
+    id: string;
+    method: object;
+    ip: string;
+    canLog: boolean;
+  } {
+    const value = ContextProvider.get(ContextProvider.routerKey);
+    if (value) {
+      // @ts-ignore
+      return value;
+    }
+    return {
+      action: { feature: '', action: '' },
+      id: '',
+      method: {},
+      ip: '',
+      canLog: false,
+    };
+  }
+
+  static setRequestId(id: string): void {
+    ContextProvider.set(ContextProvider.requestKey, id);
+  }
+
+  static getRequestId(): string {
+    return ContextProvider.get(ContextProvider.requestKey);
+  }
+
+  static setAuthUser(user: IUser): void {
+    ContextProvider.set(ContextProvider.authUserKey, user);
+  }
+
+  static setLanguage(language: string): void {
+    ContextProvider.set(ContextProvider.languageKey, language);
+  }
+
+  static getLanguage(): string {
+    return ContextProvider.get(ContextProvider.languageKey);
+  }
+
+  static getAuthUserField<T extends keyof IUser>(field?: T): IUser[T] {
+    return ContextProvider.getAuthUser()[field];
+  }
+
+  static getAuthUser(): IUser {
+    const auth = ContextProvider.get(ContextProvider.authUserKey) as IUser;
+    if (!auth) {
+      throw new BadGatewayException('User information not found.');
+    }
+    return auth;
+  }
+
+  static getAppId(): string {
+    return ContextProvider.getAuthUserField('appId');
+  }
+
+  static getRole(): string {
+    return ContextProvider.getAuthUserField('role');
+  }
+
+  static getAdmin(): boolean {
+    return ContextProvider.getAuthUserField('admin');
+  }
+
+  static getTenantId(): string {
+    return ContextProvider.getAuthUserField('tenantId');
+  }
+}

package/src/providers/generator.provider.ts

@@ -0,0 +1,66 @@
+import { v1 as uuid } from 'uuid';
+
+export class GeneratorProvider {
+  static uuid(): string {
+    return uuid();
+  }
+
+  static fileName(ext: string): string {
+    return GeneratorProvider.uuid() + '.' + ext;
+  }
+
+  static getS3PublicUrl(key: string): string {
+    if (!key) {
+      throw new TypeError('key is required');
+    }
+
+    return `https://s3.${process.env.AWS_S3_BUCKET_NAME_REGION}.amazonaws.com/${process.env.AWS_S3_BUCKET_NAME}/${key}`;
+  }
+
+  static getS3Key(publicUrl: string): string {
+    if (!publicUrl) {
+      throw new TypeError('key is required');
+    }
+
+    const exec = new RegExp(
+      `(?<=https://s3.${process.env.AWS_S3_BUCKET_NAME_REGION}.amazonaws.com/${process.env.AWS_S3_BUCKET_NAME}/).*`,
+    ).exec(publicUrl);
+
+    if (!exec) {
+      throw new TypeError('publicUrl is invalid');
+    }
+
+    return exec[0];
+  }
+
+  static generateVerificationCode(): string {
+    return Math.floor(1000 + Math.random() * 9000).toString();
+  }
+
+  static generatePassword(): string {
+    const lowercase = 'abcdefghijklmnopqrstuvwxyz';
+    const uppercase = lowercase.toUpperCase();
+    const numbers = '0123456789';
+
+    let text = '';
+
+    for (let i = 0; i < 12; i++) {
+      text += uppercase.charAt(Math.floor(Math.random() * uppercase.length));
+      text += lowercase.charAt(Math.floor(Math.random() * lowercase.length));
+      text += numbers.charAt(Math.floor(Math.random() * numbers.length));
+    }
+
+    return text;
+  }
+
+  /**
+   * generate random string
+   * @param length
+   */
+  static generateRandomString(length: number): string {
+    return Math.random()
+      .toString(36)
+      .replace(/[^\dA-Za-z]+/g, '')
+      .slice(0, Math.max(0, length));
+  }
+}

package/src/providers/index.ts

@@ -0,0 +1,2 @@
+export * from './context.provider';
+export * from './generator.provider';

package/src/setup/bootstrap.setup.ts

@@ -0,0 +1,254 @@
+import * as Sentry from '@sentry/nestjs';
+import { nodeProfilingIntegration } from '@sentry/profiling-node';
+import * as dotenv from 'dotenv';
+import { existsSync } from 'fs';
+import { join } from 'path';
+const possibleRootPaths = [process.cwd(), __dirname];
+const path0 = join(possibleRootPaths[0], 'config/base.env');
+const path1 = join(possibleRootPaths[1], 'config/base.env');
+if (existsSync(path0)) {
+  dotenv.config({ path: path0 });
+} else if (existsSync(path1)) {
+  dotenv.config({ path: path1 });
+} else {
+  throw new Error(`No valid base.env file: ${path0} or ${path1}`);
+}
+
+const requiredEnvVars = ['SENTRY_DSN', 'API_VERSION', 'NODE_ENV'];
+requiredEnvVars.forEach((envVar) => {
+  if (!process.env[envVar]) {
+    throw new Error(`Missing required environment variable: ${envVar}`);
+  }
+});
+Sentry.init({
+  dsn: process.env.SENTRY_DSN || '',
+  release: process.env.API_VERSION || '',
+  environment: process.env.NODE_ENV || 'unkown',
+  debug: process.env.NODE_ENV === 'dev',
+  tracesSampleRate: 1.0,
+  profileSessionSampleRate: 1.0,
+  profileLifecycle: 'trace',
+  sendDefaultPii: true,
+  integrations: [nodeProfilingIntegration],
+});
+import { CrudConfigService } from '@dataui/crud';
+
+CrudConfigService.load({
+  auth: {
+    property: 'user',
+  },
+  params: {
+    id: {
+      field: 'id',
+      type: 'string',
+      primary: true,
+    },
+  },
+  query: {
+    limit: 10,
+    alwaysPaginate: true,
+  },
+  routes: {
+    updateOneBase: {
+      allowParamsOverride: false,
+    },
+    deleteOneBase: {
+      returnDeleted: false,
+    },
+    createOneBase: {
+      returnShallow: false,
+    },
+  },
+});
+import { NestFactory, Reflector } from '@nestjs/core';
+import type { NestExpressApplication } from '@nestjs/platform-express';
+import { initializeTransactionalContext } from 'typeorm-transactional';
+import { Logger, LoggerErrorInterceptor } from 'nestjs-pino';
+import * as session from 'express-session';
+import * as bodyParse from 'body-parser';
+import {
+  ApiConfigService,
+  HttpExceptionFilter,
+  LanguageInterceptor,
+  OmniAuthMiddleware,
+  PowerByMiddleware,
+  QueryFailedFilter,
+  RequestIdMiddleware,
+  ServiceRegistryModule,
+  TranslationInterceptor,
+} from '../';
+import { HttpStatus } from '@nestjs/common';
+import { I18nValidationPipe } from 'nestjs-i18n';
+import { ClsMiddleware } from 'nestjs-cls';
+import { SentryGlobalFilter } from '@sentry/nestjs/setup';
+
+/* 优化点2：封装进程异常处理 */
+const setupProcessHandlers = (app: NestExpressApplication) => {
+  const logger = app.get(Logger);
+
+  process.on('uncaughtException', (error) => {
+    logger.fatal(
+      { error, stack: error.stack, pid: process.pid },
+      'Uncaught Exception',
+    );
+    process.exit(1);
+  });
+
+  process.on('unhandledRejection', (reason: Error, promise) => {
+    logger.error(
+      {
+        reason: {
+          message: reason.message,
+          stack: reason.stack,
+          name: reason.name,
+        },
+        promise,
+        pid: process.pid,
+      },
+      'Unhandled Rejection',
+    );
+  });
+
+  // 新增退出码监听
+  process.on('exit', (code) => {
+    logger.warn(`Process exiting with code ${code}`, {
+      uptime: process.uptime(),
+      memoryUsage: process.memoryUsage(),
+    });
+  });
+};
+
+/* 优化点3：优雅关闭封装 */
+const setupGracefulShutdown = (app: NestExpressApplication) => {
+  const logger = app.get(Logger);
+
+  const shutdown = async (signal: string) => {
+    try {
+      logger.warn(`Received ${signal}, starting graceful shutdown...`, {
+        uptime: process.uptime(),
+        connections: app.getHttpServer()?.address(),
+      });
+
+      // 增加关闭超时保护
+      await Promise.race([
+        app.close(),
+        new Promise((_, reject) =>
+          setTimeout(
+            () => reject(new Error('Shutdown timeout exceeded')),
+            15000,
+          ),
+        ),
+      ]);
+
+      logger.log('Application successfully closed', {
+        resourcesReleased: true,
+        pid: process.pid,
+      });
+      process.exit(0);
+    } catch (err) {
+      logger.error('Graceful shutdown failed', {
+        error: {
+          message: err.message,
+          stack: err.stack,
+          name: err.name,
+        },
+        critical: true,
+        pid: process.pid,
+      });
+      process.exit(1);
+    }
+  };
+
+  // 新增异常关闭信号监听
+  process.on('SIGQUIT', () => shutdown('SIGQUIT'));
+  process.on('SIGHUP', () => shutdown('SIGHUP'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  process.on('SIGINT', () => shutdown('SIGINT'));
+};
+
+export async function bootstrapSetup(AppModule, SetupSwagger) {
+  // 初始化配置
+  initializeTransactionalContext();
+
+  // 创建应用实例
+  const app = await NestFactory.create<NestExpressApplication>(AppModule, {
+    bufferLogs: true,
+  });
+
+  // 获取核心服务
+  const configService = app.select(ServiceRegistryModule).get(ApiConfigService);
+  const logger = app.get(Logger);
+
+  // 设置进程监控
+  setupProcessHandlers(app);
+  app.enableShutdownHooks();
+  setupGracefulShutdown(app);
+
+  // 基础配置
+  app.enableVersioning();
+  app.enable('trust proxy');
+
+  // 中间件配置
+  app.use(
+    bodyParse.json({ limit: '50mb' }),
+    new ClsMiddleware({}).use,
+    RequestIdMiddleware(),
+    PowerByMiddleware(),
+    OmniAuthMiddleware(),
+  );
+
+  // 全局过滤器
+  const reflector = app.get(Reflector);
+  app.useGlobalFilters(
+    new SentryGlobalFilter(),
+    new HttpExceptionFilter(),
+    new QueryFailedFilter(reflector),
+  );
+
+  // 全局拦截器
+  app.useGlobalInterceptors(
+    new LanguageInterceptor(),
+    new TranslationInterceptor(),
+    new LoggerErrorInterceptor(),
+  );
+
+  // 全局管道
+  app.useGlobalPipes(
+    new I18nValidationPipe({
+      whitelist: true,
+      errorHttpStatusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+      transform: true,
+      stopAtFirstError: true,
+      validationError: { target: false, value: false },
+    }),
+  );
+
+  // 可选功能模块
+  if (configService.documentationEnabled && SetupSwagger) {
+    SetupSwagger(app, configService.documentationPath);
+    logger.log(`Swagger docs available at ${configService.documentationPath}`);
+  }
+
+  if (configService.viewsEnabled) {
+    app.setBaseViewsDir(join(ApiConfigService.rootPath, 'views'));
+    app.setViewEngine('ejs');
+    logger.log('View engine initialized');
+  }
+
+  if (configService.sessionEnabled) {
+    app.use(session(configService.sessionConfig));
+    logger.log('Session middleware enabled');
+  }
+
+  if (configService.corsEnabled) {
+    app.enableCors(configService.corsConfig);
+    logger.log('CORS configuration applied');
+  }
+
+  // 启动服务
+  const port = configService.appConfig.port;
+  await app.listen(port);
+  logger.log(`Server running on ${await app.getUrl()}`);
+
+  return app;
+}

package/src/setup/index.ts

@@ -0,0 +1 @@
+export * from './bootstrap.setup';

package/src/shared/index.ts

@@ -0,0 +1,2 @@
+export * from './serviceRegistryModule';
+export * from './services';

package/src/shared/serviceRegistryModule.ts

@@ -0,0 +1,135 @@
+import * as path from 'path';
+import * as process from 'process';
+import { DataSource } from 'typeorm';
+import { BullModule } from '@nestjs/bull';
+import { LoggerModule } from 'nestjs-pino';
+import { ConfigModule } from '@nestjs/config';
+import type { Provider } from '@nestjs/common';
+import { Global, Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ScheduleModule } from '@nestjs/schedule';
+import { SentryModule } from '@sentry/nestjs/setup';
+import { CacheModule } from '@nestjs/cache-manager';
+import { addTransactionalDataSource } from 'typeorm-transactional';
+import { AcceptLanguageResolver, I18nModule, QueryResolver } from 'nestjs-i18n';
+import { HealthCheckerModule } from '../health-checker/health-checker.module';
+import {
+  ApiConfigService,
+  GeneratorService,
+  TranslationService,
+  ValidatorService,
+} from './services';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+const providers: Provider[] = [
+  ApiConfigService,
+  ValidatorService,
+  GeneratorService,
+  TranslationService,
+];
+
+const isTest = process.env.NODE_ENV === 'test';
+
+function findValidRootPath() {
+  const possibleRootPaths = [process.cwd(), __dirname];
+  const envFile = `${process.env.NODE_ENV || ''}.env`;
+  let envFilePath = '';
+
+  for (const rootPath of possibleRootPaths) {
+    const configPath = join(rootPath, 'config');
+    const baseEnvFilePath = join(configPath, 'base.env');
+
+    if (isTest) {
+      envFilePath = join(configPath, 'test.env');
+      if (existsSync(envFilePath)) {
+        return { rootPath, baseEnvFilePath, envFilePath };
+      } else {
+        envFilePath = join(configPath, 'dev.env');
+        if (existsSync(envFilePath)) {
+          return { rootPath, baseEnvFilePath, envFilePath };
+        }
+      }
+    } else {
+      envFilePath = join(configPath, envFile);
+      if (existsSync(envFilePath)) {
+        return { rootPath, baseEnvFilePath, envFilePath };
+      }
+    }
+  }
+
+  throw new Error(`No valid .env file: ${envFilePath}`);
+}
+
+const { envFilePath, rootPath, baseEnvFilePath } = findValidRootPath();
+ApiConfigService.rootPath = rootPath;
+
+const modules = [
+  ConfigModule.forRoot({
+    isGlobal: true,
+    cache: true,
+    expandVariables: false,
+    envFilePath: [envFilePath, baseEnvFilePath],
+  }),
+  SentryModule.forRoot(),
+  LoggerModule.forRootAsync({
+    inject: [ApiConfigService],
+    useFactory: (config: ApiConfigService) => config.pinoConfig,
+  }),
+  I18nModule.forRootAsync({
+    inject: [ApiConfigService],
+    useFactory: (config: ApiConfigService) => ({
+      fallbackLanguage: config.fallbackLanguage,
+      loaderOptions: {
+        path: path.join(ApiConfigService.rootPath, '/i18n/'),
+        watch: config.isDev,
+      },
+      logging: config.isDev,
+    }),
+    resolvers: [new QueryResolver(['lang']), AcceptLanguageResolver],
+  }),
+  HealthCheckerModule,
+];
+
+if (ApiConfigService.toBoolean(process.env.DB_ENABLED, true)) {
+  modules.push(
+    TypeOrmModule.forRootAsync({
+      inject: [ApiConfigService],
+      useFactory: (config: ApiConfigService) => config.typeormConfig,
+      dataSourceFactory: async (options) => {
+        return addTransactionalDataSource(new DataSource(options));
+      },
+    }),
+  );
+}
+
+if (ApiConfigService.toBoolean(process.env.BULL_ENABLED)) {
+  modules.push(
+    BullModule.forRootAsync({
+      inject: [ApiConfigService],
+      useFactory: (config: ApiConfigService) => config.bullConfig,
+    }),
+  );
+}
+
+if (ApiConfigService.toBoolean(process.env.CACHE_ENABLED)) {
+  modules.push(
+    CacheModule.registerAsync({
+      inject: [ApiConfigService],
+      isGlobal: true,
+      useFactory: (config: ApiConfigService) => config.cacheConfig(),
+    }),
+  );
+}
+
+if (ApiConfigService.toBoolean(process.env.SCHEDULE_ENABLED)) {
+  modules.push(ScheduleModule.forRoot());
+}
+
+@Global()
+@Module({
+  providers,
+  imports: modules,
+  exports: [...providers],
+})
+export class ServiceRegistryModule {}