## 背景

## 效果

## 落地方案

1. 依赖安装

   ```shell
   npm install @nestjs-modules/mailer
   ```
2. 初始化 `module`

   ```javascript
   // app.module.ts
   @Module({
    imports: [
      MailerModule.forRoot({
        transport: {
          host: 'smtp.exmail.qq.com',
          port: 465,
          ignoreTLS: false,
          secure: true,
          auth: {
            user: 'bot@fmlg1688.cn',
            pass: 'xxxxxx',
          },
        },
        defaults: {
          from: '"Bot" <bot@fmlg1688.cn>',
        },
        preview:false,
        template: {
          dir: path.join(process.cwd(), './src/common/template'),//这里就是你的ejs模板文件夹路径
          adapter: new EjsAdapter(),
          options: {
            strict: true //严格模式
          }
        }
      })
    ],
    ...
   })
   export class AppModule { }
   ```
3. 邮件模版

   ```javascript
   // common/template/validate.ejs
   <div class="biu-nav-email"
      style="max-width: 600px;min-width: 300px;margin: 40px auto;box-shadow: 0px 0px 5px rgba(0, 0, 0, 0.1);font-size: 16px;border-radius: 5px;color: #ccc;">
      <h3 style="margin-bottom: 40px;">
          Hi! 亲爱的用户：
      </h3>
      <p style="padding-left: 20px;">
          您正在进行邮箱验证,本次请求的验证码为:
      </p>
      <p style="color: #dde2e2;padding-left: 14px;">
          <strong style="color: #000;font-size: 24px;">
              <%= locals.code %>
          </strong>
          <span>(为了保障您帐号的安全性,请在30分钟内完成验证,祝您生活愉快!)</span>
      </p>
      <p style="padding-left: 20px;">
          <span>快速访问:</span>
          <a href="https://www.biunav.com" style="color:#fff" target="_blank"
              rel="noopener noreferrer">https://www.biunav.com</a>
      </p>
   </div>
   ```
4. 发送邮件

   ```javascript
   import { MailerService } from '@nestjs-modules/mailer';
   import { Controller, Get } from '@nestjs/common';

   @Controller({ path: '/mail' })
   export class MailController {
    constructor(private readonly mailerService: MailerService) {}

    @Get()
    async classify() {
      let result = await this.mailerService
        .sendMail({
          to: '1025534801@qq.com',
          from: 'bot@fmlg1688.cn',
          subject: '测试',
          template: './validate.ejs',
          context: {
            code: 3311,
          },
        })
        .then((result) => {
          console.log('---->');
        })
        .catch((error) => {
          console.log('error:', error);
        });

      return { code: 0, result };
    }
   }
   ```


基于Nestjs实现node发送邮件

## 前言

NestJS 是一个用于开发高效、可扩展的 Node.js 服务器端应用程序的框架。其优雅的 TypeScript 支持和深度集成的系统模块，使得开发复杂的后端服务变得前所未有的简单。在这篇文章中，我们将介绍 NestJS 的基础知识，帮助你快速入门。

## 准备工作

> 以下准备工作是 nestjs 运行的基础环境，如果你已经学习或了解了nodejs相关的知识以及开发设备已经成功安装了Node环境和开发IDE，请忽略这部分内容。

- 安装 NodeJS
- 安装 pnpm（可选项）
- 安装 VsCode 编辑器

## 开始入门

### 一、安装 nestjs 脚手架

```shell
npm install -g @nestjs/cli

或者

pnpm install -g @nestjs/cli
```

### 二、创建第一个 nestjs 服务项目

```shell
nest new your-custom-project-name
```

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/m0YyspFsmLPcRzUy.png)

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/hqrrhUDMPTse_0_m.png)

### 三、通过 VsCode 打开创建的项目

```shell
npm run start
```

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/IR_SkhcCREKbPXsL.png)

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/OcTcq1L6EqX7aUFZ.png)

### 四、访问第一个HTTP接口

> 浏览器访问 http://localhost:3000

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/uElDH89zltqa8788.png)

## 项目文件分析

nestjs 脚手架生成的最基础的项目包含如下文件列表

```shell
├── package.json
├── pnpm-lock.yaml
├── src
│   ├── app.controller.spec.ts
│   ├── app.controller.ts
│   ├── app.module.ts
│   ├── app.service.ts
│   └── main.ts
├── test
│   ├── app.e2e-spec.ts
│   └── jest-e2e.json
├── tsconfig.build.json
└── tsconfig.json
```

文件介绍：

- package.json 项目核心配置文件，主要包含项目基础信息，项目依赖等。
- src/main.ts 服务运行入口文件，定义了nest服务加载流程。
- src/module.ts nest服务依赖的核心模块，其中定义了 `imports`,`controllers`，`providers`，`exports`等。
- src/controller.ts 提供HTTP接口、微服务等对外的方法集合；
- src/service.ts 提供运行时公共方法，相对于静态的utils方法，service实例可以注入其他的provider服务。
- 其他文件都是 「单元测试」相关的文件，有没有都不会影响整个服务启动运行的，暂xiug 时按下不表。

## 编写第一个HTTP接口

> ⛱️ 当我们尝试新鲜事物时，给自己制定一些简单容易实现的目标然后实现它，通过成就感不断的刺激，才会让我们能够坚持深入使用并掌握它。

### 目标一

1. 实现如下HTTP接口

   | URL      | /api/user                                                                                          |
   | -------- | -------------------------------------------------------------------------------------------------- |
   | Method   | GET                                                                                                |
   | Request  | {<br />“name”:”levenx”<br />}                                                                  |
   | Response | {<br />“code”:0,<br />“message”:”ok”,<br />“data”:{<br />“name”:”levenx”<br />}<br />} |

   接口要求分析，前端通过/api/user接口的query参数携带name参数，接口按照要求格式返回即可。
2. 修改app.controllers.ts文件代码内容

   ```shell
   import { Controller, Get, Query } from '@nestjs/common';
   import { AppService } from './app.service';

   @Controller()
   export class AppController {

     @Get('/api/user')
     getUserName(@Query() query) {
       return {
         code: 0,
         message: 'ok',
         data: {
           name: query.name,
         },
       };
     }
   }
   ```

   分析：

   1. nestjs 通过在方法上添加@Get注解定义接口，注解方法的参数（/api/user）就是需要定义的接口路径。
   2. nestjs 提供了很多注解让开发者获取自己想要的信息，比如通过@Query获取GET请求的query参数。
   3. 方法return返回的内容就是HTTP返回的相应体内容。
3. 在浏览器中访问 http://localhost:3000/api/user?name=levenx，看看返回是否符合预期。

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/UJACIkmGjFwHoj0b.png)

### 目标二

1. 实现公共的service方法给多个HTTP接口使用，service方法的作用是在用户name前面加上 hi！
2. 修改app.service.ts文件内容

   ```javascript
   import { Injectable } from '@nestjs/common';

   @Injectable()
   export class AppService {
     setHi(name: string): string {
       return `hi! ${name}`;
     }
   }
   ```
3. 在app.controller.ts 中使用service方法

   ```javascript
   import { Controller, Get, Query } from '@nestjs/common';
   import { AppService } from './app.service';

   @Controller()
   export class AppController {
   ++  constructor(private readonly appService: AppService) {}

     @Get('/api/user')
     getUserName(@Query() query) {
       return {
         code: 0,
         message: 'ok',
         data: {
   ++        name: this.appService.setHi(query.name),
         },
       };
     }
   }
   ```

   代码分析：

   1. 首先需要在Controller的构造方法中添加appService方法，这一步让整个AppController中所有的方法都能够调用appService的方法；
   2. 在需要使用service方法的地方调用即可。
4. 在浏览器中访问 http://localhost:3000/api/user?name=levenx

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/gcOveM_4aPTplM3X.png)

## 总结

Nestjs 是一个非常强大的 Node 框架，它支持了很多能力丰富后端项目工程，本篇教程只是对Nestjs的浅尝辄止，后续我们继续深入Nestjs的更多方面。


NestJS是一个用于开发高效、可扩展的Node.js服务器端应用程序的框架。其优雅的TypeScript支持和深度集成的系统模块，使得开发复杂的后端服务变得前所未有的简单。在这篇文章中，我们将介绍NestJS的基础知识，帮助你快速入门。准备工作以下准备工作是nestjs运行的基础环境，如果你已经学习或了解了nodejs相关的知识以及开发设备已经成功安装了Node环境和开发IDE，请忽略这部分内容

 零基础入门 Nestjs 开发教程

## 背景

当我们学习nestjs框架想跟朋友分享自己的接口，当我们开发了自己的应用想对外开放给其他人使用，我们需要一台有公网IP的电脑设备。

在各大云厂商平台掏钱购买云服务器是一个不错的选择（目前云厂商都有拉新的活动，想尝鲜的同学还是低成本的尝试一下的[https://blog.csdn.net/m0_37890289/article/details/109709131](https://blog.csdn.net/m0_37890289/article/details/109709131)）

但是，在我们学习或者业务体量较小的阶段，能够**白嫖服务器资源**肯定是一件让人快乐的事。Vercel平台就是这样的平台，它支持免费部署各种服务。

本文会详细记录Vercel 部署Nestjs项目的步骤。

## 实现步骤

### 一、Nestjs 项目添加 vercel 配置文件

在nest项目的根目录下创建 vercel.json 文件，并且设置 nestjs 服务相关的配置。

```javascript
{
  "version": 2,
  "builds": [
    {
      "src": "src/main.ts",
      "use": "@vercel/node"
    }
  ],
  "routes": [
    {
      "src": "/(.*)",
      "dest": "src/main.ts",
      "methods": [
        "GET",
        "POST",
        "PUT",
        "DELETE",
        "PATCH"
      ]
    }
  ]
}
```

### 二、Nestjs 项目上传到github

1. 创建新的 github 仓库

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/d7ga0bOJFl3BsU8Q.png)

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/AaL7PpfdM1_v-vLI.png)
2. 本地项目关联 github 新建的仓库

   ```javascript
   git remote add origin https://github.com/levenx/customer-service-server.git
   ```
3. 本地代码推送到 github

   ```javascript
   git push --set-upstream origin main
   ```

   > 代码成功推送到 github
   >

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/frbBoADRF43G-REj.png)
4. 将项目授权给 vercel

   > 🎯 访问地址：[https://github.com/settings/installations](https://github.com/settings/installations)
   >

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/I-RZDMc_IWpfN-Os.png)

   搜索对应的项目，关联后记得save

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/AnYLxcN6bdZZPTZ-.png)

### 三、Vercel 平台新建项目

> ⛱️ 如果还没有 vercel 账号的同学，需要首先注册 vercel 账号（直接使用github授权登录即可）
>
> 登录**地址** [https://vercel.com/login](https://vercel.com/login)

1. 新建 vercel 项目

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/NYaYf1Z4vs42PBp5.png)
2. 搜索项目，接着执行 import

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/WHAch8TWWpRVScUM.png)
3. 修改打包命令，并且执行 deploy

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/Z_Ys28aGa_soFnP5.png)
4. 部署成功

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/rIjYnFGhMif2I7UQ.png)

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/Ydzas012dQ5wR6r4.png)

感兴趣的同学可以访问我部署的服务地址：

[bookmark](https://customer-service-server-ng1d-kl84dacvy-levenx.vercel.app/)

至此，我们已经完成了nestjs在vercel平台的部署。

### 四、自定义个人域名（非必需）

> 🎯 Vercel 默认给服务分配了临时的域名，同时支持用户配置个人域名（首先要确认自己已经拥有了个人域名，并且国内还需要完成备案）

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/1SrHQOVJvcbXVrms.png)

1. 配置个人域名

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/TLVYqDhxkriXI3wC.png)

1. 修改域名DNS解析

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/WU3maXghdBOYzOcp.png)
2. Vercel 检测解析成功

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/SbOvtiYQwo1PWQN0.png)
3. 用自己的域名访问服务

> [https://customer-service.levenx.com](https://customer-service.levenx.com/)

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/hWu_QQQYSgt1Lf2k.png)

## 总结

在学习Nestjs的过程中，将代码部署到公网上让其他人能够访问，是真的很有成就感，Vercel 是一个非常值得白嫖的平台。

如果这篇文章对你有多启发和帮助，请点一下赞表示对笔者的支持，感恩～


这篇文章详细解析了如何使用Vercel免费部署Nestjs项目的步骤。首先，我们需要在Nestjs项目中添加Vercel的配置文件。接着，我们将项目上传到GitHub，然后授权给Vercel。选择GitHub上的项目，通过Vercel平台创建新项目并完成部署。此外，如果你想使用个人域名访问你的服务，Vercel也提供了这样的支持，你只要有一个通过备案的个人域名，就可以将其配置到你的Vercel项

一文教会你如何使用 Vercel 部署你的 NestJS 应用 

## 前言

服务端消息推送**SSE**是常用的服务器消息通信手段，适用于服务器主动给客户端发送消息的场景，例如私信通知，扫描登录等都可以使用SSE实现。SSE的底层原理是客户端与服务端建立 HTTP 长链接。

Nestjs 框架内置了对SSE的支持，本文详细介绍Nestjs服务端推送服务的实战步骤。

## 使用步骤

### 一、创建 SSE 接口服务

跟普通的 HTTP 方法相同，在 `@nestjs/common` 中引入 `@Sse` 装饰器，在处理服务器推送的方法上使用 `@See`装饰器。

```javascript
import { Controller, Param, Sse } from '@nestjs/common';
import { ApiTags } from '@nestjs/swagger';
import { Observable, interval, map } from 'rxjs';

export interface MessageEvent {
  message: string;
}

@Controller({ path: '/admin/message' })
export class AdminMessageController {
  @Sse('sse')
  sendServerMessage(@Param() params): Observable<MessageEvent> {
    return interval(5000).pipe(map((_) => ({ message: '你好乐闻' })));
  }
}
```

上面的程序目的是服务器每5s向客户端发送一次消息。

### 二、使用 Postman 调试服务端推送接口

由于SSE本质就是 HTTP 连接，在Postman中使用get请求发起请求即可。

会发现每 `5s`收到一条「你好乐闻」的消息。

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/vSIwn4Jg7gOT4DUV.png)

### 三、浏览器前端建立链接

SSE 是客户端和服务端之间的单向通行，即服务端向客户端发送信息。客户端使用 `EventSource` 发送连接。

以 React 为例，实现前端页面与服务端建立SSE连接。服务端推送过来的消息会触发 `EventSource`的 `onmessage`回调事件，所以我们可以在 `onmessage`中自定义业务逻辑。

```javascript
useEffect(() => {
    const eventSource = new EventSource(
      "http://localhost:8822/admin/message/sse",
    );
    eventSource.onmessage = ({ data }) => {
      console.log("New message", JSON.parse(data));
    };
  }, []);
```

当我触发了自定义消息推送接口后，发现在浏览器的控制台可以看到日志输出

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/SIpfsScRyDzp7ypD.png)

## 进阶使用

### 如何自定义推送的内容

由于 Nestjs 底层是依赖 `rxjs` 实现数据流，Nest 的 SSE 方法返回的是 `Observable` ,在SSE服务长链接时，希望在中途能够通知 `Observable`

返回不同的数据。

基于 `rxjs`的 `Subject`可以实现上述形式的数据推送。

1. 安装相关依赖

   ```javascript
   npm install @nestjs/event-emitter
   ```
