汇总

NestJS 本身提供了一组核心模块，这些模块为开发者提供了构建应用程序所需的基本功能。然而，具体内置了多少模块并没有一个确切的数量。NestJS 框架的核心特性是其模块化架构，它允许用户创建自定义模块，并且框架也提供了一些官方支持的模块来帮助处理常见的任务。

以下是一些 NestJS 内置或官方推荐使用的模块：

1. @nestjs/common - 提供了所有应用程序所需的通用功能，如控制器、服务（提供者）、管道、守卫、异常过滤器等。
2. @nestjs/core - 核心模块，包含了启动应用程序所必需的服务和逻辑。
3. @nestjs/config - 用于加载和管理配置文件。
4. @nestjs/microservices - 使构建微服务变得容易。
5. @nestjs/websockets - 支持 WebSocket 连接。
6. @nestjs/axios - 提供了一个基于 Axios 的 HTTP 客户端模块。
7. @nestjs/jwt - JSON Web Token 认证的支持。
8. @nestjs/passport - Passport.js 的集成，用于认证策略。
9. @nestjs/graphql - GraphQL API 的支持。
10. @nestjs/swagger - 自动生成 Swagger/OpenAPI 文档。
11. @nestjs/typeorm, @nestjs/sequelize, @nestjs/mongoose - 数据库 ORM 集成。
12. @nestjs/platform-express 或 @nestjs/platform-fastify - 平台适配器，用于与 Express 或 Fastify 服务器集成。
13. @nestjs-modules/mailer - 提供了一个简单易用的模块，用于发送电子邮件。它支持多种邮件服务提供商，并且可以轻松配置模板引擎来构建复杂的邮件内容。
14. @nestjs/cache-manager - 该模块为 NestJS 应用集成了缓存管理功能，支持多种缓存存储方式如内存、文件系统、Redis 等，以提高应用性能和响应速度。
15. @nestjs/bull - Bull 是一个基于 Redis 的任务队列库，此模块允许你将异步任务加入队列中，以便在后台处理。它对于执行耗时操作或需要确保任务完成顺序的任务非常有用。
16. @nestjs/schedule - 提供了调度任务的能力，使得开发者可以在特定时间点或者按照一定的时间间隔执行代码块，比如定时清理过期数据或生成报告等。
17. @nestjs/throttler - 这个模块实现了速率限制器的功能，可以防止 API 被滥用，通过限制客户端请求频率来保护服务器资源免受过多请求的影响。
18. @nestjs/schematics - 包含了一系列的命令行工具和脚手架，可以帮助开发者快速创建和组织 NestJS 项目结构，提升开发效率。
19. @nestjs/terminus - 用于监控和健康检查你的 NestJS 应用程序。它可以设置多个健康指标并提供 HTTP 端点来查询应用的状态。
20. @nestjs/event-emitter - 集成了事件发射器模式到 NestJS 中，使得应用内部组件之间可以通过事件进行通信，简化了复杂业务逻辑的实现。
21. @nestjs/cli - 官方提供的命令行界面工具，用于生成新项目、模块、服务、控制器和其他 NestJS 组件。CLI 工具还提供了其他实用的功能，如迁移和测试。
22. @nestjs/testing - 提供了一套辅助函数和工具类，用于编写单元测试和集成测试，有助于确保应用程序的稳定性和可靠性。
23. …

此外，还有许多其他的社区贡献模块，它们不是严格意义上的“内置”，但被广泛使用并且得到了官方的认可和支持。

需要注意的是，上述列表并不是静态的；随着时间的发展，新的模块可能会被添加进来，而旧的模块也可能得到更新或重构。因此，最好的做法是查阅最新的 NestJS 官方文档 来获取最准确的信息。

@nestjs/common

@nestjs/common 是 NestJS 框架的核心模块之一，提供了构建应用程序所需的通用工具和装饰器。它是每个 NestJS 项目的基础依赖项，包含了一系列的特性，帮助开发者更容易地创建结构化、可测试和可扩展的应用程序。

主要功能

1. 装饰器 (Decorators): @nestjs/common 提供了多种内置装饰器，用于定义控制器、服务（提供者）、中间件、异常过滤器等组件之间的依赖关系和行为。例如：

   • @Controller()：用于标记类为控制器。
   • @Injectable()：用于标记服务或提供者类，使其可以被依赖注入。
   • @Get(), @Post(), 等 HTTP 方法装饰器：用于定义路由处理程序。

2. 依赖注入: 支持基于构造函数、属性和方法的依赖注入模式，简化了组件间的协作，并提高了代码的可测试性。

3. 管道 (Pipes): 用来验证和转换请求数据。Nest 内置了一些常用的管道，如 ValidationPipe，它可以帮助你快速实现 DTO（数据传输对象）验证。

4. 守卫 (Guards): 用于保护路由或控制器，可以根据特定条件决定是否允许请求继续执行。比如，AuthGuard 可以用来实施认证逻辑。

5. 拦截器 (Interceptors): 允许你在请求到达目标处理器之前或之后执行某些操作，常用于日志记录、性能监控等功能。

6. 异常过滤器 (Exception Filters): 用于捕获并处理未预期的错误，确保应用能够优雅地响应异常情况。

7. 工厂和异步配置: 支持使用工厂函数来异步创建提供者实例，这对于需要在启动时加载配置文件或其他资源非常有用。

8. 其他工具: 包含了诸如 HttpService（HTTP 客户端）、StreamableFile（流式文件响应）等实用工具。

安装

@nestjs/common 通常会随 Nest CLI 创建新项目时自动安装。如果你需要单独添加这个包到现有项目中，可以通过 npm 或 yarn 安装：

npm install @nestjs/common

或者

yarn add @nestjs/common

使用示例

这里有一个简单的例子展示了如何使用 @nestjs/common 中的一些核心概念：

import { Controller, Get, Injectable } from '@nestjs/common';

// 使用 @Injectable 装饰器标记服务类
@Injectable()
export class AppService {
  getHello(): string {
    return 'Hello World!';
  }
}

// 使用 @Controller 装饰器标记控制器类
@Controller('app')
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get() // 使用 HTTP 方法装饰器定义路由处理程序
  getHello(): string {
    return this.appService.getHello();
  }
}

通过 @nestjs/common，你可以轻松地构建出符合 SOLID 原则的应用程序架构，同时利用其提供的丰富功能来加速开发过程。

@nestjs/core

@nestjs/core 是 NestJS 框架的核心模块，提供了框架的基本功能和基础设施。它是每个 NestJS 应用程序的基础，包含了启动应用程序所需的关键组件和服务。通过 @nestjs/core，开发者可以创建模块、控制器、服务（提供者）、中间件等，并管理它们之间的依赖关系。

主要特性

1. 模块系统 (Modules):

   • 支持基于模块的应用程序结构，有助于将代码划分为逻辑单元。
   • 模块是围绕特定业务能力组织的一组相关的控制器、服务和其他类。
   • 通过模块化设计，应用变得更容易维护和扩展。

2. 依赖注入 (Dependency Injection):

   • 内置了强大的依赖注入容器，简化了组件间的协作。
   • 开发者可以通过构造函数、属性或方法参数注入依赖项。
   • 这不仅提高了代码的可测试性，还促进了松耦合的设计模式。

3. 中间件 (Middleware):

   • 允许你定义在请求到达路由处理程序之前执行的函数。
   • 可用于日志记录、身份验证、解析请求体等多种用途。
   • 中间件可以是全局性的，也可以仅应用于特定的路由或模块。

4. 异常过滤器 (Exception Filters):

   • 提供了一种捕获并处理未预期错误的方式，确保应用程序能够优雅地响应异常情况。
   • 可以全局注册，也可以针对特定控制器或路由。

5. 守卫 (Guards):

   • 用来保护路由或控制器，可以根据特定条件决定是否允许请求继续执行。
   • 常见的例子包括认证守卫，如 AuthGuard。

6. 管道 (Pipes):

   • 用于验证和转换请求数据，确保传入的数据符合预期格式。
   • 内置支持诸如 ValidationPipe 等常用管道，便于快速实现 DTO（数据传输对象）验证。

7. 拦截器 (Interceptors):

   • 允许你在请求到达目标处理器之前或之后执行某些操作。
   • 例如，用于日志记录、性能监控等功能。

8. 动态模块:

   • 支持创建动态模块，这些模块可以在运行时根据配置进行调整。
   • 动态模块通常用于需要异步初始化的服务，比如数据库连接池。

9. 异步配置:

   • 支持使用工厂函数来异步创建提供者实例，这对于需要在启动时加载配置文件或其他资源非常有用。

10. 事件调度器 (Event Emitter):

    • 内置了一个简单的事件调度系统，允许发布/订阅风格的消息传递。
    • 适用于需要解耦组件之间通信的应用场景。

安装

当你使用 Nest CLI 创建一个新的 NestJS 项目时，@nestjs/core 会自动被安装为依赖项。如果你需要单独添加这个包到现有项目中，可以通过 npm 或 yarn 安装：