2. nestjs 注册发布订阅模块

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

   @Module({
     imports: [
       EventEmitterModule.forRoot()
     ],
   })
   export class AppModule {}
   ```
3. 实现SSE自定义消息逻辑以及发送自定义内容

   ```javascript
   import { Controller, Inject, Get, Sse } from '@nestjs/common';
   import { ApiTags } from '@nestjs/swagger';
   import { EventEmitter2 } from '@nestjs/event-emitter';
   import { Observable, Subject, map } from 'rxjs';

   export interface MessageEventData {
     userId: number;
     message: Record<string, string>;
   }

   export interface MessageEvent {
     message: MessageEventData;
   }

   @Controller({ path: '/admin/message' })
   export class AdminMessageController {
     @Inject(EventEmitter2)
     private readonly eventEmitterService: EventEmitter2;

     @Sse('sse')
     sendServerEvent(): Observable<MessageEvent> {
       const subject = new Subject();

       // 监听CUSTOM_MESSAGE事件
       this.eventEmitterService.on('CUSTOM_MESSAGE', (data) => {
         // subject 处理事件
         subject.next(data);
       });

       return subject.pipe(
         map((data: MessageEventData): MessageEvent => ({ message: data })),
       );
     }

   	// 发送自定义发送消息
     @Get('send')
     emitMessage() {
       const messageEventData: MessageEventData = {
         userId: 123456,
         message: { hi: '你好乐闻' },
       };
       // 发送 CUSTOM_MESSAGE 事件
       this.eventEmitterService.emit('CUSTOM_MESSAGE', messageEventData);
     }
   }
   ```
4. Postman 调试效果

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/0VfS5TNXC4ezSybF.png)

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/faKXabGdCWorx0P4.png)

## 总结

服务端推送SSE在业务开发中经常使用到的通信手段，Nestjs 是目前比较流行通用的node框架，Nestjs 支持了SSE，本文也大致介绍了使用步骤，希望能够对有需要的同学有所帮助。


服务端消息推送SSE是常用的服务器消息通信手段，适用于服务器主动给客户端发送消息的场景，例如私信通知，扫描登录等都可以使用SSE实现。SSE的底层原理是客户端与服务端建立HTTP长链接。Nestjs框架内置了对SSE的支持，本文详细介绍Nestjs服务端推送服务的实战步骤。使用步骤一、创建SSE接口服务跟普通的HTTP方法相同，在@nestjs/common中引入@Sse装饰器，在处理服务器推送的

NestJS 如何进行服务端推送SSE、自定义服务端推送内容

## 前言

在现代的Web应用程序开发中，无论是在数据存储、检索、还是数据流转的各个环节，数据库都扮演着极其重要的角色。MongoDB是一个基于分布式文件存储的开源数据库系统，以其高性能、高可用性和易扩展性著称。

作为JavaScript社区最受欢迎的后端框架之一，NestJS 提供了优雅的解决方案来与各种数据库进行交互，其中就包括了对MongoDB的支持。

本教程将通过一个简单而通俗的实例，带你在NestJS中集成MongoDB。我们将创建一个简易的用户管理系统，实现用户的增删改查操作。

## 准备工作

在开始之前，请确保你的开发环境中已经安装了以下软件：

- Node.js（建议使用LTS版本）
- npm 或 yarn（作为Node.js的包管理工具）
- MongoDB（你可以在本机上安装MongoDB，或者使用MongoDB Atlas服务）
- Nest CLI（通过 `npm i -g @nestjs/cli` 安装）

准备就绪后，我们可以开始动手编写代码了。

## 集成步骤

### 一、创建新的 NestJS 项目

使用 Nest CLI 创建一个新项目：

```shell
nest new nest-mongodb-example
```

进入项目目录：

```shell
cd nest-mongodb-example
```

### 二、安装 MongoDB 模块

在NestJS中操作MongoDB，我们将使用 `@nestjs/mongoose`模块，同时也需要安装mongoose：

```shell
npm install @nestjs/mongoose mongoose
```

### 三、配置 MongoDB 连接

我们需要配置NestJS应用来连接到MongoDB数据库。在 `src`目录下创建一个名为 `configs`的文件夹，并在其中创建 `mongodb.config.ts`文件：

```javascript
// src/configs/mongodb.config.ts
export default {
  uri: 'mongodb://localhost/nest-mongodb-example',
};

```

在 `app.module.ts`中导入上述配置并初始化：

```typescript
// src/app.module.ts
import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import mongodbConfig from './configs/mongodb.config';

@Module({
  imports: [
    MongooseModule.forRoot(mongodbConfig.uri),
    // ...其他模块
  ],
  controllers: [],
  providers: [],
})
export class AppModule {}

```

### 四、创建数据模型 Schema

在 MongoDB 中, 我们使用 Schema 定义数据的结构。NestJS配合Mongoose可以让我们方便的操作它。

在 `src`目录下创建一个 `users`文件夹用来组织用户相关的文件。在其中创建 `user.schema.ts`用来定义用户数据模型：

```typescript
// src/users/user.schema.ts
import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

export type UserDocument = User & Document;

@Schema()
export class User {
  @Prop({ required: true })
  username: string;

  @Prop()
  email: string;

  @Prop()
  age: number;
}

export const UserSchema = SchemaFactory.createForClass(User);

```

### 五、注册数据模型

然后创建一个对应的服务模块来提供用户的业务逻辑：

```shell
nest g module users
nest g service users
```

这将会自动生成 `users.module.ts`和 `users.service.ts`文件。

现在，我们将 `User`模型和 `UserSchema`导入到 `UsersModule`中：

```typescript
// src/users/users.module.ts
import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { User, UserSchema } from './user.schema';
import { UsersService } from './users.service';

@Module({
  imports: [
    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }])
  ],
  providers: [UsersService]
})
export class UsersModule {}

```

### 六、创建操作 MongoDB 的服务

现在，我们的 `UsersService`中可以通过依赖注入方式访问 `User`模型了。在 `users.service.ts`文件中，我们可以实现一些基本的数据库操作：

```typescript
// src/users/users.service.ts
import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { User, UserDocument } from './user.schema';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';

@Injectable()
export class UsersService {
  constructor(@InjectModel(User.name) private userModel: Model<UserDocument>) {}

  async create(createUserDto: CreateUserDto): Promise<User> {
    const createdUser = new this.userModel(createUserDto);
    return createdUser.save();
  }

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

  async findOne(id: string): Promise<User> {
    const user = this.userModel.findById(id).exec();
    if (!user) {
      throw new NotFoundException(`User with ID ${id} not found`);
    }
    return user;
  }

  async update(id: string, updateUserDto: UpdateUserDto): Promise<User> {
    const updatedUser = await this.userModel.findByIdAndUpdate(id, updateUserDto, { new: true }).exec();
    if (!updatedUser) {
      throw new NotFoundException(`User with ID ${id} not found`);
    }
    return updatedUser;
  }

  async delete(id: string): Promise<User> {
    const deletedUser = await this.userModel.findByIdAndRemove(id).exec();
    if (!deletedUser) {
      throw new NotFoundException(`User with ID ${id} not found`);
    }
    return deletedUser;
  }
}
```

### 七、实现增删改查操作

为了完成我们的CURD操作，我们还需要实现相应的 `UsersController`来处理HTTP请求。

此时我们同样应该创建DTO（Data Transfer Object）用来安全的传输数据。

首先，创建 `create-user.dto.ts`:

```typescript
// src/users/dto/create-user.dto.ts
export class CreateUserDto {
  readonly username: string;
  readonly email?: string;
  readonly age?: number;
}

// src/users/dto/update-user.dto.ts
import { PartialType } from '@nestjs/mapped-types';
import { CreateUserDto } from './create-user.dto';

export class UpdateUserDto extends PartialType(CreateUserDto) {}
```

然后创建 `UsersController`:

```shell
nest g controller users

```

在 `users.controller.ts`中实现API的接口：

```typescript
// src/users/users.controller.ts
import { Controller, Get, Post, Body, Put, Param, Delete } from '@nestjs/common';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';
import { UsersService } from './users.service';
import { User } from './user.schema';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  async create(@Body() createUserDto: CreateUserDto): Promise<User> {
    return this.usersService.create(createUserDto);
  }

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

  @Get(':id')
  async findOne(@Param('id') id: string): Promise<User> {
    return this.usersService.findOne(id);
  }

  @Put(':id')
  async update(@Param('id') id: string, @Body() updateUserDto: UpdateUserDto): Promise<User> {
    return this.usersService.update(id, updateUserDto);
  }

  @Delete(':id')
  async delete(@Param('id') id: string): Promise<User> {
    return this.usersService.delete(id);
  }
}
```

现在，我们把 `UsersModule`加入到 `AppModule`的imports数组里：

```typescript
// src/app.module.ts
import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import mongodbConfig from './configs/mongodb.config';
import { UsersModule } from './users/users.module';

@Module({
  imports: [
    MongooseModule.forRoot(mongodbConfig.uri),
    UsersModule,
    // ...其他模块
  ],
  // ...其他配置
})
export class AppModule {}

```

到这里，我们已经完成了NestJS与MongoDB的集成，以及一个用户增加和查询功能的简单例子。通过这样的方式，我们便实现了在NestJS中针对MongoDB的增删改查操作。下面是每个操作对应的功能：

- **`POST /users`** 创建用户
- **`GET /users`** 获取所有用户列表
- **`GET /users/:id`** 根据ID获取单个用户
- **`PUT /users/:id`** 根据ID更新用户信息
- **`DELETE /users/:id`** 根据ID删除用户

## 结语

集成NestJS和MongoDB是一个相对直接的过程，感谢NestJS对于Mongoose的封装，使得我们可以非常便捷地管理数据库操作和数据模型。同时，我们可以享受到TypeScript的类型安全和装饰器带来的元数据功效，使得数据库相关代码更加清晰易懂。希望本教程可以帮助你在项目中快速集成NestJS和MongoDB，并构建出强大的后端服务。


在现代的Web应用程序开发中，无论是在数据存储、检索、还是数据流转的各个环节，数据库都扮演着极其重要的角色。MongoDB是一个基于分布式文件存储的开源数据库系统，以其高性能、高可用性和易扩展性著称。作为JavaScript社区最受欢迎的后端框架之一，NestJS提供了优雅的解决方案来与各种数据库进行交互，其中就包括了对MongoDB的支持。本教程将通过一个简单而通俗的实例，带你在NestJS

如何在 NestJS 中集成 MongoDB 并实现数据的增删改查操作

## 前言

在处理高频数据操作和大规模并发请求的场合，我们需要一种机制能够快速读取和缓存数据，这时 Redis 就闪亮登场了。Redis 是一个开源的内存中数据结构存储系统，它可以用作数据库、缓存和消息中间件。

NestJS 是一个灵活且模块化的Node.js框架，它借鉴了Angular的设计哲学，提出了控制器、提供者和模块的概念，这为我们集成和使用Redis提供了便利。本文介绍如何在NestJS框架中集成Redis，并通过实际案例来展示使用Redis的优势。

## 集成步骤

### 一、 安装必要的包

在开始之前，我们需要在NestJS项目中安装 Redis 和 NestJS 对应的 Redis 模块。

```shell
npm install redis ioredis @nestjs-modules/ioredis @nestjs/common

```

这里我们使用 `ioredis`，因为它是一个健壮的、功能全面的 Redis 客户端，与 `nest-modules`相关联。

### 二、创建 Redis 模块

接下来，我们需要在 NestJS 应用中创建一个 Redis 模块。

```typescript
// redis.module.ts
import { Module } from '@nestjs/common';
import { RedisModule } from '@nestjs-modules/ioredis';

@Module({
  imports: [
    RedisModule.forRoot({
      config: {
        host: 'localhost', // Redis 服务器地址
        port: 6379,       // Redis 端口
        password: 'your_password', // 如果有设置密码的话
        db: 0,           // 如果你需要使用特定的数据库的话
      },
    }),
  ],
})
export class RedisCacheModule {}

```

在这个模块中，我们导入并配置了 Redis。我们需要确保这些配置与你的 Redis 服务器设置匹配。

### 三、在服务中使用 Redis

配置好模块后，我们可以在服务中注入 Redis 客户端，并开始实现业务逻辑。

```typescript
// app.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRedis, Redis } from '@nestjs-modules/ioredis';

@Injectable()
export class AppService {
  constructor(@InjectRedis() private readonly redis: Redis) {}

  async getHello(): Promise<string> {
    // 使用 Redis 设置值
    await this.redis.set('hello', 'Hello from Redis!');
    // 使用 Redis 获取值
    return this.redis.get('hello');
  }

  // ... 其他业务逻辑 ...
}

```

在这个服务中，我们注入了 Redis 客户端，并在 `getHello`方法中演示了如何设置和获取缓存。

### 四、控制器 Controller 调用服务

最后，让我们来创建一个控制器调用这个服务。

```typescript
// app.controller.ts
import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getHello(): Promise<string> {
    return this.appService.getHello();
  }
}

```

控制器非常简单，它使用 `@Get()`装饰器来处理根路由的 GET 请求，并调用 `appService`中的 `getHello`方法。

## 功能实现

通过将Redis集成到NestJS中，我们可以实现以下需求：

1. **数据缓存**：存储经常查询的数据提高处理速度。
2. **会话管理**：用Redis存储session信息，实现无状态的负载均衡。
3. **排行榜系统**：Redis的Sorted Set非常适合做排名操作。
4. **发布/订阅**：利用 Redis 实现分工系统，用于消息的异步处理。
5. **限流**：通过Redis的INCR和EXPIRE命令来实现API的限流。
6. **作业队列**：使用 Redis 的列表结构实现一个简单的作业队列。

### 实战：接口访问限制频率

为了控制访问速率并避免应用被过多的请求淹没，我们可以利用 Redis 来为我们的 API 接口实现限流功能。下面是一个简化的例子：

### 步骤一：实现限流拦截器

```typescript
// api-rate-limiter.interceptor.ts
import {
  Injectable,
  NestInterceptor,
  ExecutionContext,
  CallHandler,
  HttpException,
  HttpStatus,
} from '@nestjs/common';
import { Observable } from 'rxjs';
import { InjectRedis, Redis } from '@nestjs-modules/ioredis';
import { tap } from 'rxjs/operators';

@Injectable()
export class ApiRateLimiterInterceptor implements NestInterceptor {
  constructor(@InjectRedis() private readonly redis: Redis) {}

  async intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<any>> {
    const key = 'rate-limit:' + context.switchToHttp().getRequest().ip;
    const currentRequestCount = await this.redis.incr(key);

    if (currentRequestCount === 1) {
      // 设置 key 的超时时间
      await this.redis.expire(key, 60); // 限流周期为 60 秒
    }

    if (currentRequestCount > 10) {
      throw new HttpException('Too many requests', HttpStatus.TOO_MANY_REQUESTS);
    }

    return next.handle().pipe(
      tap(() => {
        // 在响应完成后，你可以在这里执行一些操作。
      }),
    );
  }
}

```

要实现的这个拦截器会检查每个 IP 地址每分钟发出的请求，并且如果请求超过10次，将会抛出 `429 Too Many Requests` 错误。

### 步骤二：项目中使用限流拦截器

将这个拦截器中间件引入到你的应用中，可以在对应的控制器或全局应用中注册。

```typescript
// 在主模块中全局注册
import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { ApiRateLimiterInterceptor } from './api-rate-limiter.interceptor';

@Module({
  // ...
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(ApiRateLimiterInterceptor)
      .forRoutes('*'); // 应用到所有的路由
  }
}

```

或者在特定的控制器上使用：

```typescript
// app.controller.ts
import { Controller, UseInterceptors, Get } from '@nestjs/common';
import { ApiRateLimiterInterceptor } from './api-rate-limiter.interceptor';

@Controller()
@UseInterceptors(ApiRateLimiterInterceptor)
export class AppController {
  // ...
}

```

## 总结

通过在 NestJS 中集成 Redis，我们不仅可以实现上述功能，还能设计更复杂的系统，如分布式系统通信、实时数据分析等等。Redis 的快速、灵活性加上 NestJS 的架构，能够让你的 Web 应用性能达到一个新的层次。


在处理高频数据操作和大规模并发请求的场合，我们需要一种机制能够快速读取和缓存数据，这时Redis就闪亮登场了。Redis是一个开源的内存中数据结构存储系统，它可以用作数据库、缓存和消息中间件。NestJS是一个灵活且模块化的Node.js框架，它借鉴了Angular的设计哲学，提出了控制器、提供者和模块的概念，这为我们集成和使用Redis提供了便利。本文介绍如何在NestJS框架中集成Redis，

如何在 NestJS 中集成 Redis 并基于 Redis 实现接口访问限频率

## 前言

Elasticsearch 是一个基于 Lucene 的开源搜索引擎。它提供了一个分布式多用户能力的全文搜索引擎，基于 RESTful web 接口。Elasticsearch 具有高弹性，支持即时和实时的复杂搜索功能。NestJS 是一个用于构建高效、可扩展的 Node.js 服务器端应用程序的框架，它使用 TypeScript 开发并且结合了 OOP（面向对象编程）、FP（函数式编程）和 FRP（函数响应式编程）。

整合 Elasticsearch 和 NestJS 可以为我们提供一种十分强大的搜索解决方案，我们可以用这个组合来建立获取及解析数据的高效应用。

## 准备工作

1. 确保你本地已经安装了 Node.js、Npm/Yarn 和 NestJS CLI 工具
2. 需要一个运行中的 Elasticsearch 实例。你可以在本地机器上进行安装或者在供应商处购买服务。

## **集成步骤**

### 一、**创建 NestJS 项目**

首先，我们需要使用 NestJS CLI 工具创建一个新的 NestJS 项目。在你的命令行中输入以下命令：

```shell
shell复制代码
nest new nest-elasticsearch-project
```

### 二、**安装 @nestjs/elasticsearch 模块**

在创建好 NestJS 项目后，我们要安装 Elasticsearch 模块。打开命令行，进入项目文件夹，然后输入以下命令：

```shell
npm install --save @nestjs/elasticsearch @elastic/elasticsearch
```

这里，**`@nestjs/elasticsearch`** 是 NestJS 的 Elasticsearch 模块，**`@elastic/elasticsearch`** 是 ElasticSearch 提供的 Node.js 客户端。

### 三、**配置 ElasticSearch Module**

接着，我们需要在根模块 (**`app.module.ts`**) 中导入并配置 **`ElasticSearch Module`**。这个模块将允许我们在整个项目中使用 ElasticSearch。

```typescript
// app.module.ts
import { Module } from '@nestjs/common';
import { ElasticsearchModule } from '@nestjs/elasticsearch';