npm install @nestjs/core

或者

yarn add @nestjs/core

使用示例

以下是一个简单的例子，展示了如何利用 @nestjs/core 的一些核心概念构建一个基本的应用程序：

import { Module } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  imports: [], // 导入其他模块
  controllers: [AppController], // 注册控制器
  providers: [AppService], // 注册服务（提供者）
})
export class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000); // 启动应用并监听端口
}
bootstrap();

在这个例子中，我们定义了一个模块 (AppModule)，它导入了必要的依赖，声明了控制器和服务。然后，我们使用 NestFactory.create() 方法创建应用程序实例，并通过 app.listen() 启动 HTTP 服务器。

@nestjs/core 为构建高效、可扩展且易于维护的 Node.js 应用程序提供了坚实的基础。

@nestjs/config

@nestjs/config 是 NestJS 框架中的一个模块，它提供了一种简单的方法来管理应用程序的配置。使用这个模块，开发者可以轻松地将环境变量、JSON 文件、YAML 文件等配置源集成到他们的 NestJS 应用中，并且可以在整个应用中方便地访问这些配置。

要使用 @nestjs/config，你需要按照以下步骤进行操作：

1. 安装包：
   首先需要安装 @nestjs/config 包。你可以通过 npm 或 yarn 来安装它。

   npm install @nestjs/config

   或者

   yarn add @nestjs/config

2. 导入 ConfigModule：
   在你的应用程序的根模块（通常是 AppModule）中导入 ConfigModule。

   import { Module } from '@nestjs/common';
   import { ConfigModule } from '@nestjs/config';
   
   @Module({
     imports: [ConfigModule.forRoot()],
   })
   export class AppModule {}

   你可以通过传递选项给 forRoot() 方法来自定义 ConfigModule 的行为，例如加载特定的文件或设置是否应该缓存配置。

3. 使用配置服务：
   现在你可以在你的服务、控制器或其他地方注入 ConfigService 来获取配置值。

   import { Injectable } from '@nestjs/common';
   import { ConfigService } from '@nestjs/config';
   
   @Injectable()
   export class AppService {
     constructor(private readonly configService: ConfigService) {}
   
     getPort(): string {
       return this.configService.get<string>('PORT') || '3000';
     }
   }

4. 加载环境变量：
   @nestjs/config 默认会从环境变量和 .env 文件中加载配置。你可以创建一个 .env 文件来存放你的环境变量，然后在启动应用时确保这些变量被正确加载。

   PORT=3000
   DATABASE_URL=your-database-url

5. 验证配置：
   如果你需要确保某些配置项存在或符合一定的规则，你可以使用内置的验证功能或者结合其他验证库如 class-validator 和 class-transformer 来实现。

请记住，在生产环境中，你应该避免将敏感信息硬编码在代码中，而是利用环境变量或者其他安全的方式来管理配置。此外，确保你的 .env 文件不会被提交到版本控制系统中（可以通过 .gitignore 文件来排除）。

@nestjs/microservices

@nestjs/microservices 是 NestJS 框架提供的一个模块，用于构建微服务架构的应用程序。它使得开发人员可以轻松创建基于消息的微服务，并且支持多种传输层协议，如 gRPC、Redis、NATS、RabbitMQ、Kafka 等等。

以下是使用 @nestjs/microservices 的一些关键步骤和概念：

安装

首先，你需要安装 @nestjs/microservices 包以及你打算使用的传输层相关的客户端库（例如，如果你要使用 Redis 作为传输层，则需要安装相应的 Redis 客户端库）。

npm install @nestjs/microservices

或者

yarn add @nestjs/microservices

创建微服务

你可以通过以下方式创建一个简单的微服务：

1. 定义 MicroserviceOptions：这包含了你所选择的传输层协议及其配置。
2. **使用 NestFactory.createMicroservice()**：来创建一个新的微服务实例。

例如，使用 TCP 协议创建一个微服务：

import { NestFactory } from '@nestjs/core';
import { Transport, MicroserviceOptions } from '@nestjs/microservices';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
    AppModule,
    {
      transport: Transport.TCP,
      options: {
        host: 'localhost',
        port: 3000,
      },
    },
  );
  await app.listen(() => console.log('Microservice is listening'));
}
bootstrap();

处理消息

为了处理传入的消息，你需要在你的服务中定义处理器方法。这些方法可以通过装饰器来标记，如 @MessagePattern() 或 @EventPattern()，具体取决于你使用的传输层协议。

import { Controller } from '@nestjs/common';
import { MessagePattern, Payload } from '@nestjs/microservices';

@Controller()
export class AppController {
  @MessagePattern('sum')
  getSum(@Payload() data: number[]): number {
    return data.reduce((a, b) => a + b, 0);
  }
}

发送消息

如果你想从另一个微服务或应用发送消息到这个微服务，你可以使用 ClientProxy 类的一个实例。你可以通过 @Inject() 装饰器注入它，并使用 send() 或 emit() 方法来发送消息。

import { Injectable, Inject } from '@nestjs/common';
import { ClientProxy } from '@nestjs/microservices';

@Injectable()
export class AppService {
  constructor(
    @Inject('MATH_SERVICE') private client: ClientProxy,
  ) {}

  async getSum(a: number, b: number): Promise<number> {
    return this.client.send<number>({ cmd: 'sum' }, [a, b]).toPromise();
  }
}

配置选项

不同的传输层有不同的配置选项，比如对于 Kafka，你可能需要指定主题名称、消费者组等；对于 gRPC，你可能需要指定 proto 文件路径和服务名称等。

请根据你选择的具体传输层协议查阅官方文档以获取更详细的配置信息。

迁移现有应用程序

如果你已经有一个 NestJS 应用并且想要将其迁移到微服务架构，你可以逐步地将某些功能拆分出去，形成独立的服务，同时保持其他部分为 RESTful API 或者 GraphQL API。

@nestjs/websockets

@nestjs/websockets 是 NestJS 框架的一个模块，它使得在 NestJS 应用中集成 WebSocket 功能变得非常简单。NestJS 本身是一个用于构建高效、可扩展的服务器端应用程序的框架，它基于 Node.js 和 Express（也可以与其他 HTTP 服务器兼容）。通过 @nestjs/websockets，你可以快速搭建 WebSocket 服务，并利用 NestJS 的依赖注入、中间件等特性。

安装

首先确保你已经安装了 NestJS CLI 并创建了一个新的 NestJS 项目：

npm install -g @nestjs/cli
nest new my-websocket-app
cd my-websocket-app

然后安装必要的依赖项：

npm install @nestjs/websockets @nestjs/platform-socket.io socket.io

基本配置

编辑 src/main.ts 文件以配置 Socket.IO 适配器：

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { IoAdapter } from '@nestjs/platform-socket.io';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useWebSocketAdapter(new IoAdapter(app));
  await app.listen(3000);
}
bootstrap();

创建 WebSocket Gateway

接下来，在你的应用中创建一个 WebSocket Gateway。Gateways 是处理 WebSocket 连接和事件的核心组件。

使用 CLI 创建一个新的网关：

nest generate gateway events

这将生成一个名为 events.gateway.ts 的文件。你可以在这个文件中定义如何处理连接、断开以及接收的消息。

import { WebSocketGateway, WebSocketServer, SubscribeMessage, MessageBody } from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';

@WebSocketGateway()
export class EventsGateway {
  @WebSocketServer() server: Server;

  @SubscribeMessage('events')
  handleEvent(@MessageBody() data: any): void {
    this.server.emit('event-response', `Service received: ${data}`);
  }
}

使用命名空间和房间

NestJS 的 @nestjs/websockets 模块同样支持命名空间和房间的概念，允许你更细粒度地控制消息广播范围。

命名空间

可以通过设置 path 属性来为网关指定命名空间：

@WebSocketGateway({
  path: '/custom-namespace',
})
export class CustomNamespaceGateway {
  // ...
}

房间

在网关方法内部，你可以使用 Socket 对象的方法来管理用户加入或离开房间：

@SubscribeMessage('join-room')
handleJoinRoom(client: Socket, room: string): void {
  client.join(room);
}

@SubscribeMessage('leave-room')
handleLeaveRoom(client: Socket, room: string): void {
  client.leave(room);
}

@SubscribeMessage('room-message')
handleRoomMessage(client: Socket, payload: { room: string; message: string }): void {
  this.server.to(payload.room).emit('room-message', payload.message);
}

认证与授权

为了保护 WebSocket 端点，你可以添加守卫（Guards）来进行认证检查。例如，结合 JWT 进行身份验证：

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { WsException } from '@nestjs/websockets';
import { JwtService } from '@nestjs/jwt';

@Injectable()
export class WsJwtGuard implements CanActivate {
  constructor(private jwtService: JwtService) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    const client = context.switchToWs().getClient<Socket>();
    const token = client.handshake.auth.token;
    
    try {
      const decoded = this.jwtService.verify(token);
      return true;
    } catch {
      throw new WsException('未授权');
    }
  }
}