@Module({
  imports: [
    ElasticsearchModule.register({
      node: 'http://localhost:9200',
    }),
  ],
})
export class AppModule { }
```

在这个例子中，我们假设 ElasticSearch 在本地的 9200 端口运行。如果你的 ElasticSearch 实例运行在其他地方，根据你的实际情况修改 **`node`** 的配置。

### 四、**创建服务支持使用 ElasticSearch**

现在我们可以创建一个服务来使用 ElasticSearch 了。在这个服务中，我们可以注入 **`ElasticsearchService`** 来调用 ElasticSearch 的 API。

```shell
nest generate service search
```

在生成的 **`search.service.ts`** 中，我们可以编写以下代码：

```typescript
// search.service.ts
import { Injectable } from '@nestjs/common';
import { ElasticsearchService } from '@nestjs/elasticsearch';

@Injectable()
export class SearchService {
  constructor(private readonly elasticsearchService: ElasticsearchService) { }

  async search(query: string) {
    const { body } = await this.elasticsearchService.search({
      index: 'your_index',
      body: {
        query: {
          match: { title: query },
        },
      },
    });

    return body.hits.hits.map(hit => hit._source);
  }
}
```

上面的步骤中创建了一个 **`search`** 方法，这个方法会在指定的索引中搜索匹配查询的文档。

## 实战

ElasticSearch 的优势就是支持数据的模糊搜索，然后系统数据一般会存在MySQL这种持久性数据库。为了能够实现数据的模糊搜索，我们需要将MySQL的关键数据同步到 ElasticSearch，然后利用 ElasticSearch 的模糊搜索能力实现高级搜索功能。

接下来介绍整个流程的实现步骤：

### 一、使用 TypeORM 查询 MySQL 的数据

可以基于 `typeorm` 实现对MySQL数据的操作，但是不是本文的重点，可以参考我之前写的 NestJS集成 TypeORM 的教程[https://www.levenx.com/article/how-to-implement-curd-restful-api-interface-using-nestjs-and-typeorm](https://www.levenx.com/article/how-to-implement-curd-restful-api-interface-using-nestjs-and-typeorm)

### 二、ElasticSearch 中构建数据索引

使用 TypeORM 从 MySQL 数据库中获取数据，并使用 Elasticsearch 的 Node.js 客户端在 Elasticsearch 中索引这些数据。

```typescript
// search.service.ts
import { Injectable } from '@nestjs/common';
import { ElasticsearchService } from '@nestjs/elasticsearch';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Article } from './article.entity';

@Injectable()
export class SearchService {
  constructor(
    private readonly elasticsearchService: ElasticsearchService,
    @InjectRepository(Article) 
    private readonly articleRepo: Repository<Article>,
  ) { }

  async **indexArticles**() {
    const articles = await this.articleRepo.find();
    articles.forEach(async article => {
      await this.elasticsearchService.index({
        index: 'articles',
        id: String(article.id),
        body: article,
      });
    });
  }
}

```

### 三、ElasticSearch 执行模糊搜索

```typescript
async search(query: string) {
    const { body } = await this.elasticsearchService.search({
      index: 'articles',
      body: {
        query: {
          multi_match: {
            query,
            fields: ['title', 'content'],
          },
        },
      },
    });

    return body.hits.hits.map(hit => hit._source);
  }
```

```typescript
async search(query: string) {
    const { body } = await this.elasticsearchService.search({
      index: 'articles',
      body: {
        query: {
          fuzzy: {
            title: {
              value: query,
            },
          },
        },
      },
    });

    return body.hits.hits.map(hit => hit._source);
  }
```

## 总结

Elasticsearch 是一个强大的搜索和分析引擎，而 NestJS 则是一个能够帮助我们创建可维护、可测试和可扩展的 Node.js 服务端应用的框架。将它们结合在一起，可以让我们更轻松地创建出能够拥有复杂搜索功能的应用。


Elasticsearch是一个基于Lucene的开源搜索引擎。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTfulweb接口。Elasticsearch具有高弹性，支持即时和实时的复杂搜索功能。NestJS是一个用于构建高效、可扩展的Node.js服务器端应用程序的框架，它使用TypeScript开发并且结合了OOP（面向对象编程）、FP（函数式编程）和FRP（函数响应式编程）。整合E

基于 NestJS 集成 ElasticSearch 实现模糊搜索功能

## 前言

在构建复杂的应用时，异步处理和解耦成为了关键所在，而发布订阅模式正好可以辅助实现这两点。在这篇文章中，我们将详细介绍在使用 NestJS 进行 Web 开发时，如何利用 `@nestjs/event-emitter` 包进行发布订阅模式的实现。

## 什么是发布订阅模式

发布订阅模式是一种广泛使用的消息传递方式，发布者发布消息，订阅者订阅关注的消息，然后接收这些消息。

发布者和订阅者之间不存在直接联系，它们通过消息队列或者主题进行通讯。这种模式能够确保系统的解耦，异步处理以及消息的广播。

## 发布订阅模块的优点

1. **解耦**：发布者和订阅者之间的解耦可以让我们的应用组件更独立，更加容易扩展和维护。
2. **异步处理**：发布订阅模式可以让我们的应用异步处理事件，这很重要，特别是在处理需要大量时间的任务时。
3. **广播**：我们可以向所有的订阅者广播消息，无需逐一发送。

## 发布订阅模块使用步骤

下面是如何在应用中使用 **`@nestjs/event-emitter`** 进行事件发布和订阅。

### 一、安装 @nestjs/event-emitter

首先需要安装 `@nestjs/event-emitter` 包。

```shell
npm install @nestjs/event-emitter
```

### 二、根模块导入 EventEmitterModule 模块

在你的应用模块，例如 `AppModule` 中引入 `EventEmitterModule`：

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

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

```

### 三、定义自定义事件

定义一个事件，例如 `UserCreatedEvent`：

```typescript
export class UserCreatedEvent {
  constructor(
    public readonly userId: number,
    public readonly userName: string
  ) {}
}

```

### 四、创建事件发布者

在服务中发布事件，例如在 `UsersService` 中：

```typescript
import { EventEmitter2 } from '@nestjs/event-emitter';
import { Injectable } from '@nestjs/common';
import { UserCreatedEvent } from './user-created.event';

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

  async create(userId: number, userName: string) {
    // Some business logic
    this.eventEmitter.emit('user.created', new UserCreatedEvent(userId, userName));
  }
}

```

在这个例子中，当用户创建后，我们发布一个 'user.created' 事件。

### 五、创建事件订阅者

创建一个订阅者来监听 'user.created' 事件，例如创建一个 `UserCreatedListener`：

```typescript
import { OnEvent } from '@nestjs/event-emitter';
import { Injectable } from '@nestjs/common';
import { UserCreatedEvent } from './user-created.event';

@Injectable()
export class UserCreatedListener {
  @OnEvent('user.created')
  handleUserCreatedEvent(event: UserCreatedEvent) {
    console.log(event.userId, event.userName);
  }
}

```

在这个例子中，当 `user.created` 事件被触发时，`handleUserCreatedEvent` 函数会被执行，并打印出事件的参数。确保在 `EventEmitterModule.forRoot()` 前 `UserCreatedListener` 已经被导入到模块中。

## 总结

通过以上步骤，你已经成功在 NestJS 应用中使用 `@nestjs/event-emitter` 实现了发布订阅的流程，这将帮助你构建灵活的、可扩展的和耦合度低的应用。


在构建复杂的应用时，异步处理和解耦成为了关键所在，而发布订阅模式正好可以辅助实现这两点。在这篇文章中，我们将详细介绍在使用NestJS进行Web开发时，如何利用@nestjs/event-emitter包进行发布订阅模式的实现。什么是发布订阅模式发布订阅模式是一种广泛使用的消息传递方式，发布者发布消息，订阅者订阅关注的消息，然后接收这些消息。发布者和订阅者之间不存在直接联系，它们通过消息队列或者主

如何在 NestJS 项目中优雅的使用发布订阅工具 Event Emitter

## 前言

在构建大型Web应用时，代码的组织和管理往往十分复杂。有没有一种方式可以使应用的每一个部分可以过分承担工作并保持独立，同时又能一起协作实现应用的完整功能呢？

本文将为您详细介绍NestJS模块的概念以及创建过程。NestJS模块类似于工厂中的各个部门，每个部门有一套自己的工作模式，但最终共同完成整个生产流程。通过这篇文章，您不仅将理解NestJS模块是什么，更能掌握如何创建自己的自定义模块，使你的NestJS应用更加强大和易于管理。

## 什么是 NestJS Module 模块

如果你设想一个大型工厂，各部门按照自己的功能运作，而NestJS模块就相当于这里的“部门”。具体来说，NestJS 模块（Module）是一个以类（Class）为单位，组织和封装功能模块的方式。每个部门（模块）有一组协同工作的员工（控制器、供应者等），他们协助工厂（应用程序）实现特定的功能。

## Module 模块组成部分

模块使用 `@Module()` 装饰器进行标注，接受一个描述如何组织应用的元数据对象，主要由以下四部分组成：

- **providers**：这些是应用中的“职员”们，会被Nest实例化，他们在整个应用中都可以被使用。
- **controllers**：这些是工厂的“管理员”们，定义了一组路由实例，可以处理进出工厂的“通行证”（HTTP请求）。
- **imports**：这表示工厂部门（模块）所依赖的其他部门（模块）。
- **exports**：这是一个可以被其他部门（模块）使用的职员（供应者）列表。

## 创建自定义 Module 模块

### 一、简单模块 Module

以下是创建自定义NestJS模块的步骤：

1. **新建类并添加装饰器**

   使用 `@Module()` 装饰器标注自定义模块类。

   ```typescript
   import {Module} from '@nestjs/common';

   @Module({})
   export class CustomModule {}

   ```
2. **填写元数据对象**

   在 `@Module()` 装饰器的元数据对象中定义模块的 `providers`，`controllers`，`imports` 和 `exports`。

   ```typescript
   import { Module, Controller, Get } from '@nestjs/common';

   @Controller('custom')
   class CustomController {
     @Get()
     getHello() {
       return 'Hello from custom module';
     }
   }

   @Module({
     imports: [], // 其他需要的模块列表
     controllers: [CustomController], // 定义的控制器列表
     providers: [], // 定义供应者(provider)的列表
   })
   export class CustomModule {}

   ```

   在这个例子中，我们创建了一个自定义模块，当访问 '/custom' 路径时，会返回 'Hello from custom module'。

### 二、复杂模块 Module

下面将创建一个自定义模块，包含服务（Service），控制器（Controller）和一个模块间的引用（Import）。

想象我们正在创建一个用户APP，下面我们将创建一个 'UserModule'，这个模块将导入 'DatabaseModule'，并使用 'UserService' 来完成用户相关的操作。

```typescript
import { Module } from '@nestjs/common';
import { UserController } from './user.controller';
import { UserService } from './user.service';
import { DatabaseModule } from '../database/database.module';

@Module({
  imports: [DatabaseModule], // 导入DatabaseModule
  controllers: [UserController], // 定义UserController
  providers: [UserService], // 定义UserService
  exports: [UserService], // 导出UserService，让其他模块可以使用
})
export class UserModule {}

```

在这个模块中，我们定义了：

- `DatabaseModule`: 这是我们应用程序中管理数据库操作的模块。
- `UserController`: 这个控制器处理所有的用户请求。
- `UserService`: 这个服务完成所有与用户相关的任务，包括从数据库读取用户数据等。

现在，我们假设 `DatabaseModule`、`UserController` 和 `UserService`已经被正确定义，这样我们 `UserModule` 就可以正常工作。

### 三、动态模块 Module

更进一步创建一个动态模块，可以接收配置并基于此配置来决定模块的行为。这种情况在实际开发中经常出现，例如连接数据库，每个应用可能需要不同的数据库配置信息。这就需要我们创建 `forRoot` 方法在模块中接收这些配置。

首先，让我们创建 `DatabaseModule`，这个模块将接收一些配置参数，然后根据这些参数创建数据库连接。

```typescript
import { Module, DynamicModule } from '@nestjs/common';
import { createDatabaseProviders } from './database.providers';
import { ConnectionOptions } from 'typeorm';

@Module({})
export class DatabaseModule {
  static forRoot(options: ConnectionOptions): DynamicModule {
    const providers = createDatabaseProviders(options);
    return {
      module: DatabaseModule,
      providers: providers,
      exports: providers,
    };
  }
}

```

函数 `createDatabaseProviders` 根据接收的 `options` 参数（主要是数据库链接的配置信息）恰当地创建和配置提供者。

我们的 `UserModule` 现在就可以导入 `DatabaseModule` 并提供数据库配置：

```typescript
import { Module } from '@nestjs/common';
import { UserController } from './user.controller';
import { UserService } from './user.service';
import { DatabaseModule } from '../database/database.module';

@Module({
  imports: [
    DatabaseModule.forRoot({
      type: 'mysql',
      host: 'localhost',
      port: 3306,
      username: 'test',
      password: 'test',
      database: 'test',
      entities: [],
      synchronize: true,
    }),
  ],
  controllers: [UserController],
  providers: [UserService],
  exports: [UserService],
})
export class UserModule {}

```

这是NestJS中动态模块的一个基本使用示例。通过这种方式，我们可以灵活地为模块提供配置，大大增强了模块的可复用性和扩展性。

## 总结

NestJS的模块系统为你提供了一种组织代码的优雅方式，让代码结构清晰且易于维护。希望通过本篇文章，你能明白何为NestJS模块，以及如何创建自定义模块。现在，你可以开始动手实践，创建属于自己的模块，让你的应用程序变得更加鲁棒。


在构建大型Web应用时，代码的组织和管理往往十分复杂。有没有一种方式可以使应用的每一个部分可以过分承担工作并保持独立，同时又能一起协作实现应用的完整功能呢？本文将为您详细介绍NestJS模块的概念以及创建过程。NestJS模块类似于工厂中的各个部门，每个部门有一套自己的工作模式，但最终共同完成整个生产流程。通过这篇文章，您不仅将理解NestJS模块是什么，更能掌握如何创建自己的自定义模块。且看这次

一篇文章学会使用 NestJS 的 Module 实现高效的代码模块管理

## 前言

在构建复杂的后端应用中，如何有效地管理和彼此协作的各个部分，以及如何共享和复用功能已成为开发者们重要关注的问题。覆盖这些需求的一种技术就是 NestJS 中的 Providers。这次，让我们一起深入探讨这个关键概念，解密 Providers 的奥秘，了解它们是如何提供和分配服务的。在这篇文章中，我们将学习五种主要的 Provider 类型：值提供者、类提供者、工厂提供者、异步工厂提供者和别名提供者，以及如何在实际的 NestJS 应用中使用它们。

## 什么是 Provider

Provider 是 NestJS 中的一种核心构建块，它提供了封装与分享服务逻辑的方式。实际上，你可以将 Provider 看作是一种可以注入到任何地方的对象或实体。这些对象可以是类、工厂、值甚至更复杂的结构。不管它返回什么，它的核心意图是提供一种实现不同任务的方式，例如数据访问、辅助函数，所有这些都尽可能地可复用和可测试。

## Providers 的主要类型

在 NestJS 中有五种主要的 Provider：

- 值提供者
- 类提供者
- 工厂提供者
- 异步工厂提供者
- 别名提供者

以下内容，我们将详细深入探讨这五种类型的 Provider，并给出使用案例。

### 一、值提供者 Provider

值提供者是最直接的一种类型，它直接返回一个常量或者预定义的值。且更常见的用例是，将应用的配置注入到需要读取配置的服务中。

将配置对象作为值 Provider 的例子：

```typescript
// 在模块定义中我们创建一个值 Provider
@Module({
  providers: [
    {
      provide: 'DATABASE_CONFIG',
      useValue: {
        host: 'localhost',
        port: 5432,
        user: 'dbuser',
        password: 'dbpassword',
        database: 'myDatabase'
      }
    }
  ]
})

// 在服务中，我们可以将这个值注入进来：
@Injectable()
export class DatabaseService {
  constructor(@Inject('DATABASE_CONFIG') private dbConfig: any) {}

  getConnectionDetails() {
    // 输出数据库配置信息
    console.log(this.dbConfig);
  }
}

```

### 二、类提供者 Provider

类提供者是 Provider 中常用的一种，它可以让我们通过依赖注入的方式来获取类的实例。这对复用和测试非常有价值，因为我们可以在测试时使用模拟的实例来替换真正的服务。

下面讲述了如何使用和注入类提供者的例子：

```typescript
// 我们首先在模块定义中声明一个类提供者
@Module({
  providers: [ConfigService],
})

// 接着在服务中，我们可以注入这个提供者
@Injectable()
export class UserService {
  constructor(private configService: ConfigService) {}

  getEnvironment() {
    // 输出当前应用环境
    console.log(this.configService.get('ENV'))
  }
}

```

### 三、工厂提供者 Provider

工厂提供者是最灵活的 Provider 形式。工厂函数可以返回任意值，并且可以用来执行复杂的同步或异步操作。同样的，这让我们可以根据运行时逻辑返回不同的结果或者根据不同的运行环境提供不同的实现。

下面是工厂提供者的一个例子：

```typescript
// 在模块定义中，我们创建一个工厂提供者
@Module({
  providers: [
    {
      provide: 'ENV_CONFIG',
      useFactory: () => {
        // 例如，我们可以在此基于一些环境变量返回不同的配置：
        return process.env.NODE_ENV === 'development'
          ? developmentConfig
          : productionConfig;
      },
    },
  ],
})

// 届时我们可以在服务中注入这个工厂提供者
@Injectable()
export class UserService {
  constructor(@Inject('ENV_CONFIG') private envConfig: any) {}

  getConfig() {
    // 输出当前的环境配置
    console.log(this.envConfig);
  }
}

```

### 四、异步工厂提供者 Provider

异步工厂提供者与工厂提供者在原则上是相似的，但它们返回一个 Promise 或 Observable。当 Promise 解析或者 Observable 发射出结果时，这个结果就会在应用中作为注入的值。这项特性对于需要进行异步操作来提供值的需求场景非常有用，比如数据库连接，远程配置等。

以下是异步工厂提供者的一个应用场景：

```typescript
//在模块定义中我们先定义一个异步工厂提供者
@Module({
  providers: [
    {
      provide: 'DATABASE_CONNECTION',
      useFactory: async () => {
        const options = await getDbOptions();
        return createConnection(options);
      },
    },
  ],
})

// 在服务中，我们可以注入这个数据库连接
@Injectable()
export class UserService {
  constructor(
    @Inject('DATABASE_CONNECTION') private dbConnection: Connection
  ) {}

  findUser(id: number) {
    return this.dbConnection.getRepository(User).findOne(id);
  }
}

```

在这个示例中，`DATABASE_CONNECTION` 是一个异步工厂提供者，这个提供者会异步地创建数据库连接。

### 五、别名提供者 Provider

别名提供者允许我们为提供者赋予别名，这样我们可以在不同上下文中引用并使用同样的值。这在某些需要多次引用同一个提供者或者希望使用更具语义化名称的场景中很有用。

下面是一个别名提供者的使用示例：

```typescript
// 在模块定义中，我们创建 ConfigService 的别名
@Module({
  providers: [
    ConfigService,
    {
      provide: 'AppConfig',
      useExisting: ConfigService,
    },
  ],
})

// 在服务中，我们可以使用别名来注入这个提供者
@Injectable()
export class UserService {
  constructor(@Inject('AppConfig') private configService: ConfigService) {}

  getEnvironment() {
    // 输出当前应用环境
    console.log(this.configService.get('ENV'));
  }
}

```

在这个示例中，`AppConfig` 是 `ConfigService` 的别名，所以当我们请求 `AppConfig` 的时候，我们实际上获取到的是 `ConfigService` 的实例。

## 总结

本文介绍了 NestJS 中绝大多数的 provider 类型及其使用方式。希望这篇文章能帮助你理解不同的 provider 及其适用的场景。但我们这次的探索只是冰山一角，NestJS 还有很多高级特性等待你去挖掘。


在构建复杂的后端应用中，如何有效地管理和彼此协作的各个部分，以及如何共享和复用功能已成为开发者们重要关注的问题。覆盖这些需求的一种技术就是NestJS中的Providers。这次，让我们一起深入探讨这个关键概念，解密Providers的奥秘，了解它们是如何提供和分配服务的。在这篇文章中，我们将学习五种主要的Provider类型：值提供者、类提供者、工厂提供者、异步工厂提供者和别名提供者，以及如何在

一篇文章学会如何使用 NestJS 的五种 Provider 提供者

## 前言

如果你是一个正在学习NestJS的开发者，那么这篇文章将会为你展示如何通过管道来进行数据验证和转换，你会发现这是一个强大的工具，能够极大地提高你的开发效率。对于已经熟悉NestJS的开发者，本文的内容也会帮助你更好地理解和应用管道的概念。

## 什么 是 NestJS 的管道(Pipes)

NestJS管道(Pipes)是NestJS框架的一部分，它主要是用于处理和解析来自客户端的输入数据，然后将数据传递给请求处理器或下一个管道。在NestJS中，管道主要可以用于两种情况：数据转换和验证。

## NestJS 的管道(Pipes)的使用场景

- **数据转换**

  管道也可以用来转换输入数据。例如，可以把字符串类型的数据转换为数字或者日期对象。
- **默认值设定**

  在某些情况下，我们可能希望为某些字段提供默认值。例如，用户可选地提供一个“页数”字段来控制分页查询的返回数据，但如果用户没有提供这个字段，我们可能需要设置一个默认值。这种情况下，管道可以在输入数据中插入缺失的默认值。
- **数据验证**

  管道可以用来验证传入的请求数据，以确保它符合应用的期望需求。如果数据无效或缺失，管道可以返回一个错误。
- **业务规则验证**

  除了内建的验证装饰器，如**`@IsString()`**或** `@IsNotEmpty()`**等，我们也可以在管道中实现更复杂的自定义验证逻辑。例如，我们可能需要确保用户名在系统中是唯一的。
- **复杂对象装配**

  在某些情况下，我们可能需要对输入数据进行复杂的处理，以构建出一个复杂的对象。在这种场景下，管道可以被用来应对这种复杂的逻辑。

## 如何使用 NestJS 的管道(Pipes)

### 场景一：数据验证

现在假设我们在开发一个博客系统，我们需要验证从客户端传来的文章的标题和内容是否合格。我们可以创建一个管道实现这个功能。

首先，我们需要安装 `class-validator`和 `class-transformer`这两个包。

```shell
$ npm i --save class-validator class-transformer

```

然后我们创建一个DTO(Data Transfer Object)来规定文章的数据结构：

```javascript
import { IsString, IsNotEmpty } from 'class-validator';

export class CreatePostDto {
  @IsString()
  @IsNotEmpty()
  readonly title: string;

  @IsString()
  @IsNotEmpty()
  readonly content: string;
}

```

在这里，我们使用了 `@IsString()`和 `@IsNotEmpty()`装饰器来指定规则。然后，我们将此DTO作为参数传递给控制器：

```javascript
import { Body, Post, Controller, UsePipes, ValidationPipe } from '@nestjs/common';
import { CreatePostDto } from './create-post.dto';

@Controller('posts')
export class PostsController {
  @Post()
  @UsePipes(ValidationPipe)
  create(@Body() createPostDto: CreatePostDto) {
    // ...处理创建文章的逻辑
  }
}

```

在这个例子中，我们通过在 `@Post()`装饰器方法上使用 `@UsePipes(new ValidationPipe())`装饰器来应用管道。

### 场景二：数据转换

让我们假设您希望将数字类型的字符串转换为真正的数字。我们可以创建一个管道来实现这个需求。

```javascript
import { PipeTransform, Injectable, ArgumentMetadata } from '@nestjs/common';

@Injectable()
export class ParseIntPipe implements PipeTransform {
  transform(value: any, metadata: ArgumentMetadata) {
    const val = parseInt(value, 10);
    if (isNaN(val)) {
      throw new Error('Validation failed');
    }
    return val;
  }
}

```

然后在控制器中使用这个管道：

```javascript
import { Controller, Get, Param, ParseIntPipe } from '@nestjs/common';

@Controller('cats')
export class CatsController {
  @Get(':id')
  findOne(@Param('id', ParseIntPipe) id: number) {
    // id现在是个数字，而非字符串
    // ...处理具体的查询逻辑
  }
}

```

希望这篇文章能帮你理解NestJS的管道(Pipes)以及如何使用它们。在结构化编程和编写可维护代码方面，NestJs的管道可发挥重要作用。继续探索并学习这方面的知识将使你受益良多。

### 场景三：**默认值设定**

我们希望在用户进行分页查询时，如果他们没有提供“页数”信息，系统能自动设定一个默认值。可以创建一个管道来实现这个需求。

```javascript
import { PipeTransform, Injectable, ArgumentMetadata } from '@nestjs/common';

@Injectable()
export class OptionalParseIntPipe implements PipeTransform {
  private readonly defaultValue: number;

  constructor(defaultValue: number) {
    this.defaultValue = defaultValue;
  }

  transform(value: any, metadata: ArgumentMetadata) {
    const val = parseInt(value, 10);
    if (isNaN(val)) {
      return this.defaultValue;
    }
    return val;
  }
}

```

然后在控制器中使用这个管道：

```javascript
import { Controller, Get, Query, DefaultValuePipe } from '@nestjs/common';

@Controller('posts')
export class PostsController {
  @Get()
  fetch(@Query('page', new OptionalParseIntPipe(1)) page: number) {
    // 如果用户没提供page参数，page的默认值就是1
    // ...处理具体的查询逻辑
  }
}

```

### 场景四：业务规则验证

我们需要确保用户注册时，所输入的用户名在系统中是唯一的。可以创建一个管道来实现这个需求。

首先创建一个 `UserService`用于查询用户名：

```javascript
import { Injectable } from '@nestjs/common';

@Injectable()
export class UserService {
  async isUsernameUnique(username: string): Promise<boolean> {
    // ... 这里应该查询数据库，返回一个Promise，表示用户名是否唯一
  }
}

```

然后创建一个用户名验证管道：

```javascript
import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';

@Injectable()
export class UniqueUsernamePipe implements PipeTransform {
  constructor(private readonly userService: UserService) {}

  async transform(value: any, metadata: ArgumentMetadata) {
    const isUnique = await this.userService.isUsernameUnique(value);
    if (!isUnique) {
      throw new BadRequestException('Username is already taken!');
    }
    return value;
  }
}

```

在控制器中应用这个管道：

```javascript
import { Controller, Post, Body } from '@nestjs/common';

@Controller('users')
export class UsersController {
  @Post('register')
  async register(@Body('username', UniqueUsernamePipe) username: string) {
    // ... 处理具体的注册逻辑
  }
}

```

### 场景五：复杂对象装配

假设我们在创建文章时，需要为文章提供一个作者信息。作者信息通过id从数据库中获取，我们可以创建一个管道来实现这个需求。

```javascript
import { PipeTransform, Injectable, ArgumentMetadata, NotFoundException } from '@nestjs/common';
import { UsersService } from './users.service';

@Injectable()
export class UserByIdPipe implements PipeTransform {
  constructor(private readonly usersService: UsersService) {}

  async transform(value: any, metadata: ArgumentMetadata) {
    const user = await this.usersService.findById(value);
    if (!user) {
      throw new NotFoundException(`User with id ${value} not found`);
    }
    return user;
  }
}

```

然后在控制器中使用这个管道：

```javascript
import { Controller, Post, Body } from '@nestjs/common';

@Controller('posts')
export class PostsController {
  @Post()
  async create(@Body('authorId', UserByIdPipe) author: User) {
    // 现在，author 的值是一个用户对象，我们可以使用它来创建文章
    // ... 处理创建文章的逻辑
  }
}

```

## 总结

至此，我们已经对NestJS的管道有了更为深入的理解，包括了它的定义、使用场景以及怎样在具体的场合中使用它。无论是对于数据验证还是数据转换，它都有非常显著的效果，并且为我们的开发过程提供了很大的便利。然而，以上只是初步应用，NestJs的管道的强大之处远不止于此。


如果你是一个正在学习NestJS的开发者，那么这篇文章将会为你展示如何通过管道来进行数据验证和转换，你会发现这是一个强大的工具，能够极大地提高你的开发效率。对于已经熟悉NestJS的开发者，本文的内容也会帮助你更好地理解和应用管道的概念。什么是NestJS的管道(Pipes)？NestJS管道(Pipes)是NestJS框架的一部分，它主要是用于处理和解析来自客户端的输入数据，然后将数据传递给请求

 一篇文章学会如何使用 NestJS 的 管道Pipes 实现高效的数据转换和验证

## 前言

TypeORM 是一个在 TypeScript 和 JavaScript (ES7, ES6, ES5) 中提供了许多开箱即用特性的 ORM，它能够改善我们处理数据库操作的效率与可维护性。在复杂的应用开发过程中，数据间的关系处理显得尤其重要。今天我们将在 NestJS 中探索 TypeORM 的 ManyToMany（多对多）关系，这是一种常见且强大的数据模型关系。在建立应用程序时，我们通常需要处理大量的增删查改（CRUD）操作，而 ManyToMany 关系的有效应用能够让这些操作变得更为简洁、优雅。

## 使用步骤

### 一、安装依赖

首先需要在我们的 NestJS 应用中安装并设置 TypeORM。在你的项目根目录下执行以下命令：

```text
npm install --save @nestjs/typeorm typeorm

```

### 二、模块初始化

在项目的 **`app.module.ts`** 文件中进行 TypeORM 的设置。

```typescript
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { Author } from './author.entity';
import { Book } from './book.entity';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'test',
      password: 'test',
      database: 'test',
      entities: [Author, Book],
      synchronize: true,
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})

export class AppModule {}

```

### 三、建立多对多的实体关系

我们创建 `作者`**和** `书籍`这两个实体。作者可以写多本书，一本书也可以有多个作者。

_**Author**_

```typescript
import {Entity, Column, ManyToMany, PrimaryGeneratedColumn, JoinTable} from 'typeorm';
import { Book } from './book.entity';

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

  @Column()
  name: string;

  @ManyToMany(type => Book, book => book.authors)
  @JoinTable()
  books: Book[];
}

```

_**Book**_

```typescript
import {Entity, Column, ManyToMany, PrimaryGeneratedColumn} from 'typeorm';
import { Author } from './author.entity';

@Entity()
export class Book {

    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    title: string;

    @ManyToMany(type => Author, author => author.books)
    authors: Author[];
}

```

### 四、实现对应的服务层

为了创建作者和他们的书籍，我们需要创建一个服务。服务通过依赖注入来定义在各个模块之间的关系，你需要记住的一点是：在 NestJS 中，你需要使用 Repository 来操作数据库。

_**Author Service**_

```typescript
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Author } from './author.entity';
import { Book } from './book.entity';

@Injectable()
export class AuthorService {
  constructor(
    @InjectRepository(Author)
    private authorRepository: Repository<Author>,
    @InjectRepository(Book)
    private bookRepository: Repository<Book>,
  ) {}

  async createAuthorWithBooks() {
    const author = this.authorRepository.create({ name: 'John Doe' });

    const book1 = this.bookRepository.create({
      title: 'Book #1',
    });
    const book2 = this.bookRepository.create({
      title: 'Book #2',
    });

    author.books = [book1, book2];

    await this.authorRepository.save(author);
    // ...
  }
}

```