然后在网关中应用这个守卫：

@UseGuards(WsJwtGuard)
@SubscribeMessage('secure-event')
handleSecureEvent(@MessageBody() data: any): void {
  // 只有经过验证的客户端可以触发此事件
}

错误处理

对于全局错误处理，你可以实现一个异常过滤器：

import { ArgumentsHost, Catch, ExceptionFilter, WsException } from '@nestjs/common';
import { Socket } from 'socket.io';

@Catch(WsException)
export class WsExceptionsFilter implements ExceptionFilter {
  catch(exception: WsException, host: ArgumentsHost) {
    const ctx = host.switchToWs();
    const client: Socket = ctx.getClient();
    const data = ctx.getData();

    client.emit('error', exception.message);
  }
}

并将其应用于整个应用程序：

const app = await NestFactory.create(AppModule);
app.useGlobalFilters(new WsExceptionsFilter());

性能优化与集群支持

当需要处理大量并发连接时，考虑使用 Redis 或其他适配器来实现水平扩展。@nestjs/websockets 支持多种适配器，如 RedisIoAdapter。

import { RedisIoAdapter } from '@nestjs/platform-socket.io';
import * as redis from 'redis';

// 在 main.ts 中配置
app.useWebSocketAdapter(new RedisIoAdapter(app, [
  redis.createClient({ url: 'redis://localhost:6379' }),
  redis.createClient({ url: 'redis://localhost:6379' }),
]));

监控与日志记录

最后，不要忘记设置适当的监控和日志系统来追踪 WebSocket 服务器的状态和性能。

通过上述步骤，你应该能够在 NestJS 应用中成功集成 WebSocket 功能，并充分利用其提供的各种高级特性和最佳实践。根据具体需求，你可以进一步调整和完善这些功能。

@nestjs/axios

@nestjs/axios 是一个 NestJS 模块，它集成了 Axios HTTP 客户端库，为开发者提供了一种方便的方式来在 NestJS 应用中发起 HTTP 请求。Axios 本身是一个流行的 JavaScript 库，用于执行 HTTP 请求，并且它支持 Promise API 和拦截器功能。

使用 @nestjs/axios 可以让你更轻松地管理 HTTP 请求和响应，尤其是在微服务架构或需要与外部 API 进行交互的情况下。下面是如何使用这个模块的基本步骤：

安装

首先，你需要安装 @nestjs/axios 包以及 axios 本身（如果尚未安装）。

npm install @nestjs/axios axios

或者使用 yarn:

yarn add @nestjs/axios axios

配置

接下来，在你的应用程序的根模块（通常是 AppModule）中导入 HttpModule。HttpModule 提供了 HttpService，它是 Axios 的包装器，可以用来发送 HTTP 请求。

import { Module } from '@nestjs/common';
import { HttpModule } from '@nestjs/axios';
import { AppController } from './app.controller';

@Module({
  imports: [HttpModule],
  controllers: [AppController],
})
export class AppModule {}

你可以通过向 HttpModule.register() 方法传递配置选项来自定义 Axios 的行为，例如设置默认的基础 URL、超时时间等。

HttpModule.register({
  baseURL: 'https://api.example.com',
  timeout: 5000,
})

使用 HttpService

现在你可以在你的服务、控制器或其他地方注入 HttpService 来发起 HTTP 请求。

import { Injectable, HttpService } from '@nestjs/common';
import { firstValueFrom } from 'rxjs';

@Injectable()
export class AppService {
  constructor(private readonly httpService: HttpService) {}

  async getExternalData() {
    const response = await firstValueFrom(
      this.httpService.get('/data')
    );
    return response.data;
  }
}

注意：由于 Axios 返回的是 RxJS 的 Observable 对象，因此你可能需要用 firstValueFrom 或者 lastValueFrom（根据版本不同）将其转换为 Promise，以便更容易地处理异步操作。

自定义 Axios 实例

如果你有特殊的 Axios 配置需求，也可以创建自定义的 Axios 实例并注入到你的服务中。

import { Injectable } from '@nestjs/common';
import axios from 'axios';

@Injectable()
export class CustomHttpService {
  private readonly httpClient = axios.create({
    baseURL: 'https://api.example.com',
    timeout: 5000,
  });

  async getCustomData() {
    const response = await this.httpClient.get('/custom-data');
    return response.data;
  }
}

然后你可以将 CustomHttpService 注入到任何需要的地方。

拦截器

@nestjs/axios 支持 Axios 的拦截器功能，允许你在请求发出之前或响应到达之后进行一些预处理工作，比如添加认证头信息、日志记录等。

import { HttpModule, HttpService } from '@nestjs/axios';
import { Injectable, OnModuleInit } from '@nestjs/common';

@Injectable()
export class AppService implements OnModuleInit {
  constructor(private readonly httpService: HttpService) {}

  onModuleInit() {
    this.httpService.axiosRef.interceptors.request.use((config) => {
      // 在这里添加拦截逻辑
      config.headers['Authorization'] = 'Bearer YOUR_TOKEN';
      return config;
    });
  }
}

@nestjs/jwt，@nestjs/passport

@nestjs/jwt 是 NestJS 框架提供的一个模块，它为开发者提供了处理 JSON Web Token (JWT) 的便利方式。JWT 是一种开放标准 (RFC 7519)，用于在网络应用环境之间安全地传输信息。通过数字签名，JWT 可以验证和信任消息的来源。

使用 @nestjs/jwt 模块，你可以轻松地在你的 NestJS 应用中集成 JWT 验证机制，保护你的 API 端点，并实现用户认证和授权功能。

以下是使用 @nestjs/jwt 的基本步骤：

安装依赖

首先，你需要安装 @nestjs/jwt 和 @types/jsonwebtoken（如果你使用 TypeScript）：

npm install @nestjs/jwt jsonwebtoken
npm install --save-dev @types/jsonwebtoken

设置 JwtModule

然后，在你的应用程序中配置 JwtModule。你可以在全局范围内或仅在特定模块中导入这个模块。这里是一个简单的例子，展示了如何在根模块 (AppModule) 中设置它：

import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { JwtStrategy } from './jwt.strategy'; // 自定义策略文件
import { AuthService } from './auth.service';

@Module({
  imports: [
    PassportModule,
    JwtModule.register({
      secret: 'your-secret-key', // 使用 .env 文件中的值或环境变量来代替硬编码的秘密密钥
      signOptions: { expiresIn: '60s' }, // 设置过期时间
    }),
  ],
  providers: [AuthService, JwtStrategy],
})
export class AppModule {}

创建自定义策略

为了使用 JWT 进行身份验证，你通常还需要创建一个策略类（例如 JwtStrategy），它将告诉 NestJS 如何解析和验证传入的 JWT。这通常涉及到从请求头中提取 token，并使用 jsonwebtoken 库对其进行验证。

import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: 'your-secret-key',
    });
  }

  async validate(payload: any) {
    return { userId: payload.sub, username: payload.username };
  }
}

使用 Guard 保护路由

最后，你可以使用 @UseGuards 装饰器与 AuthGuard('jwt') 来保护特定的路由控制器或方法，确保只有携带有效 JWT 的请求才能访问这些端点。

import { Controller, Get, UseGuards } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Controller('profile')
export class ProfileController {
  @UseGuards(AuthGuard('jwt'))
  @Get()
  getProfile(@Req() req) {
    return req.user;
  }
}

@nestjs/graphql

@nestjs/graphql 是 NestJS 框架提供的一个模块，它简化了在应用程序中集成 GraphQL 的过程。通过这个模块，你可以轻松地创建基于 GraphQL 的 API，并利用其强大的类型系统、查询和变更（mutation）功能。

以下是关于如何使用 @nestjs/graphql 创建 GraphQL API 的一些关键步骤：

安装

首先，你需要安装 @nestjs/graphql 包以及与 GraphQL 相关的依赖项。

npm install @nestjs/graphql graphql apollo-server-express

或者使用 yarn:

yarn add @nestjs/graphql graphql apollo-server-express

apollo-server-express 是 Apollo Server 的 Express 集成包，它允许你在 Express 应用程序中运行 GraphQL 服务器。

配置

接下来，在你的应用程序的根模块（通常是 AppModule）中导入 GraphQLModule 并配置它。

import { Module } from '@nestjs/common';
import { GraphQLModule } from '@nestjs/graphql';
import { join } from 'path';

@Module({
  imports: [
    GraphQLModule.forRoot({
      autoSchemaFile: join(process.cwd(), 'src/schema.gql'),
      // 或者直接定义 schema:
      // typeDefs: gql`
      //   type Query {
      //     hello: String
      //   }
      // `,
      // resolvers: { ... },
    }),
  ],
})
export class AppModule {}

• autoSchemaFile: 自动从文件生成 Schema。你也可以直接在代码中定义 typeDefs 和 resolvers。
• 其他配置选项还包括设置 playground、调试模式等。

定义 Resolvers

然后，你需要定义解析器 (Resolvers)，它们是处理来自客户端请求的函数。每个解析器对应于 GraphQL 模式中的字段。

import { Resolver, Query, Mutation, Args } from '@nestjs/graphql';
import { CreateBookInput } from './dto/create-book.input';
import { Book } from './models/book.model';

@Resolver(() => Book)
export class BooksResolver {
  private books: Book[] = [];

  @Query(() => [Book])
  async books() {
    return this.books;
  }

  @Mutation(() => Book)
  async createBook(@Args('data') data: CreateBookInput) {
    const book = { id: Math.random().toString(36).substr(2, 9), ...data };
    this.books.push(book);
    return book;
  }
}

• @Resolver(() => Book)：指定此解析器处理 Book 类型的查询和变更。
• @Query() 和 @Mutation() 装饰器用于定义查询和变更方法。
• @Args() 装饰器用于获取传递给变更或查询的参数。

定义 Models 和 Inputs

为了确保类型安全，你应该为输入数据和返回的数据定义模型类或输入类。

// models/book.model.ts
import { Field, ObjectType } from '@nestjs/graphql';

@ObjectType()
export class Book {
  @Field()
  id: string;

  @Field()
  title: string;

  @Field()
  author: string;
}

// dto/create-book.input.ts
import { InputType, Field } from '@nestjs/graphql';

@InputType()
export class CreateBookInput {
  @Field()
  title: string;

  @Field()
  author: string;
}

启动应用

完成上述步骤后，启动你的 NestJS 应用，现在你应该能够访问 GraphQL Playground 来测试你的 API 了。

进阶功能

@nestjs/graphql 还支持诸如订阅（Subscriptions）、联合（Federation）、上下文（Context）、中间件（Middleware）等高级特性，这使得它可以适应更复杂的应用需求。

@nestjs/swagger

@nestjs/swagger 是一个用于在基于 NestJS 框架构建的应用程序中集成 Swagger（OpenAPI 规范）的包。它可以帮助开发者自动生成 API 文档，并提供一个交互式的 API 测试界面，使得开发和调试 API 更加方便。

使用 @nestjs/swagger 通常涉及以下几个步骤：

1. 安装依赖：你需要通过 npm 或 yarn 安装 @nestjs/swagger 和 swagger-ui-express 包。

   npm install @nestjs/swagger swagger-ui-express

2. 配置模块：在你的 NestJS 应用中，你需要设置 SwaggerModule 并创建一个 Swagger 文档对象。

   import { Module } from '@nestjs/common';
   import { APP_GUARD } from '@nestjs/core';
   import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
   
   @Module({
     imports: [
       // ... 其他模块
     ],
     providers: [
       // ... 提供者
     ]
   })
   export class AppModule {
     constructor(private readonly app: NestApplication) {}
   
     async onModuleInit() {
       const config = new DocumentBuilder()
         .setTitle('API Title')
         .setDescription('API description')
         .setVersion('1.0')
         .addTag('tag')
         .build();
       const document = SwaggerModule.createDocument(this.app, config);
       SwaggerModule.setup('api', this.app, document);
     }
   }

3. 装饰器描述：你可以在控制器和服务中使用各种装饰器来描述 API 的行为、参数、响应等信息。例如 @ApiTags, @ApiOperation, @ApiResponse 等。

4. 启动应用：当你启动 NestJS 应用后，Swagger UI 将会在你设定的路径下可用（如上面例子中的 /api），你可以在这个界面上查看并测试你的 API。

5. 文档导出：如果你想要导出 OpenAPI JSON 或 YAML 文件，你可以使用 SwaggerModule.createDocument 方法生成文档并保存到文件系统中。

确保你阅读了官方文档或相关指南，因为随着版本更新可能会有一些新的特性和变化。此外，NestJS 社区和 GitHub 上也有丰富的资源可以帮助解决问题。

@nestjs/typeorm

@nestjs/typeorm 是 NestJS 框架提供的一个模块，它集成了 TypeORM，这是一个功能丰富的对象关系映射（ORM）库，支持多种数据库如 MySQL、PostgreSQL、MariaDB、SQLite、MSSQL 和 MongoDB 等。通过 @nestjs/typeorm，你可以方便地在 NestJS 应用中进行数据库交互，并利用 TypeORM 提供的丰富功能，例如实体管理、查询构建器、事务处理等。

主要特性

• 实体定义：使用 TypeScript 类来定义数据库表结构。
• 数据访问：通过 Repository 或 Custom Repository 模式执行 CRUD 操作。
• 连接管理：配置和管理数据库连接。
• 迁移工具：创建和运行数据库迁移脚本以安全地更新数据库模式。
• 事件监听：监听实体生命周期事件，如插入、更新或删除。
• 事务支持：确保一系列操作要么全部成功，要么全部失败，保持数据一致性。
• 查询构建器：构建复杂的 SQL 查询而无需直接编写 SQL 语句。

安装与配置

1. 安装依赖

首先，你需要安装 @nestjs/typeorm 包以及 TypeORM 和你打算使用的数据库驱动程序。例如，对于 MySQL 数据库：

npm install @nestjs/typeorm typeorm mysql2 reflect-metadata

或者使用 yarn:

yarn add @nestjs/typeorm typeorm mysql2 reflect-metadata

确保你也安装了 reflect-metadata，因为 TypeORM 需要它来实现装饰器功能。

2. 配置 TypeORM

在应用程序的根模块（通常是 AppModule）中导入 TypeOrmModule 并配置它。你可以直接在代码中定义连接选项，也可以从外部配置文件加载这些选项。

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'mysql',
      host: 'localhost',
      port: 3306,
      username: 'root',
      password: 'password',
      database: 'test',
      entities: [__dirname + '/**/*.entity{.ts,.js}'],
      synchronize: true, // 注意：在生产环境中不要启用此选项
    }),
  ],
})
export class AppModule {}

3. 创建实体

然后，你需要创建实体类来表示数据库中的表。每个实体类对应于数据库中的一个表。

import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column()
  email: string;
}

4. 使用 Repository

为了对实体执行 CRUD 操作，你可以使用 TypeORM 的 Repository 模式。NestJS 提供了一种简单的方式来将 Repository 注入到服务中。

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';

@Injectable()
export class UsersService {
  constructor(
    @InjectRepository(User)
    private usersRepository: Repository<User>,
  ) {}

  findAll(): Promise<User[]> {
    return this.usersRepository.find();
  }

  findOne(id: number): Promise<User> {
    return this.usersRepository.findOneBy({ id });
  }

  async remove(id: number): Promise<void> {
    await this.usersRepository.delete(id);
  }
}

进阶功能

@nestjs/typeorm 支持许多进阶功能，比如事务管理、事件监听、自定义查询构建器等，以满足更复杂的应用需求。

• 事务管理：确保一组数据库操作要么全部成功，要么全部失败。
• 事件监听：可以在实体保存之前或之后执行特定逻辑。
• 自定义查询构建器：构建更复杂的查询，包括 JOINs、子查询等。

@nestjs/sequelize

@nestjs/sequelize 是 NestJS 框架提供的一个模块，它集成了 Sequelize ORM，使得开发者可以在应用程序中轻松使用 Sequelize 来进行数据库交互。Sequelize 是一个流行的 Node.js ORM，支持多种关系型数据库，如 MySQL、MariaDB、PostgreSQL、SQLite 和 Microsoft SQL Server。

通过 @nestjs/sequelize，你可以利用 Sequelize 提供的功能，例如模型定义、关联、查询构建器、事务等，同时享受 NestJS 的模块化架构和依赖注入系统带来的好处。

安装

首先，你需要安装 @nestjs/sequelize 包以及 Sequelize 和你打算使用的数据库驱动程序。例如，如果你使用的是 PostgreSQL 数据库：

npm install @nestjs/sequelize sequelize pg pg-hstore

或者使用 yarn:

yarn add @nestjs/sequelize sequelize pg pg-hstore

注意：pg 是 PostgreSQL 的驱动程序，而 pg-hstore 用于处理 PostgreSQL 的 hstore 数据类型。如果你使用其他类型的数据库，请根据需要安装相应的驱动程序。

配置

接下来，在你的应用程序的根模块（通常是 AppModule）中导入 SequelizeModule 并配置它。

import { Module } from '@nestjs/common';
import { SequelizeModule } from '@nestjs/sequelize';
import { User } from './users/user.model';

@Module({
  imports: [
    SequelizeModule.forRoot({
      dialect: 'postgres', // 'mysql' | 'mariadb' | 'postgres' | 'mssql'
      host: 'localhost',
      port: 5432,
      username: 'root',
      password: 'password',
      database: 'test',
      autoLoadModels: true,
      synchronize: true, // 注意：在生产环境中不要启用此选项
    }),
    SequelizeModule.forFeature([User]), // 导入特定模型
  ],
})
export class AppModule {}

• dialect: 数据库类型。
• host, port, username, password, database: 数据库连接信息。
• autoLoadModels: 如果设置为 true，则会自动加载所有实体类。
• synchronize: 如果设置为 true，则会自动同步实体与数据库模式。请注意，这在生产环境中是危险的，因为它可能会导致数据丢失或表结构变化。