### 五、多对多的增删改查操作

- **新增 Create**

  在 AuthorService 中，我们已经创建了 **`createAuthorWithBooks`** 方法，可以同时创建作者和对应的书籍：

  ```typescript
  async createAuthorWithBooks() {
      const author = this.authorRepository.create({ name: 'John Doe' });

      const book1 = this.bookRepository.create({
        title: 'Book #1',
      });

      const book2 = this.bookRepository.create({
        title: 'Book #2',
      });

      author.books = [book1, book2];

      await this.authorRepository.save(author);
    }
  ```
- **删除 Remove**

  删除某一本书，可以通过 **`remove`** 方法来达成：

  ```typescript
  async deleteBook(bookId: number) {
    let toDelete = await this.bookRepository.findOne(bookId);
    let deleted = false;
    if (toDelete) {
      await this.bookRepository.remove(toDelete);
      deleted = true;
    }
    return { deleted };
  }

  ```
- **修改 Update**

  假设我们要更新某一本书的信息，可以通过 **`update`** 方法来操作：

  ```typescript
  async updateBook(bookId: number, updatedTitle: string) {
    let toUpdate = await this.bookRepository.findOne(bookId);
    let updated = false;
    if (toUpdate) {
      toUpdate.title = updatedTitle;
      await this.bookRepository.save(toUpdate);
      updated = true
    }
    return { updated };
  }

  ```
- **查询 Search**

  例如我们想要查找一个作者所有的书，可以创建如下方法：

  ```typescript
  async findBooksByAuthor(authorId: number) {
    return this.bookRepository.createQueryBuilder("book")
        .innerJoinAndSelect("book.authors", "author")
        .where("author.id = :authorId", { authorId })
        .getMany();
  }

  ```
- 列表查询

  假设我们想要查询所有的作者列表，可以通过 **`find`** 方法实现：

  ```typescript
  async findAllAuthors() {
    return await this.authorRepository.find();
  }

  ```

## 进阶操作

### 一、分页查询

当你的数据太多，你可能需要进行分页查询。我们可以使用 **`take`** 和 **`skip`** 方法进行分页查询。

下面这个方法展示了如何获取第二页的作者，每页有5个作者：

```typescript
async findAuthorsPagination(page: number) {
  return await this.authorRepository.find({
     take: 5,
     skip: 5 * (page - 1),
  });
}

```

在这个方法中, **`take`** 表示要获取的条数，**`skip`** 表示要跳过的条数。

### 二、关联查询

假设我们需要获取包含了一个作者的所有书的信息，我们就需要做一个关联查询：

```typescript
async findAuthorAndBooks(authorId: number) {
  return this.authorRepository.findOne(authorId, { relations: ["books"] });
}

```

这个 **`findOne`** 方法会返回一个 **`Author`** 对象，该对象包含一个 **`Book`** 对象的数组，表示该作者写的所有书。

## 总结

在使用 NestJS 和 TypeORM 进行开发时，我们已经掌握了 ManyToMany（多对多）关系的设定、如何进行基础的 CRUD（增删查改）操作，还了解了列表查询、分页查询及关联查询的实现方式。最后，不要忘记，TypeORM 的 ManyToMany 关系默认情况下是懒加载的，使得我们在需要时才去加载关联数据，提升了程序的运行效率。借助 NestJS 和 TypeORM，我们能够轻松处理复杂的数据关联关系，提升开发效率。


TypeORM是一个在TypeScript和JavaScript(ES7,ES6,ES5)中提供了许多开箱即用特性的ORM，它能够改善我们处理数据库操作的效率与可维护性。在复杂的应用开发过程中，数据间的关系处理显得尤其重要。今天我们将在NestJS中探索TypeORM的ManyToMany（多对多）关系，这是一种常见且强大的数据模型关系。在建立应用程序时，我们通常需要处理大量的增删查改（CRUD）

基于 NestJS 操作 TypeORM 中的多对多 ManyToMany

## 前言

TypeORM 是一个在 TypeScript 和 JavaScript (ES7, ES6, ES5) 中提供了许多开箱即用特性的 ORM，它能够改善我们处理数据库操作的效率与可维护性。在复杂的应用开发过程中，数据间的关系处理显得尤其重要。今天我们将在 NestJS 中探索 TypeORM 的 OneToMany（一对多）关系，这是一种常见且强大的数据模型关系。在建立应用程序时，我们通常需要处理大量的增删查改（CRUD）操作，而 OneToMany 关系的巧妙应用能够让这些操作变得更为简洁、优雅。

## 使用步骤

### 一、安装依赖

首先需要在我们的 NestJS 应用中安装并设置 TypeORM。在你的项目根目录下执行以下命令：

```shell
npm install --save @nestjs/typeorm typeorm
```

### 二、模块初始化

在项目的 **`app.module.ts`** 文件中进行 TypeORM 的设置。

```typescript
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { Author } from './author.entity';
import { Post } from './post.entity';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'test',
      password: 'test',
      database: 'test',
      entities: [Author, Post],
      synchronize: true,
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})

export class AppModule {}
```

### 三、**建立一对多的实体关系**

我们创建**`作者`**和** `文章`**这两个实体。先建立** `作者实体`**，再设定** `文章实体`**。

_**Author**_

```typescript
import {Entity, Column, OneToMany, PrimaryGeneratedColumn} from 'typeorm';
import { Post } from './post.entity';

@Entity()
export class Author {
  @PrimaryGeneratedColumn()
  id: number;
  
  @Column()
  name: string;

  @OneToMany((type) => Post, (post) => post.author)
  posts: Post[];
}
```

_**Post**_

```typescript
import {Entity, PrimaryGeneratedColumn, Column, ManyToOne} from 'typeorm';
import { Author } from './author.entity';

@Entity()
export class Post {

    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    title: string;

    @ManyToOne((type) => Author, (author) => author.posts)
    author: Author;
}
```

### 四、实现对应的服务层

为了创建作者和他的文章，我们需要创建一个服务。服务通过依赖注入来定义在各个模块之间的关系，你还需要记住的一点是：在 NestJS 中，你需要使用 Repository 来操作数据库。而 **`InjectRepository()`** 装饰器会帮助我们自动创建并注册这个 Repository。

_**Author Service**_

```typescript
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Author } from './author.entity';
import { Post } from './post.entity';

@Injectable()
export class AuthorService {
  constructor(
    @InjectRepository(Author)
    private authorsRepository: Repository<Author>,
    @InjectRepository(Post)
    private postsRepository: Repository<Post>,
  ) {}

  async createAuthorWithPosts() {
    const author = this.authorsRepository.create({ name: 'John Doe' });

    const post1 = this.postsRepository.create({
      title: 'Post #1',
      author,
    });
    const post2 = this.postsRepository.create({
      title: 'Post #2',
      author,
    });

    author.posts = [post1, post2];

    await this.authorsRepository.save(author);
    // ... 
  }
}
```

### 五、一对多的增删改查操作

- **新增 Create**

  在 AuthorService 中，我们已经创建了 **`createAuthorWithPosts`** 方法，可以同时创建作者和对应的文章：

  ```typescript
  async createAuthorWithPosts() {
    const author = this.authorsRepository.create({ name: 'John Doe' });

    const post1 = this.postsRepository.create({
      title: 'Post #1',
      author,
    });

    const post2 = this.postsRepository.create({
      title: 'Post #2',
      author,
    });

    author.posts = [post1, post2];

    await this.authorsRepository.save(author);
  }
  ```
- **删除 Remove**

  删除某一篇文章，可以通过 **`remove`** 方法来达成：

  ```typescript
  async deletePost(postId: number) {
    let toDelete = await this.postsRepository.findOne(postId);
    let deleted = false;
    if (toDelete) {
      await this.postsRepository.remove(toDelete);
      deleted = true;
    }
    return { deleted };
  }
  ```
- **修改 Update**

  假设我们要更新某一篇文章的信息，可以通过 **`update`** 方法来操作：

  ```typescript
  async updatePost(postId: number, updatedTitle: string) {
    let toUpdate = await this.postsRepository.findOne(postId);
    let updated = false;
    if (toUpdate) {
      toUpdate.title = updatedTitle;
      await this.postsRepository.save(toUpdate);
      updated = true
    }
    return { updated };
  }
  ```
- **查询 Search**

  例如我们想要查找一个作者所有的文章，可以创建如下方法：

  ```typescript
  async findPostsByAuthor(authorId: number) {
    return this.postsRepository.createQueryBuilder("post")
        .innerJoinAndSelect("post.author", "author")
        .where("author.id = :authorId", { authorId })
        .getMany();
  }
  ```
- 列表查询

  假设我们想要查询所有的作者列表，可以通过 **`find`** 方法实现：

  ```typescript
  async findAllAuthors() {
    return await this.authorsRepository.find();
  }
  ```

## 进阶操作

### 一、分页查询

当你的数据太多，你可能需要进行分页查询。我们可以使用 **`take`** 和 **`skip`** 方法进行分页查询。

下面这个方法展示了如何获取第二页的作者，每页有5个作者：

```typescript
async findAuthorsPagination(page: number) {
  return await this.authorsRepository.find({
     take: 5,
     skip: 5 * (page - 1),
  });
}
```

在这个方法中, **`take`** 表示要获取的条数，**`skip`** 表示要跳过的条数。

### 二、**关联查询**

在我们有了OneToMany的关系后, 假设我们需要获取包含了一个作者的所有文章的信息, 那我们就需要做一个关联查询：

```typescript
async findAuthorAndPosts(authorId: number) {
  return this.authorsRepository.findOne(authorId, { relations: ["posts"] });
}
```

这个 **`findOne`** 方法会返回一个 **`Author`** 对象，该对象包含一个 **`Post`** 对象的数组，表示该作者写的所有文章。

## 总结

在使用 NestJS 和 TypeORM 进行开发时，我们已经掌握了 OneToMany（一对多）关系的设定、如何进行基础的 CRUD（增删查改）操作，还了解了列表查询、分页查询及关联查询的实现方式。最后，不要忘记，TypeORM 的 OneToMany 关系默认情况下是懒加载的，使得我们在需要时才去加载关联数据，提升了程序的运行效率。借助 NestJS 和 TypeORM，我们能够轻松处理复杂的数据关联关系，提升开发效率。


TypeORM是一个在TypeScript和JavaScript(ES7,ES6,ES5)中提供了许多开箱即用特性的ORM，它能够改善我们处理数据库操作的效率与可维护性。在复杂的应用开发过程中，数据间的关系处理显得尤其重要。今天我们将在NestJS中探索TypeORM的OneToMany（一对多）关系，这是一种常见且强大的数据模型关系。在建立应用程序时，我们通常需要处理大量的增删查改（CRUD）操

基于 NestJS 操作 TypeORM 中的一对多 OneToMany

## 前言

当我们基于NestJS框架构建和管理应用程序时，为了保障其安全性，我们常常需要对某些敏感操作或敏感信息的访问进行限制，这是我们需要使用到 **守卫** 的地方。它作为一种可以阻止未经授权的访问的机制，对我们的应用程序起到了守护的作用。

在这篇文章中，我将深入剖析 NestJS 的守卫，以帮您全面了解这个概念。我会从解释其背后的工作机制开始，接着介绍使用守卫的各种场景，并以详细的示例来演示如何在 NestJS 项目中实现和使用守卫。

## **什么是 Guards 守卫**

在去解析NestJS的守卫之前，我们先来简单了解一下NestJS。NestJS是一种设计用于构建高效，可扩展的 Node.js 服务器端应用程序的框架。它使用渐进式 JavaScript，内置并完全支持 TypeScript，并结合了 OOP、FP 和 FRP 的元素。

既然我们已经对NestJS有了基本的理解，那么，什么是NestJS的守卫(Guards)呢？简单来说，守卫（Guards）是NestJS中的一个概念，其职责就像其名字一样，它起到了保护我们应用程序不被未经授权的访问的作用。在特定的路由处理程序执行之前，守卫负责确定请求是否应该被路由处理程序处理。

## 使用场景

守卫通常用于身份验证和授权，也就是在执行业务代码之前验证用户是否有权做出某个操作。

例如，在许多应用程序中，你需要防止未经授权的用户访问敏感信息或执行特定的操作。若用户请求查看或修改某些只有特定权限或角色才能查看或修改的数据时，守卫即可起到“守门人”的作用。

## 使用案例

### 一、**创建一个身份验证守卫**

我们首先要创建一个 **`AuthGuard`** 类并注入它。这个类需要实现 **`CanActivate`** 接口并实现 **`canActivate`** 方法：

```typescript
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Observable } from 'rxjs';

@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    const request = context.switchToHttp().getRequest();
    // 添加你的身份验证逻辑
    // For example:
    return validateRequest(request);
  }
}
```

在上面的示例中，我们首先从 **`@nestjs/common`** 包导入了 **`Injectable`**，**`CanActivate`** 和 **`ExecutionContext`**。然后，我们创建了一个 **`AuthGuard`** 类，它会实现 **`CanActivate`** 接口，这个接口要求我们实现 **`canActivate`** 方法。

在这个方法中，我们首先获取上下文请求对象。然后，我们可以在这个方法中执行我们需要的任何判断逻辑，比如检查请求中是否包含有效的 JWT 令牌。

### 二、使用身份验证守卫（控制器维度）

现在，我们已经创建了守卫，那该如何使用呢？其实非常简单，我们只需要在控制器或者具体路由上添加 **`@UseGuards()`** 装饰器：

```typescript
import { Controller, Get, UseGuards } from '@nestjs/common';
import { AuthGuard } from './auth.guard';

@Controller('users')
@UseGuards(AuthGuard)
export class UserController {
  
  @Get()
  findAll() {
    return "这个操作返回所有的猫，只有通过身份验证的用户能看到!";
  }
}
```

这样，我们就可以确保只有通过 `AuthGuard` 权限认证的用户才能够访问到我们的 **`CatsController`** 控制器中的所有路由。

### 三、使用身份验证守卫（路由维度）

如果你只希望在某个特定的路由上应用这个守卫，而不是整个控制器，你可以将 **`UseGuards`** 装饰器应用于具体的路由处理函数：

```typescript
import { Controller, Get, UseGuards } from '@nestjs/common';
import { AuthGuard } from './auth.guard';

@Controller('cats')
export class CatsController {
  
  @Get()
  @UseGuards(AuthGuard)
  findOne() {
    return "这个操作返回一只猫，只有通过身份验证的用户能看到!";
  }
}
```

## 总结

以上我们已经展示了如何创建和使用自定义守卫。然而，在真实的业务场景中，可能会有更复杂的情况，比如基于角色的访问控制(Role-Based Access Control, RBAC)。这种情况下，你的守卫可能需要复杂的逻辑来确定一个用户能接触哪些资源。这些都是你可以使用守卫来处理的场景。

总的来说，NestJS 的守卫是一个非常强大的工具，特别是对于大型和复杂的项目，在权限判断上，使用守卫可以极大地提高代码的可维护性和安全性。


当我们基于NestJS框架构建和管理应用程序时，为了保障其安全性，我们常常需要对某些敏感操作或敏感信息的访问进行限制，这是我们需要使用到守卫的地方。它作为一种可以阻止未经授权的访问的机制，对我们的应用程序起到了守护的作用。在这篇文章中，我将深入剖析NestJS的守卫，以帮您全面了解这个概念。我会从解释其背后的工作机制开始，接着介绍使用守卫的各种场景，并以详细的示例来演示如何在NestJS项目中实现

一篇文章学会如何使用 NestJS 的 Guards 守卫实现系统身份验证和授权

## 前言

当我们基于NestJS框架构建和管理应用程序时，常常需要在特定的阶段执行一些额外的操作，例如在接收请求时进行身份验证，或在发送响应之前添加一些自定义的HTTP头。这就是我们需要理解和使用NestJS中间件的原因 ——它就像一道门，所有的请求必须要过这道门，而我们可以在门上挂上各种“魔法”，使得我们的应用程序更强大、更容易管理。

## **什么是NestJS中间件**

NestJS中间件实际上就是一个函数，这个函数可以对请求或响应对象进行一些操作，或者在传递给下一个处理程序之前进行一些预处理。具体来说，一般使用中间件处理以下几个场景：

1. **认证：** 验证用户的身份，只有经过验证的用户才能对某些资源进行访问。
2. **日志记录：** 记录请求的详细信息，如请求时间、来源IP、目标URL等，这对于审计和错误追踪非常有用。
3. **请求解析：** 对请求参数进行解析，并进行一些必要的格式化和验证操作。
4. **错误处理：** 对请求处理过程中产生的错误进行统一的处理。

## 使用案例

### 一、日志记录中间件

假设我们需要对每个到服务器的请求进行日志记录，我们可以定义一个日志中间件，如下所示：

```typescript
import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: Function) {
    console.log('Received request:', req.method, req.originalUrl);
    next();
  }
}
```

然后在应用模块中使用这个中间件：

```typescript
import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { LoggerMiddleware } from './logger.middleware';

@Module({})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(LoggerMiddleware).forRoutes('*');
  }
}
```

现在，每个到达我们服务器的请求都会在控制台输出它的HTTP方法和URL。

### 二、身份认证中间件

在这个例子中，我们定义一个中间件，它会检查每个请求的授权头部，如果没有这个头部，它会返回一个错误信息；如果有这个头部，它会进行验证，验证成功后才会将请求传递给下一个处理程序。

```typescript
import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response } from 'express';

@Injectable()
export class AuthMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: Function) {
    if (!req.headers.authorization) {
      return res.status(403).json({ message: 'No Authorization Header' });
    }
    // 验证授权头部...
    next();
  }
}
```

然后在应用模块中使用这个中间件：

```typescript
import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { AuthMiddleware } from './auth.middleware';

@Module({})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
    .apply(AuthMiddleware).forRoutes('*');
  }
}
```

这样一来，只有经过有效验证的用户才能访问我们服务器上的资源。

### 三、**请求解析中间件**

NestJS框架提供了一个**内置的请求解析中间件**，可以将请求主体解析成我们所想要的格式，例如JSON。这样，我们可以在路由处理函数中直接处理这些数据。使用这个内置的中间件非常简单，只需要在主模块中添加以下代码：

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

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.use(express.json());
  await app.listen(3000);
}
bootstrap();
```

现在，当我们接收到带有JSON主体的POST请求时，我们可以在路由处理函数中直接使用这些数据。为了演示这个，假设我们有一个只接受JSON数据的路由：

```typescript
import { Controller, Post, Body } from '@nestjs/common';

@Controller('route')
export class MyController {
  @Post()
  postData(@Body() data: any) {
    // 我们可以直接处理JSON数据
    console.log(data);
  }
}
```

### 四、**错误处理中间件**

错误处理是Web开发中常见的一个需求，NestJS同样可以通过中间件的方式处理错误。例如，我们可以创建一个错误处理中间件来捕获抛出的异常，然后将它们格式化为JSON响应：

```typescript
import { Injectable, NestMiddleware, ExpressMiddleware } from '@nestjs/common';
import { NextFunction, Request, Response } from 'express';

@Injectable()
export class ErrorHandlerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    try {
      next();
    } catch (err) {
      res.status(500).json({
         message: 'Internal server error',
         ...err,
      });
    }
  }
}
```

然后我们需要在模块中将此中间件应用到环路：

```typescript
import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { ErrorHandlerMiddleware } from './error-handler.middleware';

@Module({})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(ErrorHandlerMiddleware).forRoutes('*');
  }
}
```

## 总结

总的来说，NestJS中间件就像是一个可定制的、灵活性极高的管道，它可以让我们预处理请求、扩展响应或者组织我们的业务逻辑。它的威力不仅在于能够处理各种边缘情况，更在于它的扩展性和可维护性，这两个强大的特性让我们可以根据项目的需要自定义适合的中间件，从而开发出高效、健壮的后端服务。


当我们基于NestJS框架构建和管理应用程序时，常常需要在特定的阶段执行一些额外的操作，例如在接收请求时进行身份验证，或在发送响应之前添加一些自定义的HTTP头。这就是我们需要理解和使用NestJS中间件的原因——它就像一道门，所有的请求必须要过这道门，而我们可以在门上挂上各种“魔法”，使得我们的应用程序更强大、更容易管理。什么是NestJS中间件NestJS中间件实际上就是一个函数，这个函数可以

一篇文章学会 NestJS 中间件的使用，让你的应用更灵活和可扩展

# 前言

在实际的应用开发中，你或许遇到过异常处理机制不统一或错误信息展示混乱的现象。为了解决这些问题，NestJS提供了一个优雅的解决方案：过滤器（Filter）。本文将从实际出发，向你介绍NestJS过滤器的基本概念，重要用途和深度实例。

## 什么是NestJS的过滤器

当一个程序运行过程中发生了异常，并且这个异常没有被捕获处理，用户就会看到一些奇怪的错误信息，这种现象对用户体验非常不好。此时，NestJS的过滤器就登场啦！过滤器可以用来捕捉未被处理的异常，然后以一种更有秩序、更友好的方式显示，极大提升了用户体验。

## NestJS过滤器的使用场景

接下来，我们将通过一些代码片段来解析过滤器在不同场景下的应用。

1. **全局错误处理**

   创建一个全局过滤器来捕获所有未被处理的异常，以一致的风格返回给用户。

```typescript
@Catch()
export class GlobalFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    // 统一处理异常，返回友好的错误信息
  }
}
// 在main.ts中全局使用
app.useGlobalFilters(new GlobalFilter());

```

1. **定制HTTP响应**

   可以用过滤器自定义服务器的响应格式。

```typescript
@Catch()
export class TransformFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    // 按照自定义的方式来配置返回的HTTP响应
  }
}
// 在特定的路由或控制器使用
@UseFilters(new TransformFilter())
@Controller('example')
export class ExampleController {
}

```

1. **异常记录**

   在捕获异常的同时，使用过滤器记录错误信息。

```typescript
@Catch()
export class LoggingFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    // 记录异常堆栈信息
    console.error(exception);
  }
}
// 在全局或特定路由使用
app.useGlobalFilters(new LoggingFilter());

```

## 使用案例

下面是两个具体的过滤器使用案例，我们会在代码旁边添加详细注释，帮助你理解代码的每个部分。

### 案例一：全局异常过滤器

```typescript
@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();
    const status = exception instanceof HttpException ? exception.getStatus() : 500;

    // 以统一的JSON格式返回错误信息
    response
      .status(status)
      .json({
        statusCode: status,
        timestamp: new Date().toISOString(),
        path: request.url,
      });
  }
}
// 在主文件中全局注册这个过滤器
app.useGlobalFilters(new AllExceptionsFilter());

```

### 案例二：记录异常过滤器

```typescript
@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    // 将异常信息输出到控制台
    console.error(`Exception occurred: ${exception.message}`);
  }
}
// 在指定的控制器或方法上通过使用装饰器使用这个过滤器
@UseFilters(HttpExceptionFilter)
export class ExampleController {
}

```

## 总结

上面例子展示了NestJS过滤器强大的自定义能力，我们可以按照应用程序的需要来实现复杂的异常处理逻辑。但是，请注意，在过滤器中应避免进行太复杂的操作，以免增加调试的难度和系统的复杂性。


在实际的应用开发中，你或许遇到过异常处理机制不统一或错误信息展示混乱的现象。为了解决这些问题，NestJS提供了一个优雅的解决方案：过滤器（Filter）。本文将从实际出发，向你介绍NestJS过滤器的基本概念，重要用途和深度实例。什么是NestJS的过滤器当一个程序运行过程中发生了异常，并且这个异常没有被捕获处理，用户就会看到一些奇怪的错误信息，这种现象对用户体验非常不好。此时，NestJS的过

一篇文章学会如何使用 NestJS 过滤器处理全局异常情况

## 前言

在现代Web开发的世界中，NestJS以其灵活性和强大的功能立足，成为Node.js框架的佼佼者。其中一个引人注目的功能就是**拦截器**，这是一种可以让开发者更好地控制和补充HTTP请求循环的工具。拦截器让开发者可以在处理程序之前或之后“拦截”HTTP请求，这是解决一系列问题的基石。

## 什么是NestJS拦截器

简单来说，拦截器是一种特殊类型的服务，运行在路由处理程序方法之前和之后。它们在每次请求和响应的生命周期中都被调用，能够在请求处理之前进行操作，或对从处理程序返回的响应进行转换。

你可以将其视为中间件的一种更先进的形式，它们在每次请求和响应的生命周期中都被运行。

## NestJS拦截器的用途

NestJS拦截器的常见用途包括：

### 1. **修改响应数据**

统一所有响应数据的格式，为其添加相同的结构或者字段。

### 2. **请求预处理**

实现认证和授权逻辑，或对请求数据进行初步校验。

### 3. **性能调优**

计算处理请求所需的时间，为优化性能提供依据。

### 4. **日志记录**

记录每次请求及响应的详细数据，为问题排查提供信息。

## 实际案例

下面，我们将通过一些具体的案例来了解如何在实际项目中使用NestJS拦截器。

### 1. 响应数据的统一处理

在这个案例中，我们希望所有的HTTP响应都有一个 `code`字段和 `data`字段。我们可以通过创建一个拦截器来执行此操作：

```typescript
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

@Injectable()
export class TransformInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next
      .handle()
      .pipe(
        map(data => ({ code: 200, data })),
      );
  }
}

```

这是执行后的结果：

```json
{
  "code": 200,
  "data": {/* 原来的响应数据 */}
}

```

### 2. 记录处理时间

此拦截器可用于记录处理请求所需的时间，对于性能优化非常有用：

```typescript
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';

@Injectable()
export class TimingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const now = Date.now();
    return next
      .handle()
      .pipe(
        tap(() => console.log(`After... ${Date.now() - now}ms`)),
      );
  }
}

```

执行的结果可能如下：

```text
After... 27ms

```

## 总结

以上就是对NestJS拦截器的详细介理解和使用案例。掌握了拦截器，我们可以在处理请求时有更多的操作空间。虽然这只是NestJS的众多特性之一，但其强大的潜力表明了它在构建现代Web应用程序时的价值。

使用NestJS开发应用程序是一种愉快的体验，而拦截器无疑大大增强了它的功能，使我们可以更好地控制和管理HTTP请求。这只是NestJS的一小部分，但却能大大提升你的开发效率。

此外，此处提供的使用案例只是冰山一角，实际上，NestJS拦截器的可能性几乎是无限的，可以根据不同的需求定制拦截器。


在现代Web开发的世界中，NestJS以其灵活性和强大的功能立足，成为Node.js框架的佼佼者。其中一个引人注目的功能就是拦截器，这是一种可以让开发者更好地控制和补充HTTP请求循环的工具。拦截器让开发者可以在处理程序之前或之后“拦截”HTTP请求，这是解决一系列问题的基石。什么是NestJS拦截器简单来说，拦截器是一种特殊类型的服务，运行在路由处理程序方法之前和之后。它们在每次请求和响应的生命

一篇文章学会 NestJS 的拦截器并且附带实战操作案例

## 前言

在持续迭代的现代应用开发中，版本控制是无法绕开的问题。任何对现有接口的修改，如果没有一个有效的版本控制机制，都可能导致应用全局范围的影响。那么，如何实现一个清晰且高效的接口版本控制呢？

多版本控制策略希望在设计之初就考虑到，以确保应用具备良好的灵活性和可扩展性。而 NestJS 的强大功能，就带给我们实现多版本控制的可能。

NestJS 是一个强大且灵活的 Node.js 框架，它提供的模块化架构可以让我们为每个版本的代码创建特定的模块。这样，一旦对某个版本的代码需要修改，修改的内容就会被严格地限制在这个模块中，最大限度地减少对其他版本产生影响。

本文将带你了解使用 NestsJS 如何实现接口多版本控制。

## 接口**多版本控制的类型**

在 NestJS 中，多版本控制可支持三种类型：

1. **URI Versioning（URI版本控制）**

   这种类型的版本控制将版本信息放在请求的 URI 中。例如 **`https://example.com/v1/route`** 和 **`https://example.com/v2/route`**。
2. **Header Versioning（标头版本控制）**

   标头版本控制将使用自定义的、用户指定的请求标头来指定版本信息。
3. **Media Type Versioning（媒体类型版本控制）**

   媒体类型版本控制使用请求的 **`Accept`** 标头来指定版本信息。

接下来，我们将详细介绍这三种类型的版本控制。

## 接口**多版本控制的**实现方式

### 一、**URI Versioning（URI版本控制）**

URI 版本控制使用在请求的 URI 中传递的版本信息，例如 **`https://example.com/v1/route`** 和 **`https://example.com/v2/route`**。注意使用 URI 版本控制，版本信息将自动添加到 URI 中全局路径前缀（如果存在）之后，任何控制器或路由路径之前。

为了要启用 URI 版本控制，你需要在 **`main.ts`** 文件中这样配置：

```shell
import { NestFactory } from '@nestjs/core';
import { VersioningType } from '@nestjs/common';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  // or "app.enableVersioning()"
  app.enableVersioning({
    type: VersioningType.URI,
  });
  await app.listen(3000);
}
bootstrap();
```

默认情况下，URI 中的版本将自动以 **`v`** 为前缀，但是可以通过将 **`prefix`** 键设置为你想要的前缀来配置前缀值，如果你希望禁用它，则可以设置为 **`false`**。

### 二、**Header Versioning（标头版本控制）**

标头版本控制使用自定义的、用户指定的请求标头来指定版本信息。例如，你可以编写一个包含了特定版本信息的 HTTP 请求：

```shell
GET /cats HTTP/1.1
Host: example.com
Accept: application/json
Custom-Header: 2
```

启用标头版本控制，你需要在 **`main.ts`** 文件中这样配置：

```typescript
import { NestFactory } from '@nestjs/core';
import { VersioningType } from '@nestjs/common';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.enableVersioning({
    type: VersioningType.HEADER,
    header: 'Custom-Header',
  });
  await app.listen(3000);
}
bootstrap();
```

**`header`** 属性就是包含请求版本的标头的名称。

### 三、**Media Type Versioning（媒体类型版本控制）**

媒体类型版本控制使用 **`Accept`** 请求的标头来指定版本信息。在 **`Accept`** 标头中，版本将与媒体类型用分号 **`;`** 分隔。然后它应该包含一个键值对，表示用于请求的版本，例如 **`Accept: application/json;v=2`**。在确定要配置为包含键和分隔符的版本时，它们的键更多地被视为前缀。

要启用媒体类型版本控制，你需要在 **`main.ts`** 文件中这样配置：

```typescript
import { NestFactory } from '@nestjs/core';
import { VersioningType } from '@nestjs/common';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.enableVersioning({
    type: VersioningType.MEDIA_TYPE,
    key: 'v=',
  });
  await app.listen(3000);
}
bootstrap();
```

其中 **`key`** 属性应为包含版本的键值对的键和分隔符。例如，当 **`Accept`** 头部为 **`application/json;v=2`** 时，**`key`** 属性将设置为 **`v=`**。

## 实战

一个最基础接口版本的 `Controller`

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

@Controller()
export class UserControllerV1 {
  @Get('user')
  findAll(): string[] {
    return ['This action returns all user'];
  }
}
```

接下来在这个基础接口的基础上进行多种方式的版本控制

### 一、单个路由级别设置版本

可以为单个路由设置版本。单个路由的版本设置将覆盖控制器版本。以下实例演示了如何为路由添加版本：

```typescript
import { Controller, Get, Version } from '@nestjs/common';

@Controller()
export class UserController {
  @Version('1')
  @Get('user')
  findAllV1(): string[] {
    return ['user1'];
  }

  @Version('2')
  @Get('user')
  findAllV2(): string {
    return ['user2'];
  }
}
```

访问 `http://localhost:3000/v1/user`

### 二、控制器级别设置版本

分开到不同的Controller文件中

```typescript
import { Controller, Get, Version } from '@nestjs/common';

@Controller({
  version: ['1'],
})
export class UserController {
  @Get('user')
  findAll(): string[] {
    return ['user1'];
  }
}
```

```typescript
import { Controller, Get, Version } from '@nestjs/common';

@Controller({
  version: ['2'],
})
export class UserController {
  @Get('user')
  findAll(): string[] {
    return ['user2'];
  }
}
```

访问 `http://localhost:3000/v1/user`

### 三、系统级别设置版本

```typescript
app.enableVersioning({
  // ...
  defaultVersion: '1'
  // or
  defaultVersion: ['1', '2']
  // or
  defaultVersion: VERSION_NEUTRAL
});
```