创建模型

然后，你需要创建模型类来表示数据库中的表。每个模型类对应于数据库中的一个表，并且可以定义字段、关联等。

import { Table, Column, Model, DataType } from 'sequelize-typescript';

@Table
export class User extends Model {
  @Column({
    type: DataType.INTEGER,
    autoIncrement: true,
    primaryKey: true,
  })
  id: number;

  @Column({
    type: DataType.STRING,
    allowNull: false,
  })
  name: string;

  @Column({
    type: DataType.STRING,
    allowNull: false,
    unique: true,
  })
  email: string;
}

• @Table：标记该类为模型。
• @Column：定义列及其属性。

使用模型

为了对模型执行 CRUD 操作，你可以直接在服务中使用模型实例的方法。NestJS 提供了依赖注入的支持，因此你可以很容易地将模型注入到服务中。

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/sequelize';
import { User } from './user.model';

@Injectable()
export class UsersService {
  constructor(@InjectModel(User) private userModel: typeof User) {}

  async findAll(): Promise<User[]> {
    return this.userModel.findAll();
  }

  async findOne(id: number): Promise<User> {
    return this.userModel.findByPk(id);
  }

  async create(user: User): Promise<User> {
    return this.userModel.create(user);
  }

  async remove(id: number): Promise<void> {
    const user = await this.findOne(id);
    await user.destroy();
  }
}

• @InjectModel(User)：注入特定模型。
• findAll(), findByPk(), create(), destroy() 等方法来自 Sequelize 的模型 API。

进阶功能

@nestjs/sequelize 支持许多进阶功能，比如事务管理、事件监听、自定义查询构建器等，以满足更复杂的应用需求。

• 事务管理：确保一组数据库操作要么全部成功，要么全部失败。
• 事件监听：可以在模型保存之前或之后执行特定逻辑。
• 自定义查询构建器：构建更复杂的查询，包括 JOINs、子查询等。

@nestjs/mongoose

@nestjs/mongoose 是 NestJS 框架提供的一个模块，它集成了 Mongoose，这是一个用于 MongoDB 的对象数据建模（ODM）库。通过 @nestjs/mongoose，你可以轻松地在应用程序中使用 Mongoose 来与 MongoDB 数据库交互，并利用其丰富的功能，例如模式定义、验证、查询构建器等。

安装

首先，你需要安装 @nestjs/mongoose 包以及 Mongoose 和你打算使用的 MongoDB 驱动程序。如果你还没有安装 MongoDB，请先确保它已正确设置并运行。

npm install @nestjs/mongoose mongoose

或者使用 yarn:

yarn add @nestjs/mongoose mongoose

配置

接下来，在你的应用程序的根模块（通常是 AppModule）中导入 MongooseModule 并配置它。

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  imports: [
    MongooseModule.forRoot('mongodb://localhost:27017/test'),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

• MongooseModule.forRoot()：初始化 Mongoose 连接。你需要提供 MongoDB 的连接字符串作为参数。

创建 Schema 和 Model

然后，你需要创建 Schema 和 Model 类来表示 MongoDB 中的集合。每个 Schema 定义了文档的结构和行为，而 Model 则提供了对数据库的操作接口。

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

export type CatDocument = Cat & Document;

@Schema()
export class Cat {
  @Prop({ required: true })
  name: string;

  @Prop({ required: true })
  age: number;

  @Prop({ required: true })
  breed: string;
}

export const CatSchema = SchemaFactory.createForClass(Cat);

• @Schema()：标记该类为 Mongoose Schema。
• @Prop()：定义文档属性及其选项。

注册模型

为了让 NestJS 知道如何访问特定的模型，你需要在模块中注册它。

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';
import { Cat, CatSchema } from './schemas/cat.schema';

@Module({
  imports: [
    MongooseModule.forFeature([{ name: Cat.name, schema: CatSchema }]),
  ],
  controllers: [CatsController],
  providers: [CatsService],
})
export class CatsModule {}

• MongooseModule.forFeature()：注册模型以便在整个模块中使用。

使用 Model

为了对模型执行 CRUD 操作，你可以直接在服务中使用模型实例的方法。NestJS 提供了依赖注入的支持，因此你可以很容易地将模型注入到服务中。

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { Cat } from './interfaces/cat.interface';

@Injectable()
export class CatsService {
  constructor(
    @InjectModel(Cat.name) private catModel: Model<Cat>,
  ) {}

  async findAll(): Promise<Cat[]> {
    return this.catModel.find().exec();
  }

  async create(createCatDto: any): Promise<Cat> {
    const createdCat = new this.catModel(createCatDto);
    return createdCat.save();
  }

  async remove(id: string): Promise<void> {
    await this.catModel.findByIdAndRemove(id).exec();
  }
}

• @InjectModel(Cat.name)：注入特定模型。
• find(), save(), findByIdAndRemove() 等方法来自 Mongoose 的模型 API。

进阶功能

@nestjs/mongoose 支持许多进阶功能，比如事务管理、事件监听、自定义查询构建器等，以满足更复杂的应用需求。

• 事务管理：虽然 MongoDB 本身支持多文档 ACID 事务，但需要注意的是，不是所有的驱动版本都支持这个特性。
• 事件监听：可以在模型保存之前或之后执行特定逻辑。
• 自定义查询构建器：构建更复杂的查询，包括聚合管道等。

@nestjs/platform-express

@nestjs/platform-express 是 NestJS 框架提供的一个模块，它使得开发者可以在 NestJS 应用中使用 Express.js 作为底层的 HTTP 服务器。Express.js 是一个快速、开放源码且极简的 Web 开发框架，广泛用于构建 Node.js 应用程序。通过 @nestjs/platform-express，你可以利用 Express 的所有功能，同时享受 NestJS 提供的强大模块化架构和依赖注入系统。

安装

首先，你需要安装 @nestjs/platform-express 包以及 Express.js（如果尚未安装）。

npm install @nestjs/platform-express express

或者使用 yarn:

yarn add @nestjs/platform-express express

创建应用

创建一个新的 NestJS 应用程序，并确保你选择了 Express 作为平台。如果你已经有一个应用程序，只需确保导入了 @nestjs/platform-express 即可。

配置

在你的应用程序的根模块（通常是 AppModule）中不需要特别配置 @nestjs/platform-express，因为它是 NestJS 默认使用的平台。但是，如果你想自定义 Express 实例的行为，可以这样做：

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import * as express from 'express';

async function bootstrap() {
  const app = await NestFactory.create(AppModule, express());

  // 自定义中间件
  app.use((req, res, next) => {
    console.log('Request received');
    next();
  });

  // 启动服务器
  await app.listen(3000);
}
bootstrap();

• NestFactory.create()：创建一个新的 NestJS 应用实例，并传入 Express 实例。
• app.use()：添加中间件来处理每个请求。

使用 Express 特性

由于 @nestjs/platform-express 允许你直接访问 Express 实例，因此你可以轻松地集成任何 Express 中间件或特性。例如，你可以使用 express-session 或者 cookie-parser 来管理会话和 cookie。

添加中间件

import * as session from 'express-session';

// 在 bootstrap 函数中
app.use(session({
  secret: 'my-secret',
  resave: false,
  saveUninitialized: true,
}));

使用静态文件

import * as path from 'path';

// 在 bootstrap 函数中
app.useStaticAssets(path.join(__dirname, '..', 'public'));

设置视图引擎

如果你想使用模板引擎（如 Pug、EJS 等），你可以设置视图引擎。

app.setBaseViewsDir(join(__dirname, '..', 'views'));
app.setViewEngine('pug');

控制器和路由

在 NestJS 中定义控制器和路由的方式与纯 Express 应用略有不同，但同样强大。你可以使用装饰器来简化路由定义，并自动注册路由处理器。

import { Controller, Get, Req, Res } from '@nestjs/common';
import { Request, Response } from 'express';

@Controller('cats')
export class CatsController {
  @Get()
  findAll(@Req() req: Request, @Res() res: Response) {
    return res.send('This action returns all cats');
  }
}

• @Controller()：定义控制器。
• @Get()：定义 GET 请求的路由。
• @Req() 和 @Res()：获取 Express 请求和响应对象。

进阶功能

@nestjs/platform-express 支持许多进阶功能，比如自定义中间件、错误处理、CORS 配置等，以满足更复杂的应用需求。

• 自定义中间件：可以编写自定义中间件来处理跨域资源共享 (CORS)、身份验证等。
• 错误处理：可以通过全局异常过滤器或局部异常过滤器来捕获和处理错误。
• CORS 配置：可以轻松启用 CORS 并配置允许的来源、方法等。

@nestjs/platform-fastify

@nestjs/platform-fastify 是 NestJS 框架提供的一个模块，它允许开发者使用 Fastify 作为 HTTP 应用程序的底层服务器。Fastify 是一个高性能、低开销的 Web 框架，对于那些需要快速处理大量请求的应用程序来说是一个很好的选择。

NestJS 默认使用 Express 作为其底层 HTTP 服务器，但通过 @nestjs/platform-fastify，你可以轻松地切换到 Fastify。这样做有几个潜在的好处：

• 性能：Fastify 的设计目标之一就是高性能，它在某些基准测试中比 Express 表现更好。
• 插件生态系统：Fastify 有一个丰富的插件生态系统，可以为你的应用程序提供额外的功能。
• 更小的内存占用：Fastify 在设计时考虑到了内存效率，这可能使得它更适合资源受限的环境。

要开始使用 @nestjs/platform-fastify，你需要做以下几步：

1. 安装依赖：
   使用 npm 或 yarn 安装 @nestjs/platform-fastify 包。

   npm install @nestjs/platform-fastify fastify

2. 修改主文件（通常是 main.ts）来使用 FastifyAdapter：

   import { NestFactory } from '@nestjs/core';
   import { FastifyAdapter, NestFastifyApplication } from '@nestjs/platform-fastify';
   import { AppModule } from './app.module';
   
   async function bootstrap() {
     const app = await NestFactory.create<NestFastifyApplication>(
       AppModule,
       new FastifyAdapter(),
     );
     await app.listen(3000);
   }
   bootstrap();

3. 启动应用并测试。

记得查阅官方文档以获取最新的信息和最佳实践，因为框架和工具会随着时间不断更新。

@nestjs-modules/mailer

@nestjs-modules/mailer 是一个用于 NestJS 框架的模块，它简化了从 NestJS 应用程序发送电子邮件的过程。这个模块提供了灵活的配置选项，并支持多种邮件传输服务（如 SMTP, SendGrid, SES 等）。

使用 @nestjs-modules/mailer 可以让你轻松地在你的 NestJS 项目中集成邮件发送功能。你只需要安装该模块并根据文档进行配置，就可以开始发送邮件了。下面是一些基本步骤来设置和使用这个模块：

安装

首先你需要安装 @nestjs-modules/mailer 和 nodemailer（它是一个 Node.js 的模块，用来发送电子邮件）：

npm install @nestjs-modules/mailer nodemailer

或者如果你使用的是 yarn：

yarn add @nestjs-modules/mailer nodemailer

配置

接下来，在你的 NestJS 应用中导入 MailerModule 并进行配置。通常是在 AppModule 中完成的：

import { Module } from '@nestjs/common';
import { MailerModule } from '@nestjs-modules/mailer';

@Module({
  imports: [
    MailerModule.forRoot({
      transport: 'smtps://user:pass@smtp.example.com',
      defaults: {
        from: '"No Reply" <no-reply@example.com>',
      },
    }),
  ],
})
export class AppModule {}

你可以直接提供一个 Nodemailer 兼容的传输对象，或者使用 URL 格式的字符串来定义传输协议、主机、端口、认证信息等。

使用

然后你可以通过依赖注入获取 MailerService 来发送邮件：

import { Injectable } from '@nestjs/common';
import { MailerService } from '@nestjs-modules/mailer';

@Injectable()
export class AppService {
  constructor(private readonly mailerService: MailerService) {}

  async sendMail() {
    await this.mailerService.sendMail({
      to: 'receiver@example.com',
      subject: 'Testing NestJS MailerModule ✔',
      text: 'PlainText content',
      html: '<b>Bold content</b>',
    });
  }
}

以上是使用 @nestjs-modules/mailer 发送邮件的基本流程。你可以查阅官方文档来了解更多的配置选项和高级用法，比如模板引擎的支持、异步配置等。

@nestjs/cache-manager

@nestjs/cache-manager 是 NestJS 提供的一个用于缓存管理的模块。它允许开发者在 NestJS 应用中轻松集成各种缓存解决方案，如 Redis、内存缓存等。这个模块依赖于 cache-manager 库，后者是一个 Node.js 缓存管理库，支持多种存储后端。

安装

首先，你需要安装 @nestjs/cache-manager 和你选择的缓存存储后端。例如，如果你想要使用 Redis 作为缓存存储，你可以安装以下包：

npm install @nestjs/cache-manager cache-manager ioredis
# 或者
yarn add @nestjs/cache-manager cache-manager ioredis

配置

接着，在你的应用模块（通常是 AppModule）中导入 CacheModule 并配置它。这里以 Redis 为例进行配置：

import { Module } from '@nestjs/common';
import { CacheModule, CacheInterceptor, CACHE_MANAGER } from '@nestjs/cache-manager';
import * as redisStore from 'cache-manager-ioredis';

@Module({
  imports: [
    CacheModule.register({
      store: redisStore,
      host: 'localhost',
      port: 6379,
      // 其他配置选项...
    }),
  ],
  providers: [
    {
      provide: 'CACHE_MANAGER',
      useFactory: (cacheManager) => cacheManager,
      inject: [CACHE_MANAGER],
    },
  ],
})
export class AppModule {}

使用

一旦配置完成，你可以在服务或其他地方注入 Cache 服务来使用缓存功能。例如：

import { Injectable, Inject } from '@nestjs/common';
import { CACHE_MANAGER } from '@nestjs/cache-manager';
import { Cache } from 'cache-manager';

@Injectable()
export class SomeService {
  constructor(@Inject(CACHE_MANAGER) private readonly cacheManager: Cache) {}

  async getFromCache(key: string): Promise<any> {
    return this.cacheManager.get(key);
  }

  async setToCache(key: string, value: any, ttl?: number): Promise<void> {
    await this.cacheManager.set(key, value, ttl);
  }
}

中间件/拦截器

NestJS 还提供了 CacheInterceptor，可以用来自动缓存控制器方法的结果。这非常适合那些数据不经常变化但查询频繁的场景。

import { Controller, Get } from '@nestjs/common';
import { UseInterceptors, CacheInterceptor, CacheTTL } from '@nestjs/common';

@Controller('example')
@UseInterceptors(CacheInterceptor)
export class ExampleController {
  @Get()
  @CacheTTL(60) // 缓存时间设置为60秒
  async getData() {
    // 假设这里是耗时的操作
    return { data: 'some data' };
  }
}

通过这种方式，你可以非常方便地将缓存机制集成到你的 NestJS 应用程序中，从而提高性能和响应速度。

@nestjs/bull

@nestjs/bull 是一个用于在 NestJS 框架中集成 Bull（一个基于 Redis 的工作队列库）的模块。它允许开发者在他们的 NestJS 应用程序中轻松地创建和管理后台任务，以实现异步处理、任务调度和分布式任务处理等功能。

以下是 @nestjs/bull 的一些主要特性和概念：

1. Job (任务):
   任务是队列中的最小工作单元。每个任务可以携带数据，并且由工作者函数处理。你可以根据需要定义不同类型的任务。

2. Queue (队列):
   队列是用来存储待处理任务的地方。你可以在应用中创建多个队列，每个队列可以有自己的一组任务和处理器。

3. Processor (处理器):
   处理器是负责执行队列中任务的逻辑。你可以通过装饰器或服务来定义处理器，这样当新任务加入队列时，它们就会被自动处理。

4. Scheduler (调度器):
   使用内置的调度功能，你可以安排定期任务或者延迟任务。这使得你可以设置任务在未来某个时间点执行，或是按照一定的时间间隔重复执行。

5. BullModule:
   这个模块提供了对 Bull 队列的支持，包括配置连接到 Redis 服务器、注册队列以及提供全局的队列提供者。

6. 装饰器:
   @nestjs/bull 提供了一系列的装饰器来简化与 Bull 集成的过程，比如 @Process() 来标记处理特定类型任务的方法，@OnGlobalQueueCompleted() 来监听所有队列完成事件等。

7. 监控和可视化:
   Bull 还支持使用像 Bull Board 这样的工具来监控队列的状态和性能，这可以帮助你更好地管理和优化你的后台任务。

要开始使用 @nestjs/bull，你需要安装必要的依赖项，然后配置并导入 BullModule 到你的 NestJS 应用中。接着，你可以定义队列和服务来处理这些队列中的任务。下面是一个简单的例子：

// 安装依赖
npm install @nestjs/bull bull redis

// 导入 BullModule 并添加到应用程序的根模块
import { Module } from '@nestjs/common';
import { BullModule } from '@nestjs/bull';

@Module({
  imports: [
    BullModule.forRoot({
      redis: {
        host: 'localhost',
        port: 6379,
      },
    }),
    BullModule.registerQueue({
      name: 'mail-queue',
    }),
  ],
})
export class AppModule {}

接下来，你可以创建一个处理器来处理 mail-queue 中的任务：

import { Injectable, OnModuleInit } from '@nestjs/common';
import { Processor, Process } from '@nestjs/bull';
import { Job } from 'bull';

@Processor('mail-queue')
@Injectable()
export class MailConsumer implements OnModuleInit {
  onModuleInit() {
    console.log('Mail consumer initialized');
  }

  @Process()
  async handleJob(job: Job) {
    console.log(`Processing job ${job.id} with data ${JSON.stringify(job.data)}`);
    // 在这里放置发送邮件的代码
  }
}

这个例子展示了如何设置一个基本的队列和相应的消费者。你可以根据实际需求扩展此示例，例如添加错误处理、重试机制、进度更新等。

@nestjs/schedule

@nestjs/schedule 是 NestJS 的一个官方模块，它允许开发者在应用程序中轻松地安排和执行定时任务。通过这个模块，你可以创建基于时间的调度作业，例如定期清理缓存、发送每日报告邮件等。

以下是 @nestjs/schedule 模块的主要特性和使用方法：

主要特性

1. Cron 表达式支持:
   你可以使用标准的 Cron 表达式来定义任务的执行时间规则。这使得你可以灵活地指定任务应该何时运行，比如每分钟、每天特定时间、每周一次等。

2. 时间间隔 (Interval):
   如果你不需要复杂的调度逻辑，可以简单地设置以毫秒为单位的时间间隔来周期性地执行任务。

3. 延时执行 (Timeout):
   设置一次性延迟执行的任务，类似于 JavaScript 中的 setTimeout 函数。

4. 异步任务:
   支持异步函数作为调度任务，因此你可以等待某些操作完成后再继续执行其他代码。

5. 组合调度:
   可以将多个调度器组合在一起，以便更复杂的时间模式安排。

6. 优雅停止:
   当应用关闭时，可以确保所有正在运行的任务都能完成，而不是突然中断。

安装与配置

首先，你需要安装 @nestjs/schedule 包：

npm install @nestjs/schedule

然后，在你的主模块（通常是 AppModule）中导入 ScheduleModule：

import { Module } from '@nestjs/common';
import { ScheduleModule } from '@nestjs/schedule';

@Module({
  imports: [
    ScheduleModule.forRoot(),
  ],
})
export class AppModule {}

创建调度任务

接下来，你可以通过装饰器来创建调度任务。下面是一些常见的例子：

• 使用 Cron 表达式的任务

import { Injectable } from '@nestjs/common';
import { Cron, CronExpression } from '@nestjs/schedule';

@Injectable()
export class CronService {
  @Cron(CronExpression.EVERY_HOUR)
  handleCron() {
    console.log(`Scheduled task executed at ${new Date()}`);
  }
}

在这个例子中，handleCron 方法将在每一小时整点时被执行。

• 使用时间间隔的任务

import { Injectable } from '@nestjs/common';
import { Interval } from '@nestjs/schedule';

@Injectable()
export class IntervalService {
  @Interval(10000) // 每10秒执行一次
  handleInterval() {
    console.log('This is an interval-based task');
  }
}

• 使用延时执行的任务

import { Injectable, OnModuleInit } from '@nestjs/common';
import { Timeout } from '@nestjs/schedule';

@Injectable()
export class TimeoutService implements OnModuleInit {
  onModuleInit() {
    console.log('Module initialized');
  }

  @Timeout(5000) // 在服务启动后5秒执行一次
  handleTimeout() {
    console.log('This is a timeout-based task');
  }
}

注意事项

• 确保你的服务是被注入到 NestJS 应用程序中的，否则调度器不会自动发现并注册这些任务。
• 对于长时间运行或资源密集型的任务，考虑使用像 @nestjs/bull 这样的后台任务处理库，因为它们提供了更好的错误处理、重试机制等功能。
• 调度任务默认是在每个实例上都执行的。如果你的应用部署在多个实例上，并且你不希望所有实例都执行相同的任务，那么需要实现某种形式的分布式锁或者选择一个主节点来负责执行任务。

通过 @nestjs/schedule，你可以方便地为 NestJS 应用添加各种类型的定时任务，从而提高应用的功能性和自动化程度。

@nestjs/throttler

@nestjs/throttler 是 NestJS 提供的一个模块，用于限制客户端对 API 的访问频率。这对于防止滥用、保护服务器资源以及确保服务的公平使用非常重要。通过设置速率限制，可以有效地减少恶意流量或误配置客户端对系统的影响。

安装依赖

要开始使用 @nestjs/throttler，首先需要安装它：

npm install @nestjs/throttler

配置 ThrottlerModule

接下来，在你的应用程序中配置 ThrottlerModule。通常你会在根模块 (AppModule) 中导入并配置它。这里是一个基本的配置示例：

import { Module } from '@nestjs/common';
import { ThrottlerModule } from '@nestjs/throttler';

@Module({
  imports: [
    ThrottlerModule.forRoot({
      ttl: 60, // 时间窗口大小（秒）
      limit: 10, // 每个时间窗口内允许的最大请求数
    }),
    // 其他模块...
  ],
  // providers, controllers, etc.
})
export class AppModule {}

上述配置表示每个 IP 地址每分钟最多只能发送 10 个请求。

使用守卫进行更细粒度控制

如果你想对特定的路由或控制器应用不同的速率限制规则，你可以使用 ThrottlerGuard 并结合自定义的 TTL 和 LIMIT。你还可以创建自定义守卫来实现更复杂的逻辑，例如基于用户角色或订阅级别的速率限制。

import { Injectable, NestMiddleware } from '@nestjs/common';
import { ThrottlerGuard } from '@nestjs/throttler';

@Injectable()
export class CustomThrottlerGuard extends ThrottlerGuard {
  protected getTracker(req): string {
    // 自定义追踪器逻辑，比如基于用户ID而不是IP地址
    return req.user.id;
  }
}

// 在控制器或方法级别使用守卫
import { Controller, Get, UseGuards } from '@nestjs/common';
import { CustomThrottlerGuard } from './custom-throttler.guard';

@Controller('profile')
export class ProfileController {
  @UseGuards(CustomThrottlerGuard)
  @Get()
  getProfile(@Req() req) {
    return req.user;
  }
}

存储选项

默认情况下，@nestjs/throttler 使用内存存储来跟踪请求计数。如果你的应用程序是分布式部署的，或者你需要持久化这些数据，那么你可以考虑使用 Redis 等外部存储解决方案。为此，你需要安装相应的包，并配置 ThrottlerStorage。

npm install ioredis

然后，你可以创建一个自定义存储类：

import { Injectable } from '@nestjs/common';
import { ThrottlerStorageInterface } from '@nestjs/throttler';
import * as Redis from 'ioredis';

@Injectable()
export class RedisThrottlerStorage implements ThrottlerStorageInterface {
  private readonly client = new Redis();

  async incr(key: string, ttl: number): Promise<number> {
    await this.client.incr(key);
    await this.client.expire(key, ttl);
    return parseInt(await this.client.get(key), 10);
  }

  async reset(key: string): Promise<void> {
    await this.client.del(key);
  }
}

最后，将这个存储类传递给 ThrottlerModule：

ThrottlerModule.forRoot({
  ttl: 60,
  limit: 10,
  storage: new RedisThrottlerStorage(),
}),

这样就可以使用 Redis 来管理速率限制了。根据你的需求，你可能需要调整配置或者添加额外的功能。官方文档提供了更多详细信息和支持。

@nestjs/schematics

@nestjs/schematics 是 NestJS 框架提供的一个工具包，用于通过 Angular CLI 风格的命令行接口生成和管理 NestJS 项目结构。Schematics 允许开发者快速创建模块、控制器、服务（提供者）、中间件、守卫、管道、拦截器等 NestJS 组件，而无需手动编写样板代码。

使用 @nestjs/schematics 可以帮助开发者更高效地开发应用程序，因为它减少了重复性工作，并且确保了新创建的组件遵循一致的代码风格和结构。

要使用 @nestjs/schematics，你通常需要先安装它。如果你还没有安装 NestCLI，可以通过 npm 安装：

npm install -g @nestjs/cli

一旦安装了 NestCLI，你可以用它来初始化新的 NestJS 项目或者向现有项目添加新的功能模块。例如，创建一个新的 NestJS 应用程序可以这样：

nest new project-name

然后，你可以使用以下命令来生成不同的 NestJS 组件：

• 创建一个模块：

  nest generate module module-name

• 创建一个控制器：

  nest generate controller controller-name

• 创建一个服务/提供者：

  nest generate service service-name

这些命令会自动更新项目的架构并注入必要的导入语句，从而保持代码的整洁和有序。

请注意，@nestjs/schematics 和 @nestjs/cli 工具会不断更新，因此建议查阅官方文档以获取最新信息和最佳实践。

@nestjs/terminus

@nestjs/terminus 是一个为 NestJS 应用程序提供的健康检查模块，它帮助开发者监控应用程序的健康状态。通过 @nestjs/terminus，你可以轻松地设置和管理各种健康检查端点（health check endpoints），这些端点可以被外部服务（如负载均衡器、容器编排工具等）用来确定你的应用是否正常运行。

以下是使用 @nestjs/terminus 的一些基本步骤：

安装

首先，你需要安装 @nestjs/terminus 包：

npm install @nestjs/terminus

或者如果你使用的是 Yarn：

yarn add @nestjs/terminus

创建健康检查控制器

然后，在你的 NestJS 项目中创建一个新的控制器来处理健康检查请求。通常你会想要创建一个专门的健康检查模块和控制器。

import { Controller, Get } from '@nestjs/common';
import { HealthCheckService, HealthCheck } from '@nestjs/terminus';

@Controller('health')
export class HealthController {
  constructor(private health: HealthCheckService) {}

  @Get()
  @HealthCheck()
  check() {
    // 这里可以添加更多的健康检查函数
    return this.health.check([
      () => this.health.pingCheck('database', 'http://localhost:5432'),
      // 其他健康检查...
    ]);
  }
}

配置应用

确保在你的主应用模块（通常是 AppModule）中导入 TerminusModule：

import { Module } from '@nestjs/common';
import { TerminusModule } from '@nestjs/terminus';
import { HealthController } from './health.controller';

@Module({
  imports: [TerminusModule],
  controllers: [HealthController],
})
export class AppModule {}

自定义健康检查

你可以根据需要自定义健康检查逻辑。例如，你可以添加数据库连接检查、Redis连接检查等。@nestjs/terminus 提供了一些内置的健康检查功能，并且也支持你编写自己的健康检查逻辑。

使用场景

• Kubernetes：Kubernetes 可以配置 liveness 和 readiness 探针来定期调用健康检查端点，以判断容器是否应该继续运行或接受流量。
• 负载均衡器：健康检查可以用于告诉负载均衡器哪些实例是健康的，应该接收流量。
• **持续集成/持续部署 (CI/CD)**：在部署过程中，健康检查可以帮助确认新版本的应用已经成功启动并且可以正常工作。

@nestjs/terminus 是构建可靠、可维护的服务的一个重要工具，特别是在微服务架构中，健康检查对于保持系统的稳定性和可靠性至关重要。

@nestjs/event-emitter

@nestjs/event-emitter 是 NestJS 框架提供的一个用于事件驱动架构的模块，它简化了在应用程序中实现发布-订阅模式的过程。通过使用 EventEmitter2 库，@nestjs/event-emitter 使开发者能够在服务之间解耦合的同时，通过事件来协调和通信。

以下是关于如何使用 @nestjs/event-emitter 的一些基本指导：

安装

首先，你需要安装 @nestjs/event-emitter 包：

npm install @nestjs/event-emitter

或者如果你使用的是 Yarn：

yarn add @nestjs/event-emitter

配置应用

接下来，在你的主应用模块（通常是 AppModule）中导入 EventEmitterModule：

import { Module } from '@nestjs/common';
import { EventEmitterModule } from '@nestjs/event-emitter';

@Module({
  imports: [
    EventEmitterModule.forRoot(), // 初始化事件发射器
  ],
})
export class AppModule {}

发布事件

你可以在任何服务、控制器或守卫中通过注入 EventEmitter2 来发布事件：

import { Injectable, Inject } from '@nestjs/common';
import { EventEmitter2 } from '@nestjs/event-emitter';

@Injectable()
export class OrdersService {
  constructor(@Inject(EventEmitter2) private eventEmitter: EventEmitter2) {}

  async createOrder(orderData: any) {
    // 创建订单的逻辑...
    
    // 发布创建订单成功的事件
    this.eventEmitter.emit('order.created', { order: orderData });
  }
}

监听事件

你可以监听特定事件，并在事件触发时执行相应的逻辑。这通常是在服务类中完成的，通过装饰器 @OnEvent 来定义事件处理器：

import { Injectable, OnEvent } from '@nestjs/common';

@Injectable()
export class OrderEventsService {
  @OnEvent('order.created')
  handleOrderCreatedEvent(event: any) {
    console.log(`Order created with data: ${JSON.stringify(event.order)}`);
    // 执行其他业务逻辑，例如发送通知等
  }
}

使用场景

• 解耦组件：通过事件机制，可以减少不同组件之间的直接依赖。
• 异步处理：事件可以用来触发异步任务，如后台作业、通知系统等。
• 日志记录和监控：每当特定事件发生时，可以记录日志或向监控系统发送警报。
• 微服务通信：在微服务架构中，事件可以作为服务间通信的一种方式，尽管更常见的是使用消息队列或其他专用工具。

@nestjs/event-emitter 提供了一种简单且强大的方法来构建响应式和可扩展的应用程序。

@nestjs/cli

@nestjs/cli 是 NestJS 的命令行接口工具，用于加速开发过程。它可以帮助开发者快速创建新的 NestJS 项目、生成模块、控制器、服务等，以及执行其他实用的任务。通过使用 @nestjs/cli，你可以确保项目的结构遵循最佳实践，并且可以减少样板代码的编写。

以下是一些常见的 @nestjs/cli 命令：

• 创建新项目:

  nest new project-name

• 生成新模块:

  nest generate module module-name

• 生成新控制器:

  nest generate controller controller-name

• 生成新服务（提供者）:

  nest generate service service-name

• 生成守卫、中间件、管道、拦截器等:

  nest generate guard|middleware|pipe|interceptor name

安装 @nestjs/cli 全局到你的机器上，你可以在任何地方运行上述命令。要全局安装 CLI，你可以使用 npm 或 yarn:

npm install -g @nestjs/cli

或

yarn global add @nestjs/cli

如果你想要检查已安装的 CLI 版本，可以使用以下命令：

nest --version

请记得在执行这些命令之前确认你的环境中已经正确设置了 Node.js 和 npm 或 yarn。此外，CLI 工具会不断更新，因此建议定期检查官方文档以获取最新的功能和用法。

@nestjs/testing

@nestjs/testing 是 NestJS 框架提供的一个模块，旨在简化测试过程。它提供了一套工具和辅助函数，帮助开发者创建和组织单元测试、集成测试等。通过 @nestjs/testing，你可以轻松地模拟依赖项，创建测试模块，并对应用程序的各个部分进行彻底的测试。

以下是如何使用 @nestjs/testing 进行测试的基本步骤：

安装

首先，你需要确保安装了 @nestjs/testing 包。如果你已经安装了 NestJS CLI 并创建了一个项目，那么通常这个包会自动包含在你的开发依赖中。如果没有，可以通过 npm 或 yarn 安装：

npm install --save-dev @nestjs/testing

或

yarn add --dev @nestjs/testing

创建测试文件

对于每一个需要测试的服务、控制器或其他组件，你都应该创建相应的测试文件。通常，这些文件会被命名为 [component].spec.ts（例如 cats.service.spec.ts）。

编写测试

在测试文件中，你可以使用 Test.createTestingModule() 方法来创建一个测试模块，该模块可以配置服务、控制器等依赖关系。然后，你可以使用 compile() 方法编译测试模块并获取应用对象或服务实例以进行测试。

下面是一个简单的例子，展示了如何为一个服务编写测试：

import { Test, TestingModule } from '@nestjs/testing';
import { CatsService } from './cats.service';

describe('CatsService', () => {
  let service: CatsService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [CatsService],
    }).compile();

    service = module.get<CatsService>(CatsService);
  });

  it('should be defined', () => {
    expect(service).toBeDefined();
  });
});