### 四、无视接口版本

有时候，一些控制器或路由可能无论版本如何都具有相同的功能。这时，你可以将版本设置为 **`VERSION_NEUTRAL`** 符号，任何版本的请求都将映射到该控制器或路由。以下实例演示了如何设置无视版本的控制器：

```typescript
import { Controller, Get, VERSION_NEUTRAL } from '@nestjs/common';

@Controller({
  version: VERSION_NEUTRAL,
})
export class UserController {
  @Get('user')
  findAll(): string[] {
    return  return ['user'];
  }
}
```

访问 `http://localhost:3000/user`

## 总结

简单的版本控制可能会在管理上引入混乱和复杂性，但是 NestJS 的多版本控制能有效地处理这类问题，让我们可以使用 URI、标头或媒体类型的方式灵活地管理各个版本。不仅如此，NestJS 还允许我们对控制器或每个独立路由进行单独的版本控制，并提供了一种选择退出版本控制的方式。另外，我们还可以将默认版本全局应用于未指定版本的所有控制器和路由，进一步简化了版本管理工作。

使用 API 版本控制，我们能在新增功能和修复缺陷时保持旧版的稳定性，同时也允许用户在准备好更新他们的客户端时自由切换到新版本。通过优雅而规范的版本控制，开发者可以始终对 API 有清晰的理解，而用户则可以享受到连续的服务。

使用 NestJS 进行接口多版本的控制，是一种高效且灵活的解决方案。它不仅能帮助我们在持续迭代和更新中保持稳定，也使得我们的应用具有更好的可扩展性和健壮性。


在持续迭代的现代应用开发中，版本控制是无法绕开的问题。任何对现有接口的修改，如果没有一个有效的版本控制机制，都可能导致应用全局范围的影响。那么，如何实现一个清晰且高效的接口版本控制呢？多版本控制策略希望在设计之初就考虑到，以确保应用具备良好的灵活性和可扩展性。而NestJS的强大功能，就带给我们实现多版本控制的可能。NestJS是一个强大且灵活的Node.js框架，它提供的模块化架构可以让我们为每

NestJS 如何实现接口多版本控制

## 前言

应用程序通常需要在多种环境中运行，比如本地开发环境、测试环境和生产环境。在不同的环境中，我们通常需要采用不同的配置设置。举个例子，本地环境可能需要一个特定的数据库凭据，而生产环境则使用另一组完全不同的数据库凭据。由于这些配置变量频繁地改变，因此最佳实践是将它们存在环境变量中。

在Node.js中，外部定义的环境变量可以通过**`process.env`**全局变量来访问。一种可能的做法是在每个环境中设置不同的环境变量，然而这样做在管理上变得越来越复杂，特别是在需要频繁模拟或更改这些值的开发和测试环境中。

一个常见的做法是使用**`.env`**文件来管理配置，在这个文件中包含了一系列的键值对，每个键代表一个特定的环境变量。在不同的环境中运行应用程序只需要切换对应的** `.env`**文件即可。

## 配置模块

对于NestJS框架，我们可以利用**`ConfigModule`**来实现上述的配置管理方式。**`ConfigModule`**包含一个** `ConfigService`**，该服务可以根据** `$NODE_ENV`**环境变量来加载相应的** `.env`**文件。为了简化使用，NestJS提供了一个开箱即用的** `@nestjs/config`**包。

在接下来的文章中，我们将详细介绍如何在NestJS中使用**`@nestjs/config`**包来实现安全、灵活的配置管理。

## 基础使用步骤

### 1.**安装依赖包**

使用 npm 安装 config 模块和@nestjs/config模块。

```text

npm install config @nestjs/config
```

### 2. **创建配置文件**

在你的项目根目录下创建一个名为**`config`**的文件夹，并在该文件夹下面新建一些** `.ts`**或** `.json`**的配置文件，比如** `database.ts`**，内容可以为：

```typescript
export default {
    host: process.env.DATABASE_HOST,
    port: parseInt(process.env.DATABASE_PORT, 3306),
};
```

这样，我们的敏感信息就被保存在了环境变量中，不会暴露在代码中。

### 3. **引入模块**

在项目的 app.module.ts 文件中引入**`ConfigModule`**：

```typescript
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import databaseConfig from './config/database';

@Module({
  imports: [
    ConfigModule.forRoot({
      load: [databaseConfig],
    }),
  ],
  ...
})
export class AppModule {}
```

### 4. **使用配置**

可以在任何需要的地方注入**`ConfigService`**来访问这些配置值：

```typescript
import { Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class AppService {
  constructor(private configService: ConfigService) {}

  getDatabaseHost(): string {
    return this.configService.get<string>('database.host');
  }
}
```

## 其他模块使用配置

在使用像TypeORM这样的模块时，我们需要设置很多配置项，例如数据库连接信息。这些信息通常会根据环境的不同而更改。在这种情况下，我们可以使用Config模块来管理和使用这些配置。

### 1. **安装TypeORM和Config模块**

需要提前 先安装TypeORM和Config模块的依赖包

```typescript
npm install @nestjs/typeorm typeorm @nestjs/config
```

### 2. **创建配置文件**

接着在config文件夹中创建一个名为**`typeorm.ts`**的文件，用于存放数据库连接的配置。

```typescript
export default {
    type:        process.env.DB_TYPE,
    host:        process.env.DB_HOST,
    port:        parseInt(process.env.DB_PORT, 10),
    username:    process.env.DB_USERNAME,
    password:    process.env.DB_PASSWORD,
    database:    process.env.DB_DATABASE,
    synchronize: process.env.DB_SYNCHRONIZE === 'true',
};
```

### 3. **引入模块并配置TypeORM**

在app.module.ts文件中，需要引入**`TypeOrmModule`**和** `ConfigModule`**并进行配置。

接下来使用了**`forRootAsync`**方法来异步配置TypeORM。**`useFactory`**函数使我们可以从注入的** `ConfigService`**中直接获取** `typeorm`**配置。

```typescript
import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import databaseConfig from './config/database';
import typeOrmConfig from './config/typeorm';

@Module({
  imports: [
    ConfigModule.forRoot({
      load: [databaseConfig, typeOrmConfig],
    }),
    TypeOrmModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      useFactory: (configService: ConfigService) => configService.get('typeorm'),
    }),
  ],
})
export class AppModule {}
```

## 总结

使用config模块来处理配置能够让我们更好地管理和保护程序中的敏感信息，同时也为我们提供了在不同环境中切换配置的可能。同时在其他成熟的Module模块中也会通过注入ConfigModule，然后在全局Config配置中获取需要的信息。


应用程序通常需要在多种环境中运行，比如本地开发环境、测试环境和生产环境。在不同的环境中，我们通常需要采用不同的配置设置。举个例子，本地环境可能需要一个特定的数据库凭据，而生产环境则使用另一组完全不同的数据库凭据。由于这些配置变量频繁地改变，因此最佳实践是将它们存在环境变量中。在Node.js中，外部定义的环境变量可以通过process.env全局变量来访问。一种可能的做法是在每个环境中设置不同的环

如何在 NestJS 中安全高效的管理 Config 配置

## 前言

NestJS 是一个用于构建高效、可扩展的 Node.js 服务器端应用程序的框架，它使用 TypeScript 作为开发语言，也支持原生的 JavaScript。在 NestJS 中，生命周期事件是一个重要的概念。在我们构建和管理应用程序时，有时需要在特定的阶段执行一些操作，例如在创建实例，添加或删除模块，突然终止程序时，对这些事件加以利用，可以使我们的应用程序更强大、灵活。

在本文中，我将介绍 NestJS 的生命周期，如何使用生命周期，并通过给出详细的例子加深理解。

## NestJS 有哪些**生命周期**

NestJS 的生命周期钩子允许你在特定时刻执行特定代码，例如在模块初始化或关闭应用时。在 NestJS 中，每个模块和提供者（providers）都有自己的生命周期。

其中可能包括如下几种事件：

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/08vkMJ5AeZNG9YVQ.png)

### 应用启动阶段

1. **`onModuleInit()`**

   当你的模块通过 **`modules`** 数组注册在 Nest 应用程序中时，内部所有的 providers（包括你的服务、守卫、拦截器等）初始化后会调用此方法。这是生命周期的第一个环节。
2. **`onApplicationBootstrap()`**

   此阶段表示所有的东西（模块、providers 以及路由加载器等）都已经被完全初始化，Nest 应用实例已准备好处理请求了。因此，这是 bootstraping 过程的最后一个步骤，它也表示 HTTP 服务器已完成启动。

### 应用关闭阶段

1. **`onModuleDestroy()`**

   当正在销毁 module 时（通常是你主动调用了 **`app.close()`**，或者 Nest 进程被 OS 发来的 SIGINT、SIGTERM 等信号中断时），这个方法会被调用。
2. **`BeforeApplicationShutdown`**

   任何实现了 **`BeforeApplicationShutdown`** 的方法在应用关闭前都会被调用。如果是因为应用收到系统信号，并准备进行关闭处理时（例如 **`SIGTERM`** 或 **`SIGINT`**），对应的信号名称将传给 **`beforeApplicationShutdown(signal?: string)`** 这个方法。
3. **`onApplicationShutdown()`**

   此阶段是关闭过程的最后一个步骤。它给 Nest 大环境一些时间做最后的清理行为（例如日志写入等）。当这个方法执行完后，进程就会正式退出。

> 📌 如果生命周期方法返回一个 `Promise`，Nest 将等待这个 `Promise` 完成（或者解决）之后再继续生命周期。

## 生命周期使用方式

### OnModuleInit VS OnModuleDestroy

```shell
import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';

@Injectable()
export class LoggingService implements OnModuleInit, OnModuleDestroy {
  onModuleInit() {
    console.log(`The LoggingService has been initialized.`);
  }

  onModuleDestroy() {
    console.log(`The LoggingService is being destroyed.`);
  }
}
```

当模块初始化时，我们在控制台打印出 **`The LoggingService has been initialized`**;当模块被销毁时，则打印 **`The LoggingService is being destroyed.`**。

### OnApplicationBootstrap VS BeforeApplicationShutdown

```shell
import { Injectable, BeforeApplicationShutdown, OnApplicationBootstrap } from '@nestjs/common';

@Injectable()
export class LoggingService implements BeforeApplicationShutdown, OnApplicationBootstrap {
  onApplicationBootstrap() {
    console.log(`Application has fully started`);
  }

  beforeApplicationShutdown(signal: string) {
    console.log(`Received shutdown signal: ${signal}`);
  }
}
```

### **onApplicationShutdown**

**`onApplicationShutdown`** 方法，它将在应用进行关闭之前被触发。

```shell
import { Injectable, OnApplicationShutdown } from '@nestjs/common';

@Injectable()
export class AppService implements OnApplicationShutdown {
  onApplicationShutdown(signal: string) {
    console.log('AppService is shutting down due to: ', signal);
  }
}
```

其中，**`signal`** 参数可以获取导致应用关闭的信号类型，如 **`'SIGINT'`**、**`'SIGTERM'`** 或 **`'SIGKILL'`**等。

这种方式在你需要在应用关闭前进行一些清理工作，如关闭数据库连接、结束正在执行的任务或记录日志等方面特别有用。

## **总结**

理解 NestJS 的生命周期事件以及如何处理这些事件，可以帮助我们在构建大型复杂应用程序时保持代码的清晰性和组织性，希望本文能够对大家有所帮助。


NestJS是一个用于构建高效、可扩展的Node.js服务器端应用程序的框架，它使用TypeScript作为开发语言，也支持原生的JavaScript。在NestJS中，生命周期事件是一个重要的概念。在我们构建和管理应用程序时，有时需要在特定的阶段执行一些操作，例如在创建实例，添加或删除模块，突然终止程序时，对这些事件加以利用，可以使我们的应用程序更强大、灵活。在本文中，我将介绍NestJS的生命

一篇文章掌握 NestJS 所有的生命周期以及执行时机

## 背景

装饰器的作用就像其名字一样，它就像一件华丽的外衣，给你的 NestJS 代码提供了吸引力和可读性。这是因为装饰器可以改变我们对代码的处理方式，并帮助我们实现更高级的编程模式。在本文中，我们将探讨如何创建自定义装饰器，这将大大增强我们的 NestJS 使用体验。

## 装饰器类型

- **类装饰器(Class Decorators)**

  在NestJS中，类装饰器最常用在控制器和模块定义上，例如 `@Controller`等。
- **方法装饰器(Method Decorators)**

  在NestJS中，方法装饰器主要用于路由处理，例如**`@Get`**、**`@Post`**等。
- **属性装饰器(Property Decorators)**

  在NestJS中，属性装饰器通常用于依赖注入，例如**`@Inject`**装饰器等。
- **参数装饰器(Parameter Decorators)**

  在NestJS中，参数装饰器一般用于提取请求或路由参数，例如**`@Req`**、**`@Res`**、**`@Query`**等。

## 自定义四种装饰器

### 1. 类装饰器

类装饰器在声明前被申明，它接受类的构造函数作为参数。

```text
function MyCustomClassDecorator() {
  return function(constructor: Function) {
    // 添加自定义逻辑...
    // 例如，我们可以添加新的属性或方法
  }
}

```

创建装饰器后，我们就可以开始使用它。

```text
@MyCustomClassDecorator()
class MyClass {
  //...
}

```

### 2. 属性装饰器

属性装饰器是配合类装饰器一起使用的。你可以在类的属性上使用装饰器，以增加或改变属性的行为。

```text
function MyCustomPropertyDecorator(target: any, propertyKey: string) {
  // 添加自定义逻辑...
  // 比如，我们可以监听属性值的改变，更改属性的配置等
}

```

我们来看看如何在类中使用这个装饰器：

```text
class MyClass {
  @MyCustomPropertyDecorator
  myProperty: string;
}

```

### 3. 方法装饰器

方法装饰器也非常实用，通常用来改变方法的行为，例如包装方法、纪录日志、更改返回值等。

```text
function MyCustomMethodDecorator(
  target: any,
  propertyKey: string,
  descriptor: PropertyDescriptor
) {
  // 添加自定义逻辑... 根据需要更改或替换原有方法
}

```

然后，你就可以在你的方法上使用装饰器。

```text
class MyClass {
  @MyCustomMethodDecorator
  myMethod() {
    //...
  }
}

```

### 4. 参数装饰器

参数装饰器通常用于从请求中提取数据。

```text
import { createParamDecorator, ExecutionContext } from '@nestjs/common';

export const MyCustomParamDecorator = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request =  ctx.switchToHttp().getRequest();
    // 添加自定义逻辑，如提取并返回特定的请求数据
  },
);

```

下面是使用这个自定义参数装饰器的示例：

```text
class MyClass {
  myMethod(@MyCustomParamDecorator data: string) {
    //...
  }
}

```

## 总结

总的来说，创建自定义装饰器是一种强大的技术，让我们的代码变得更加轻量，逻辑更加清晰。理解并使用装饰器是我们深化对 NestJS 的理解，并充分利用其强大功能的关键。尽管本文已经为你介绍了如何创建各种类型的装饰器，确保在实战中正确使用它们仍然是很重要的。

值得注意的是，尽管装饰器具有强大的功能，但应谨慎使用。一个类或函数上过多的装饰器可能会使代码难以阅读和理解，因此在考虑使用装饰器时，请确保它们能让你的代码更加清晰，而不是复杂化。此外，尽管装饰器可以帮助我们实现很多功能，但在很多情况下，更适合的解决方案可能仍是可读性更高、更简单的代码结构和设计模式。


装饰器的作用就像其名字一样，它就像一件华丽的外衣，给你的NestJS代码提供了吸引力和可读性。这是因为装饰器可以改变我们对代码的处理方式，并帮助我们实现更高级的编程模式。在本文中，我们将探讨如何创建自定义装饰器，这将大大增强我们的NestJS使用体验。装饰器类型类装饰器(ClassDecorators)在NestJS中，类装饰器最常用在控制器和模块定义上，例如@Controller等。方法装饰

如何在 Nest 项目中自定义装饰器

> 💡 如果你不希望其他人可以随意进出你的房子，那么你需要给你的房子上个锁。

## 前言

开发一个接口很容易，开发一个具有安全性的接口却不容易。成熟的后端服务项目最注重的一点就是如何保护系统的数据安全，不能让用户无脑的访问操作所有的数据，这是不合理更是极度危险的行为。