在这个例子中，我们创建了一个测试模块，其中包含了 CatsService 提供者。接着，我们在每个测试之前异步编译测试模块，并从编译后的模块中获取 CatsService 的实例。最后，我们用一个简单的断言检查服务是否已定义。

使用 Jest 测试框架

NestJS 默认集成了 Jest 测试框架。Jest 提供了许多便捷的功能，如快照测试、代码覆盖率报告等。因此，你可以利用 Jest 的强大功能来增强你的测试。

要运行测试，可以在项目的根目录下执行：

npm run test

这将运行所有匹配 .spec.ts 文件中的测试。

异步测试与依赖注入

当你的服务依赖于其他服务或外部资源（如数据库连接）时，你可以使用 jest.mock() 函数来模拟这些依赖，或者在 createTestingModule 中手动指定它们的实现。

例如：

import { Test, TestingModule } from '@nestjs/testing';
import { CatsService } from './cats.service';
import { Model } from 'mongoose';
import { Cat } from './interfaces/cat.interface';
import { CatsModule } from './cats.module';

describe('CatsService', () => {
  let service: CatsService;
  let model: Model<Cat>;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      imports: [CatsModule],
    })
    .overrideProvider(Model)
    .useValue({
      find: jest.fn(),
      // ... mock other methods
    })
    .compile();

    service = module.get<CatsService>(CatsService);
    model = module.get<Model<Cat>>(getModelToken('Cat'));
  });

  it('should return an array of cats', async () => {
    jest.spyOn(model, 'find').mockImplementationOnce(() => ({
      exec: jest.fn().mockResolvedValue([{ name: 'Milo' }, { name: 'Otis' }]),
    }));

    expect(await service.findAll()).toEqual([{ name: 'Milo' }, { name: 'Otis' }]);
  });
});

在这个例子中，我们覆盖了默认的 Model 提供者，并为其方法提供了模拟实现。这使得我们可以独立于实际的数据库连接来测试 CatsService 的行为。