NestJS 作为企业级后端开发框架，自然会提供一套权限校验的方案，本文基于NestJS的passort方案，结合 jwt token 完成对系统服务的保护。

## 操作步骤

> 💡 给你的服务装上防盗锁，只允许有钥匙的人进入。

### 一、安装依赖库

首先需要在nestjs项目中安装特定的依赖库

```javascript
npm install @nestjs/passport passport @nestjs/jwt passport-jwt -S
npm install @types/passport-jwt -D
```

### 二、引入 Passort 和 JWT 模块

身份认证是由passort模块提供主要框架，具体的校验能力我选择通过jwt完成用户信息验证，即引入jwt相关的nestjs模块；

```javascript
import { PassportModule } from '@nestjs/passport';
import { JwtModule } from '@nestjs/jwt';

@Module({
  imports: [
    PassportModule.register({ defaultStrategy: 'jwt' }),
    JwtModule.register({
      secret: 'your-secret-key', // TODO: 你需要放入自己的密钥，或者从环境变量中提取
      signOptions: { expiresIn: '1d' }, // 这是可选的
    }),
  ],
  providers: [AuthService, JwtStrategy],
})
export class AuthModule {}
```

### 三、创建 JWT 策略

需要创建一个JWT策略，这个策略服务是用于处理JWT的校验与解析。

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

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

  async validate(payload: any) {
    // TODO: Add your validation logic
  }
}
```

### 四、Controller方法使用验证装饰器

当完成JWT策略创建并注入到AppModule模块，即可在服务接口上使用 AuthGurd 装饰器进行用户身份的验证。

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

@Controller()
export class AppController {
  constructor() {}

  @UseGuards(AuthGuard('jwt'))
  @Get()
  getHomeInfo() {
    return {
      code: 0,
      message: 'ok',
      data: {
        name: 'https://www.levenx.com',
      },
    };
  }
}
```

访问 http://localhost:3000

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/9BIikR1yZaOe35W5.png)

由此发现请求首先会经过JWT策略的身份验证，需要保证请求的header中包含 Authorization 字段。

### 五、生成 JWT Token

步骤五的截图中看到，当客户端没有做任何处理就发起请求时，直接被passport拦截并返回401。

为了通过身份验证拦截，客户端发起请求时需要在请求Header上携带 `Authorization`字段，并且value值必需满足 `Bearer + jwt token` 格式，具体实现可参考：

```javascript
fetch('http://localhost:3000', {
  headers: {
    'Authorization': `Bearer ${jwtToken}`
  }
})
```

**客户端如何获取到****`jwt token`****字符串？**

从步骤二中，我们已经在AppModule引入了 `JwtModule`，它在全局提供了生成JWT Token的服务 `JwtService`，通过 `JwtService`即可生成JWT Token字符串。

```typescript
import { JwtService } from '@nestjs/jwt';
import { Injectable } from '@nestjs/common';

@Injectable()
export class AuthService {
  constructor(private readonly jwtService: JwtService) {}

  async sign() {
    return this.jwtService.sign({ userId: 123456 });
  }
}
```

```javascript
@Controller()
export class AutoController {

  @Inject(AuthService)
  private readonly authService: AuthService;

  @Get('/login')
  async login() {
    const token = await this.authService.sign();
    return {
      code: 0,
      message: 'ok',
      data: {
        token,
      },
    };
  }

}
```

通过访问 `http://localhost:3000/login`获取JWT Token字符串

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/b_OrXKRLEeXWrJxs.png)

客户端获取到 Token 字符串后需要持久化保存起来，并且后续接口请求Header中携带上。如果JWT 是合法有效、在有效期内，通过了AuthGuard的校验，即可正常访问受保护的接口。如果JWT无效，AuthGuard会拦截请求，用户会收到401错误码。

## 总结

本文介绍了如何对请求进行信息校验，对于没有携带Token的请求进行防御性拦截，这保证了基础的保护作用。但是还存在其他更细致的权限问题没有解决，比如不同的用户对于资源有不同的操作权限（有的用户只能查看资源，有的用户可以修改删除资源），这类问题需要我们对每个用户的权限进行更加清晰的管理。

很快我会输出一篇关于NestJS如何细粒度的权限管理的实操教程，敬请关注。


如果你不希望其他人可以随意进出你的房子，那么你需要给你的房子上个锁。开发一个接口很容易，开发一个具有安全性的接口却不容易。成熟的后端服务项目最注重的一点就是如何保护系统的数据安全，不能让用户无脑的访问操作所有的数据，这是不合理更是极度危险的行为。NestJS作为企业级后端开发框架，自然会提供一套权限校验的方案，本文基于NestJS的passort方案，结合jwttoken完成对系统服务的保护。

NestJS 基于 Passort 和 JWT Token 实现接口的权限管理

## 前言

对于服务端项目而言，对外如何提供合格规范的HTTP接口，对内如何优雅的操作数据存储，比如mysql、mongodb。

本文是NestJS服务端开发的基础入门教程，我会根据成熟的解决方案，给大家详细介绍如何基于NestJS实现开发RESTful API，其中基于TypeORM操作mysql数据的增删改查。

希望通过阅读完这篇文章后零基础的朋友也能够完成简单的服务端项目开发。

## 准备工作

### 1.  安装依赖

为了方便对mysql进行操作，ORM工具是必不可少的。TypeORM对NestJS有良好的支持，同是对TypeScript 也有极好的支持，所以首先安装好必要的依赖包；

```javascript
npm install @nestjs/typeorm typeorm mysql2
```

### 2.  导入 TypeOrmModule

在项目模块中导入TypeORM模块，并且将mysql连接信息按照下方模块正确填写；

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

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'mysql',
      host: 'localhost',
      port: 3306,
      username: 'username',
      password: 'password',
      database: 'databaseName',
      autoLoadEntities: true,
      synchronize: true,
			logging: ["query"]
    }),
  ],
})
export class AppModule {}
```

### 3. 创建数据库表实体

TypeORM 的目的是开发者不需要直接面对SQL语句，只需要通过TypeORM提供的API就能够完成对数据库表数据的增删改查。

TypeORM中通过entity对象与数据库的表一一对应。例如本文我们实现对 article 数据表的各种操作。

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

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

  @Column()
  title: string;

  @Column()
  content: string;

  @Column({ default: true })
  isPublish: boolean;
}
```

### 4. 加载数据库实体

步骤3定义好了article对象，接下来需要将它注册到TypeORM

```javascript
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Article } from './models/article';

@Module({
  imports: [
    TypeOrmModule.forRoot({
     ...
    }),
    TypeOrmModule.forFeature([Article])
  ],
})
export class AppModule {}
```

### 5. 项目启动

项目启动后，从控制台输出的日志可以看到article表创建的日志，说明已经成功初始化了TypeORM

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/sLbY8AHnvUGCkhYL.png)

通过Navicat查询article表也成功创建了

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/AAgn4k5DfMN02RPt.png)

至此，所有的准备工作已经完成。接下来我们基于TypeORM完成CURD操作。

## 开始编写 CURD RESTful API

> 💡 REST API 定义了一组标准的方法来操作资源（比如 GET, POST, PUT, DELETE）。

新建 `ArticleController` 用于处理 `article`数据的增删改查。

完成HTP接口代码后，然后通过Postman进行接口调试。

```javascript
import { InjectRepository } from '@nestjs/typeorm';
import {
  Controller,
  Get,
  Query,
  Header,
  Res,
  Post,
  Delete,
  Param,
  Put,
  Body,
} from '@nestjs/common';
import { Article } from './models/article';
import { Repository } from 'typeorm';

@Controller('/api/article')
export class ArticleController {
  @InjectRepository(Article)
  private readonly articleRepository: Repository<Article>;

 
}
```

### 一、增

通过articleRepository的save方法新增数据

```javascript
@Controller('/api/article')
export class ArticleController {
  @InjectRepository(Article)
  private readonly articleRepository: Repository<Article>;

  @Post()
  async createArticle() {
    const article = await this.**articleRepository.save**({
      title: '文章名称',
      content: '内容内容内容内容内容',
      isPublish: true,
    });
    return article;
  }
}
```

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/HmgEdHe4OQ4f9SXs.png)

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/b9y-Me6yugLvzmuO.png)

### 二、删

通过articleRepository的delete方法删除数据

```javascript
@Controller('/api/article')
export class ArticleController {
  @InjectRepository(Article)
  private readonly articleRepository: Repository<Article>;

  @Delete('/:id')
  async deleteArticle(@Param() params) {
    const { id } = params;
    await this.**articleRepository.delete**({ id });
    return 'ok';
  }
}
```

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/0Lu1KSNB6S5tklvY.png)

### 三、改

通过articleRepository的update方法新增数据

```javascript
@Controller('/api/article')
export class ArticleController {
  @InjectRepository(Article)
  private readonly articleRepository: Repository<Article>;

  @Put()
  async updateArticle(@Body() body) {
    const { id, title } = body;
    await this.**articleRepository.update**({ id }, { title });
    return 'ok';
  }
}
```

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/5Hm51RwNDpv7F8JR.png)

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/8XFH2dLksRv5YgDm.png)

### 四、查

通过articleRepository的find方法查询数据

```javascript
@Controller('/api/article')
export class ArticleController {
  @InjectRepository(Article)
  private readonly articleRepository: Repository<Article>;

  @Get()
  async getArticle() {
    const articles = await this.**articleRepository.find**();
    return articles;
  }
}
```

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/2rByrXSdsxEjm5GA.png)

## 总结

本文基于Nestjs和TypeORM实现了最基础的CURD接口，也提供了对应的实战代码和效果截图，希望能够帮助到有需要的朋友。


对于服务端项目而言，对外如何提供合格规范的HTTP接口，对内如何优雅的操作数据存储，比如mysql、mongodb。本文是NestJS服务端开发的基础入门教程，我会根据成熟的解决方案，给大家详细介绍如何基于NestJS实现开发RESTfulAPI，其中基于TypeORM操作mysql数据的增删改查。希望通过阅读完这篇文章后零基础的朋友也能够完成简单的服务端项目开发。准备工作1.安装依赖为了方便对m

基于NestJS 和 TypeORM 实现 CURD RESTful API接口

## 前言

在构建大型和复杂的 Web 应用时，维护清晰的代码结构和高效的操作是至关重要的。NestJS 作为一个现代的 Node.js 框架，提供了多种方式来帮助开发者编写结构化和可维护的代码。其中，`@nestjs/cqrs` 模块就是一种强大的机制，它通过实现命令查询责任分离（CQRS）模式，使得代码更加模块化，业务逻辑更清晰，同时还带来了性能和安全性的提升。

在本文中，我们将详细探讨 CQRS 模式的好处，并通过一个创建博客帖子的例子来演示如何在 NestJS 应用中使用 `@nestjs/cqrs`。

## CQRS 模式介绍

CQRS（Command Query Responsibility Segregation，命令查询责任分离）是一种软件架构模式，它建议将应用的读操作（查询）和写操作（命令）分离开来。这种分离可提高系统的可维护性、可扩展性、性能和安全性。

## 实践 CQRS：创建博客帖子的例子

让我们通过一个实际的例子来了解如何在 NestJS 中实现 CQRS 模式。在本例中，我们将创建一个博客帖子。

### 一、设置项目和安装模块

确保你的 NestJS 项目已创建并初始化。然后安装 CQRS 模块：

```bash
npm install @nestjs/cqrs
```

### 二、定义命令和处理器

创建一个命令对象，该对象是创建帖子请求的载体：

```typescript
// src/commands/implementations/create-post.command.ts
export class CreatePostCommand {
  constructor(
    public readonly title: string,
    public readonly content: string,
    public readonly authorId: string
  ) {}
}
```

现在，创建一个命令处理器来处理这个命令：

```typescript
// src/commands/handlers/create-post.handler.ts
import { CommandHandler, ICommandHandler } from '@nestjs/cqrs';
import { CreatePostCommand } from '../implementations/create-post.command';

@CommandHandler(CreatePostCommand)
export class CreatePostHandler implements ICommandHandler<CreatePostCommand> {
  async execute(command: CreatePostCommand): Promise<void> {
    const { title, content, authorId } = command;
    // 这里可以调用服务层的方法来实际创建帖子
    console.log(`Creating a new post with title: ${title}`);
    // 帖子创建成功后，可以发布事件
  }
}
```

### 三、注册命令处理器

更新你的应用模块以注册 CQRS 模块和命令处理器：

```typescript
// src/app.module.ts
import { Module } from '@nestjs/common';
import { CqrsModule } from '@nestjs/cqrs';
import { CreatePostHandler } from './commands/handlers/create-post.handler';

@Module({
  imports: [CqrsModule],
  providers: [CreatePostHandler],
})
export class AppModule {}
```

### 四、在控制器中执行命令

在控制器中，我们需要注入 `CommandBus`，这样我们就能够发送命令给相应的处理器。

```typescript
// src/posts/posts.controller.ts
import { Body, Controller, Post } from '@nestjs/common';
import { CommandBus } from '@nestjs/cqrs';
import { CreatePostCommand } from '../commands/implementations/create-post.command';

@Controller('posts')
export class PostsController {
  constructor(private commandBus: CommandBus) {}

  @Post()
  async create(@Body() body: { title: string; content: string; authorId: string }) {
    const createPostCommand = new CreatePostCommand(body.title, body.content, body.authorId);
    await this.commandBus.execute(createPostCommand);
    return { message: 'Post has been created successfully.' };
  }
}
```

在这个控制器中，当客户端向 `/posts` 发送 `POST` 请求时，我们从请求体中提取数据，并将其封装为 `CreatePostCommand` 对象。然后通过 `CommandBus` 将命令发送给 `CreatePostHandler` 进行处理。这样，我们的控制器保持简洁，而复杂的业务逻辑则在处理器中实现。

## CQRS 模式的好处

- **可维护性**: 分离命令和查询逻辑，使得代码结构更清晰，易于理解和维护。
- **可扩展性**: 单独扩展读取和写入操作，特别是在读操作远远超过写操作的系统中。
- **性能**: 通过为读取和写入操作设计专门的数据模型和数据库结构来优化性能。
- **安全性**: 实施不同的安全策略，为命令和查询操作提供精确的安全控制。

### 详细说明

让我们以创建博客帖子的例子来探讨 CQRS 模式的好处：

#### 可维护性

在传统的 CRUD 操作中，涉及创建帖子的所有逻辑可能都包含在单个服务类中，这使得代码难以维护。通过 CQRS，我们将创建帖子的逻辑封装在 `CreatePostHandler` 中，这使得其与其他逻辑（比如获取帖子或更新帖子）隔离开来，提高了代码的可维护性。

#### 可扩展性

随着应用的增长，我们可能会发现读取帖子的操作频率远远高于创建帖子。在没有 CQRS 的情况下，对服务进行扩展可能会相当复杂，因为读写操作混合在一起。通过 CQRS，我们可以单独优化查询操作，比如通过添加缓存机制来提高查询速度，而不会影响写操作。

#### 性能

在 CQRS 中，我们可以为写操作（命令处理器）和读操作（查询处理器）创建不同的数据模型。例如，我们可以为查询创建一个优化的视图或索引，这样可以提高读取性能，而不影响写操作的效率。

#### 安全性

由于命令（写操作）通常比查询（读操作）需要更严格的安全控制，CQRS 允许我们为命令处理器实现更严格的安全策略，如只有特定的用户角色可以创建帖子。对于查询操作，我们可以提供更宽松的权限，因为它们只涉及数据的读取。

## 总结

通过实现 CQRS 模式，我们可以使 NestJS 应用更容易维护和扩展，同时提高性能和安全性。虽然 CQRS 可以带来很多好处，但它也增加了系统的复杂性，因此在决定是否采用 CQRS 时，需要仔细考虑应用的具体需求和上下文。

希望本教程能帮助你了解如何在 NestJS 中使用 `@nestjs/cqrs`，并激发你去探索这个模式更深层次的可能性。


在构建大型和复杂的Web应用时，维护清晰的代码结构和高效的操作是至关重要的。NestJS作为一个现代的Node.js框架，提供了多种方式来帮助开发者编写结构化和可维护的代码。其中，@nestjs/cqrs模块就是一种强大的机制，它通过实现命令查询责任分离（CQRS）模式，使得代码更加模块化，业务逻辑更清晰，同时还带来了性能和安全性的提升。在本文中，我们将详细探讨CQRS模式的好处，并通过一个创建博