# 设计模式

# IOC

Inversion od Control 控制反转

高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。

# DI

Dependency Injection 依赖注入

其实就是写了一个中间件，来收集依赖，主要是为了解耦，减少维护成本

# 类装饰器

主要是通过@符号添加装饰器

他会自动把class构造函数传入到装饰器的第一个参数target

然后通过prototype可以自定义添加属性和方法


function decotators (target:any) {
    target.prototype.name = '小满'
}
 
@decotators
 
class Xiaoman {
 
    constructor () {
 
    }
 
}
 
const xiaoman:any = new Xiaoman()
 
console.log(xiaoman.name)

# 属性装饰器

同样使用@符号给属性添加装饰器

它会返回两个参数第一个原型对象class 第二个属性的名称key

const currency: PropertyDecorator = (target: any, key: string | symbol) => {
  console.log(target, key);
};

class Xiaoman {
  @currency
  public name: string;
  constructor() {
    this.name = "";
  }
  getName() {
    return this.name;
  }
}

# 参数装饰器

同样使用@符号给属性添加装饰器

它会返回三个参数原型对象方法的名称参数的位置从0开始

type CurrencyDecorator = (
  target: any,
  key: string | symbol,
  index: number
) => void;

const currency: CurrencyDecorator = (
  target: any,
  key: string | symbol,
  index: number
) => {
  console.log(target, key, index);
};

class Xiaoman {
  public name: string;
  constructor() {
    this.name = "";
  }
  getName(name: string, @currency age: number) {
    return this.name;
  }
}

# 方法装饰器

同样使用@符号给属性添加装饰器

它返回三个参数原型对象方法的名称属性描述符（writable，enumerrable，configurable）

const currency: MethodDecorator = (
  target: any,
  key: string | symbol,
  descriptor: any
) => {
  console.log(target, key, descriptor);
};

class Xiaoman {
  public name: string;
  constructor() {
    this.name = "";
  }
  @currency
  getName(name: string, age: number) {
    return this.name;
  }
}

# Nest.js

# 安装

$ npm i -g @nestjs/cli
$ nest new project-name

# 换行格式

vscode的CRLF换成LF解决（单文件）

也可以 Ctrl + ,然后搜索 files.eol

# 目录结构

src
	app.controller.spec.ts	具有单一路由的基本控制器
	app.controller.ts	控制器的单元测试
	app.module.ts	应用的根模块
	app.service.ts	具有单一方法的基本服务
	main.ts	使用核心函数 NestFactory创建Nest应用实例的应用入口文件

# demo

# 快速创建

nest g module user server

nest g controller user server

nest g service user server

// 一个命令直接生成CURD

nest g resource user

# Module

组织整个应用程序的结构

nest g module user server

负责引入controller和service

会在根模块app.module.ts中引入UserModule这个模块，相当于一个树形结构

# Controller

nest g controller user server

负责处理客户端传入的请求和服务端返回的响应

@Get('path')
findAll():string{
	return {
		res:'',
		data:'',
		status:200
	}
}

# Provider

nest g service user server

服务的提供者提供数据库操作服务

还可以做用户校验

# 数据库

引入Mongoose根模块

// app.module.ts
  imports: [MongooseModule.forRoot('mongodb://localhost/xxx'), UserModule],

依赖

npm install @types/mongoose --dev

# schema

定义一个数据表的格式

// user.schema.ts
import { Schema } from 'mongoose';

export const userSchema = new Schema({
  _id: { type: String, required: true }, // 覆盖 Mongoose 生成的默认 _id
  user_name: { type: String, required: true },
  password: { type: String, required: true }
});

在user.module.ts中导入


@Module({
  imports: [MongooseModule.forFeature([{ name: 'Users', schema: userSchema }])],
  }}

# 控制器

# 路由

控制台创建

nest g controller user server

@Controller('cats') 装饰器指定路径前缀

@Controller('cats')  		//path: /cats

路由映射

@Controller('cats')  		
	@Get('profile') 	=> /cats/profile
	
	@Get('all') 		=> /cats/all

# Request

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

@Controller('cats')
export class CatsController {
  @Get()
  findAll(@Req() request: Request): string {
    return 'This action returns all cats';
  }
}

在express中使用Typescript

npm i @types/express

# 请求装饰器

@Get()
@Post()
@Put()
@Delete()
@Patch()
@Options()
@Head()
@All()	=> 用于处理所有HTTP请求方法的处理程序

# 路由通配符

@Get('ab*cd')
findAll(){
	return ''
}

路由路径 'ab*cd' 将匹配 abcd 、ab_cd 、abecd 等。字符 ? 、+ 、 * 以及 () 是它们的正则表达式对应项的子集。连字符（-）和点（.）按字符串路径逐字解析。

# 状态码

import { HttpCode } from '@nestjs/common'
@Post()
@HttpCode(204)
create() {
  return 'This action adds a new cat';
}

# headers

import { Header } from '@nestjs/common'
@Post()
@Header('Cache-Control','none')
create(){
	return ''
}

# 重定向

@Get()
@Redirect('https://nestjs.com',301)

@Get('docs')
@Redirect('https://docs.nestjs.com', 302)
getDocs(@Query('version') version) {
  if (version && version === '5') {
    return { url: 'https://docs.nestjs.com/v5/' };
  }
}

# 路由参数

@Get(':id')
findOne(@Param() params): string {
	console.log(params.id);
    return `${params.id}`
}

@Get(':id')
findOne(@Param('id') id): string {
    return `${id}`
}

# 子域路由

@Controller({host:'admin.example.com'})
export class AdminController {
	@Get()
	index(): string {
		return 'Admin page';
	}
}

# 请求负载

DTO(数据传输对象)

/*
  create-cat.dto.ts
*/
export class CreateCatDto {
  readonly name: string;
  readonly age: number;
  readonly breed: string;
}

在controller中使用

@Post()
async create(@Body() createCatDto: CreateCatDto) {
	return ''
}

# 最后一步

在app.module.ts 中导入

import { Module } from '@nestjs/common';
import { yourController } from './your/path'
@Module({
	controllers:[yourController],
})
export class AppModule{}

# Providers

service 给contoller提供与数据库交互的方法

控制台创建

nest g service user server

// CatsService
import { Injectable } from '@nestjs/common'
import { Cat } from './interfaces/cat.interface'

@Injectable()
export class CatsService {
    private readonly cats: Cat[] = [];
    create(cat:Cat) {
        this.cats.push(cat);
    }
    findAll():Cat[]{
		return this.cats;
    }
}

interfaces/cat.interface.ts

export interface Cat {
    name:string;
    age:number;
    breed:string;
}

# 依赖注入

constructor(private readonly catsService: CatsService) {}

# 可选提供者

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

@Injectable()
export class HttpService<T> {
  constructor(
    @Optional() @Inject('HTTP_OPTIONS') private readonly httpClient: T
  ) {}
}

# 基于属性的注入

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

@Injectable()
export class HttpService<T> {
  @Inject('HTTP_OPTIONS')
  private readonly httpClient: T;
}

# 小满nest

https://blog.csdn.net/qq1195566313

# RESTful风格设计

传统接口

http://localhost:8080/api/get_list?id=1

RESTful接口

http://localhost:8080/api/get_list/1 查询删除更新

RESTful 风格一个接口就会完成增删改差他是通过不同的请求方式来区分的

查询GET 提交POST 更新 PUT PATCH 删除 DELETE

RESTful版本控制

// main.ts
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.URI,
  });
  await app.listen(3000);
}
bootstrap();

然后配置版本

// user.controller.ts
// @Controller('user')
@Controller({
  path: 'user',
  version: '1',
})

访问url从 http://localhost:3000/user/users 变成 http://localhost:3000/v1/user/users

# Controller Request (获取前端传过来的参数)

nestjs 提供了方法参数装饰器用来帮助快速获取参数

@Request() req
@Response() res
@Next() next @Session() req.session @Param(key?: string) req.params/req.params[key] @Body(key?: string) req.body/req.body[key] @Query(key?: string) req.query/req.query[key] @Headers(name?: string) req.headers/req.headers[name] @HttpCode

# 获取get请求传参


  @Get('get')
  find(@Request() req) {
    console.log(req.query);
    return {
      code: 200,
    };
  }
// 或者
  find(@Query() query) {
    console.log(query);
    return {
      code: 200,
    };
  }

# post获取参数

可以使用Request装饰器或者Body装饰器


  @Post('get')
  create(@Request() req) {
    console.log(req);
    return {
      code: 200,
    };
  }
// 或者
  create(@Body() body) {
    console.log(body);
    return {
      code: 200,
    };
  }

# 动态路由

@Request

  @Get('/getId/:_id')
  findId(@Request() req) {
    console.log(req.params);
    return {
      code: 200,
    };
  }

http://localhost:3000/v1/user/getId/55555 => 输出 { _id: '55555' }


  @Get('/cookie')
  fn(@Headers() Header) {
    console.log(Header);
    return {
      code: 200,
      data: 'cookie',
    };
  }

# 状态码

使用 HttpCode装饰器控制接口返回的状态码


  @Get('users')
  @HttpCode(201)

# session

session是服务器为每个用户的浏览器提供创建的一个会话对象这个session会记录到浏览器的cookie用来区分用户

npm i express-session --save

需要智能提示安装一个声明依赖

npm i @types/express-session -D

然后再main.ts引入通过app.use 注册session


import * as session from 'express-session'
 
app.use(session())

secret 生成服务端session 签名可以理解为加盐 name 生成客户端cookie 的名字默认 connect.sid cookie 设置返回到前端 key 的属性，默认值为{ path: ‘/’, httpOnly: true, secure: false, maxAge: null }。 rolling 在每次请求时强行设置 cookie，这将重置 cookie 过期时间(默认:false)

# Providers

# module引入service在providers注入

// user.module.ts
@Module({
  imports: [MongooseModule.forFeature([{ name: 'Users', schema: userSchema }])],
  controllers: [UserController],
  providers: [UserService],
})

# 在Controller就可以使用注入好的service了

// user.controller.ts
  constructor(private readonly userService: UserService) {}

# 第二种用法（自定义名称）

import { Module } from '@nestjs/common';
import { UserService } from './user.service';
import { UserController } from './user.controller';
 
@Module({
  controllers: [UserController],
  providers: [{
    provide: "Xiaoman",
    useClass: UserService
  }]
})
export class UserModule { }

# 自定义名称之后要用对应的inject取不然会找不到

construtor (@Inject('Xiaoman') private readonly userService:UserService)

# 自定义注入值

通过useValue

providers:[{
    provide:'Xiaoman',
    useClass:UserService
},{
	provide:'JD',
    useValue:['TB','PDD','JD']
}]

使用

constructor (
@Inject('Xiaoman') private readonly userService: UserService,
@Inject('JD') private shopList:string[]){}

@Get()
findAll(){
	return this.userService.findAll() + this.shopList	
}

# 工厂模式

如果服务之间有相互的依赖或者逻辑处理可以使用useFactory

  
@Module({
  controllers: [UserController],
  providers: [ 
    UserService2,
  {
    provide: "Test",
    inject: [UserService2],
    useFactory(UserService2: UserService2) {
      return new UserService3(UserService2)
    }
  }
  ]
})

# 异步模式

useFactory返回一个promise或者其他异步操作

{
	provide:'sync',
    async useFactory(){
        return await new Promise((r)=>{
            setTimeout(()=>{
                r('sync')
            })
        })
    }
}

# 模块@Module

每个 Nest (opens new window) 应用程序至少有一个模块，即根模块。根模块是 Nest 开始安排应用程序树的地方。事实上，根模块可能是应用程序中唯一的模块，特别是当应用程序很小时，但是对于大型程序来说这是没有意义的。在大多数情况下，您将拥有多个模块，每个模块都有一组紧密相关的功能

nest g res user 创建一个CURD模板的时候 nestjs会自动帮我们引入模块

# 共享模块

例如user的Service想暴露给其他模块使用就可以使用exports导出该服务

// user.module.ts
import { UserService } from './userservice'
@Module({
    exports:[Userservice]
})

由于App.modules已经引入过该模块就可以直接使用user模块的Service

app.module.ts 正常import

在app.controller.ts使用user.service的方法


import { UserService } from './server/user/user.service';
import { User } from './server/user/user.interface';
  async findAll(): Promise<UserResponse<User[]>> {
    return {
      code: 200,
      data: await this.userService.findAll(),
      message: 'Success.',
    };
  }

# 全局模块

@Global()

我们给user模块添加@Global() 它便注册为全局模块

// user.module.ts
import { Global, Module } from '@nestjs/common';

@Global()
@Module({
  imports: [MongooseModule.forFeature([{ name: 'Users', schema: userSchema }])],
  controllers: [UserController],
  providers: [UserService],
  exports: [UserService],
})
export class UserModule {}

在其他模块使用无需在module import 导入

demo.controller.ts
import { UserService } from './../server/user/user.service';

    private readonly userService: UserService,
 
  @Get()
  findAll() { 
    return this.userService.findAll();
  }

# 动态模块

动态模块主要就是为了给模块传递参数可以给该模块添加一个静态方法用来接收参数

// config.module.ts
import { Global, Module, DynamicModule } from '@nestjs/common';
import { ConfigService } from './config.service';
import { ConfigController } from './config.controller';

interface Options {
  path: string;
}

@Global()
@Module({
  controllers: [ConfigController],
  providers: [ConfigService],
})
export class ConfigModule {
  static forRoot(options: Options): DynamicModule {
    return {
      module: ConfigModule,
      providers: [
        {
          provide: 'Config',
          useValue: {
            baseApi: '/api' + options.path,
          },
        },
      ],
      exports: [
        {
          provide: 'Config',
          useValue: {
            baseApi: '/api' + options.path,
          },
        },
      ],
    };
  }
}

// app.module.ts

@Module({
  // imports: [UserModule],
  imports: [
    MongooseModule.forRoot('mongodb://localhost:27017/nest'),
    UserModule,
    DemoModule,
    SktModule,
    ConfigModule.forRoot({
      path: '/Songth1ef',
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

// app.controller.ts

interface Options {
  path: string;
}
@Controller()
export class AppController {
  constructor(
    private readonly appService: AppService,
    private readonly userService: UserService,
    @Inject('Config') private options: Options,
  ) {}

  @Get() 
  get(): Options {
    return this.options;
  }
}

访问 http://localhost:3000/ => {"baseApi":"/api/Songth1ef"}

# 中间件

中间件是在路由处理程序之前调用的函数中间间函数可以访问请求和响应对象

中间件函数可以执行以下任务:

执行任何代码。
对请求和响应对象进行更改。
结束请求-响应周期。
调用堆栈中的下一个中间件函数。
如果当前的中间件函数没有结束请求-响应周期, 它必须调用 next() 将控制传递给下一个中间件函数。否则, 请求将被挂起。

# 创建一个依赖注入中间件

// logger.middleware.ts
import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';
@Injectable()
export class Logger implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    // console.log(req, res);
    console.log('---');
    next();
  }
}

使用方法在模块里面实现 configure 返回一个consumer 通过apply注册中间件通过forRouters指定Controller路由

// app.module.ts
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(Logger).forRoutes('v1/user');
  }
}

也可以指定拦截的方法比如拦截GET POST 等 forRouters 使用对象配置


export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    // consumer.apply(Logger).forRoutes('v1/user');
    consumer.apply(Logger).forRoutes({
      path: 'user',
      method: RequestMethod.GET,
    });
  }
}

甚至可以直接把 UserController塞进去


    consumer.apply(Logger).forRoutes(UserController);

# 全局中间件

注意全局中间件只能使用函数模式按理可以做白名单拦截之类

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
 
 
const whiteList = ['/list']
 
function middleWareAll  (req,res,next) {
   
     console.log(req.originalUrl,'我收全局的')
 
     if(whiteList.includes(req.originalUrl)){
         next()
     }else{
         res.send('小黑子露出鸡脚了吧')
     }
 
     
}
 
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.use(middleWareAll)
  await app.listen(3000);
}
bootstrap();

# 接入第三方中间间例如cors处理跨域

npm install cors

npm install @types/cors -D

# nest上传图片

# 主要用两个包

multer   @nestjs/platform-express nestJs自带了
multer   @types/multer 这两个需要安装

在upload Module 使用MulterModule register注册存放图片的目录

需要用到 multer 的 diskStorage 设置存放目录 extname 用来读取文件后缀 filename给文件重新命名

// upload.module.ts
import { MiddlewareConsumer, Module } from '@nestjs/common';
import { UploadService } from './upload.service';
import { UploadController } from './upload.controller';

import { MulterModule } from '@nestjs/platform-express';
import { diskStorage } from 'multer';
import { extname, join } from 'path';
import { json, urlencoded } from 'express';
import { NestModule } from '@nestjs/common/interfaces';
@Module({
  imports: [
    MulterModule.register({
      storage: diskStorage({
        destination: join(__dirname, '../images'),
        filename: (_, file, callback) => {
          const fileName = `${new Date().getTime() + extname(file.originalname)}`;
          return callback(null, fileName);
        },
      }),
    }),
  ],
  controllers: [UploadController],
  providers: [UploadService],
})
export class UploadModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(
      json({ limit: '50mb' }),
      urlencoded({ extended: true, limit: '50mb' }),
    );
  }
}

# controller

使用 UseInterceptors 装饰器 (opens new window) FileInterceptor是单个读取字段名称 FilesInterceptor是多个

参数使用 UploadedFile 装饰器接受file 文件

// upload.controller.ts
@Controller('upload')
export class UploadController {
  constructor(private readonly uploadService: UploadService) {}

  @Post('album')
  @Header('Access-Control-Allow-Headers', '*')
  @Header('Access-Control-Allow-Methods', 'POST')
  @UseInterceptors(FileInterceptor('file'))
  upload(@UploadedFile() file) {
    console.log(file);
    // console.log(res);

    // return true;
    return {
      code: 200,
      data: file.filename,
    };
  }

# 3.生成静态目录访问上传之后的图片

useStaticAssets prefix 是虚拟前缀

// main.ts

  app.useStaticAssets(join(__dirname, 'images'), {
    prefix: '/files',
  });

访问地址=> http://localhost:3000/files/1717409117828.jpg

# 下载图片


  @Get('export/:id')
  async findOne(@Param('id') id: string, @Res() res: Response) {
    try {
      const row = await this.uploadService.findOne(id);
      if (!row || !row.file_path) {
        return res.status(HttpStatus.NOT_FOUND).send('File not found');
      }
      const url = join(__dirname, '../images/' + row.file_path);
      if (existsSync(url)) {
        return res.download(url);
      } else {
        return res.status(HttpStatus.NOT_FOUND).send('File not found');
      }
    } catch (error) {
      console.error(error);
      return res
        .status(HttpStatus.INTERNAL_SERVER_ERROR)
        .send('Internal server error');
    }
  }


  @Get('stream/:id')
  @Header('Content-Type', 'application/octet-stream')
  async stream(@Param('id') id: string, @Res() res: Response) {
    try {
      const row = await this.uploadService.findOne(id);
      res.setHeader('Access-Control-Expose-Headers', 'Content-Disposition');
      res.setHeader(
        'Content-Disposition',
        'attachment; filename=' + row.file_path,
      );
      console.log(row);

      if (!row || !row.file_path) {
        return res.status(HttpStatus.NOT_FOUND).send('File not found');
      }
      const url = join(__dirname, '../images/' + row.file_path);
      if (existsSync(url)) {
        // return res.download(url);
        const tarStream = new zip.Stream();
        await tarStream.addEntry(url);
        tarStream.pipe(res);
      } else {
        return res.status(HttpStatus.NOT_FOUND).send('File not found');
      }
    } catch (error) {
      console.error(error);
      return res
        .status(HttpStatus.INTERNAL_SERVER_ERROR)
        .send('Internal server error');
    }
  }

# RXJS

Nestjs已经内置了Rxjs

Rxjs使用的是观察者模式用来编写异步队列和事件处理

Observable 可观察的物体

Subscription监听Observable

Operators 纯函数可以处理管道的数据如map filter cncat reduce等

案例

类似于迭代器next发出通知complete通知完成

subscribe订阅observable 发出的通知也就是一个观察者

import { Observable } from 'rxjs';

// 类似于迭代器 next 发出通知 complete通知完成
const observable = new Observable((subscriber) => {
  subscriber.next(1);
  subscriber.next(1);
  subscriber.next(1);
  setTimeout(() => {
    subscriber.next(4);
    subscriber.complete();
  }, 1000);
});

observable.subscribe({
  next: (value) => {
    console.log(value);
  },
});

# 响应拦截器

# 拦截器

拦截器具有一系列有用的功能这些功能受面向切面编程（AOP）技术的启发。他们可以：在函数执行之前/之后绑定额外的逻辑

转换从函数返回的结果

转换从函数抛出的异常

扩展基本函数行为

根据所选条件完全重写函数（例如，缓存目的）

我们现在没有给我们的nestjs规范返回给前端的格式现在比较乱

我们想给他返回一个标准的json格式就要给我们的数据做一个全局format

{
	data,
	status:0,
	message:'success',
	success:true
}

新建common文件夹创建response.ts

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

interface data<T> {
  data: T;
}

@Injectable()
export class Response<T = any> implements NestInterceptor {
  intercept(context, next: CallHandler): Observable<data<T>> {
    return next.handle().pipe(
      map((data) => {
        return {
          data,
          status: 0,
          success: true,
          message: 'success',
        };
      }),
    );
  }
}

在main.ts注册

app.useGlobalInterceptors(new Response())

# 异常拦截器

# 全局异常拦截器

common下新建 filter.ts

创建一个异常过滤器它负责捕获作为HttpException类实例的异常并为她们设置自定义响应逻辑。为此，我们需要访问底层平台Request和Resopnse。我们将访问Request对象，以便提取原始url并将其包含在日志信息中。我们将使用Response.json()方法，使用Response对象直接控制发送的响应。

import {
  ArgumentsHost,
  Catch,
  ExceptionFilter,
  HttpException,
} from '@nestjs/common';

import { Request, Response } from 'express';
@Catch(HttpException)
export class HttpFilter implements ExceptionFilter {
  catch(execption: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const request = ctx.getRequest<Request>();
    const response = ctx.getResponse<Response>();
    const status = execption.getStatus();
    response.status(status).json({
      data: execption.message,
      time: new Date().getTime(),
      success: false,
      path: request.url,
      status,
    });
  }
}

注册全局异常过滤器


  app.useGlobalFilters(new HttpFilter());

# 管道转换

管道可以做两件事

转换，可以将前端传入的数据转成我们需要的数据

验证，类似于前端的rules配置验证规则

先讲转换nestjs提供了八个内置转换API

ValidationPipe
ParseIntPipe
ParseFloatPipe
ParseBoolPipe
ParseArrayPipe
ParseUUIDPipe
ParseEnumPipe
DefaultValuePipe

# 案例一我们接收一个动态参数希望是一个number类型现在是string


  @Get('number/:_id')
  async getNumber(@Param('_id') _id: string) {
    console.log(_id, typeof _id);
  }
  // http://localhost:5104/upload/number/666
  // 666 string


  @Get('number/:_id')
  async getNumber(@Param('_id', ParseIntPipe) _id: number) {
    console.log(_id, typeof _id);
  }
  // http://localhost:5104/upload/number/666
  // 666 number

# 案例二验证UUID

安装uuid

npm install uuid -S

npm install @types/uuid -D

生成一个uuid


  @Get('uuid/:_id')
  async getUUID(@Param('_id', ParseUUIDPipe) _id: string) {
    console.log(_id, typeof _id);
  }

# 管道验证DTO

先创建一个pipe验证管道

nest g pi pipe
nest g res pipe
npm i --save class-validator class-transformer

// src\pipe\dto\create-pipe.dto.ts

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

export class CreatePipeDto {
  @IsNotEmpty()
  @IsString()
  name: string;

  @IsNotEmpty()
  age: number;
}

controller 使用管道和定义类型

// src\pipe\pipe.controller.ts
import { PipePipe } from './pipe.pipe';
  @Post()
  create(@Body(PipePipe) createPipeDto: CreatePipeDto) {
    return this.pipeService.create(createPipeDto);
  }

实现验证transform

import {
  ArgumentMetadata,
  HttpException,
  HttpStatus,
  Injectable,
  PipeTransform,
} from '@nestjs/common';
import { plainToInstance } from 'class-transformer';
import { validate } from 'class-validator';
import { CreatePipeDto } from './dto/create-pipe.dto';
@Injectable()
export class PipePipe implements PipeTransform {
  async transform(value: CreatePipeDto, metadata: ArgumentMetadata) {
    const DTO = plainToInstance(metadata.metatype, value);
    const errors = await validate(DTO);
    if (errors.length > 0) {
      throw new HttpException({ value, errors }, HttpStatus.BAD_REQUEST);
    }
    return value;
  }
}

注册全局DTO验证管道

会先走全局验证管道 =》如果有自定义的 Pipe ，走自定义的Pipe =》controller


  // 全局管道验证
  app.useGlobalPipes(new ValidationPipe());

# nest爬虫

 const baseUrl = 'xxxxxxxxxxxxxxxxxxxxxxx'
    const next = '下一页'
    let index = 0;
    const urls: string[] = []
    const getCosPlay = async () => {
      console.log(index)
      await axios.get(`xxxxxxxxxxxxxx/Cosplay/Cosplay10772${index ? '_'+index : ''}.html`).then(async res => {
        //console.log(res.data)
        const $ = cheerio.load(res.data)
        const page = $('.article-content .pagination a').map(function () {
          return $(this).text()
        }).toArray()
        if (page.includes(next)) {
          $('.article-content p img').each(function () {
            console.log($(this).attr('src'))
            urls.push(baseUrl + $(this).attr('src'))
          })
          index++
          await getCosPlay()
        }
      })
    }
    await getCosPlay()
    console.log(urls)

 writeFile(urls: string[]) {
    urls.forEach(async url => {
      const buffer = await axios.get(url, { responseType: "arraybuffer" }).then(res=>res.data)
      const ws = fs.createWriteStream(path.join(__dirname, '../cos' + new Date().getTime() + '.jpg'))
      ws.write(buffer)
    })
  }

# 守卫

守卫有个单独的责任根据运行时出现的某些条件（例如权限，角色，访问控制列表等）来确定给定的请求是否由路由处理程序处理这通常称为授权在传统的express应用中通常由中间件处理授权（以及认证）。中间件是身份验证的良好选择，因为诸如token验证或添加属性到request对象上与特定路由（及元数据）没有强关联

守卫在每个中间件之后执行但在任何拦截器或管道之前执行

创建守卫

nest g gu [name]

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

@Injectable()
export class RoleGuard implements CanActivate {
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    return true;
  }
}

controller使用守卫


import { RoleGuard } from './../role/role.guard';

@Controller('guard')
@UseGuards(RoleGuard)

全局守卫


  // 全局守卫
  app.useGlobalGuards(new RoleGuard());

实际直接使用会报错

// error
  constructor(private reflector: Reflector) {}
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

解决

// app.module
  providers: [
    AppService,
    {
      provide: APP_GUARD,
      useClass: RoleGuard,
    },
    Reflector,
  ],

// main.ts
  // 全局守卫
  // app.useGlobalGuards(new RoleGuard());替换成=>
  const reflector = new Reflector();
  const roleGuard = new RoleGuard(reflector);
  app.useGlobalGuards(roleGuard);

guard使用 Reflector反射读取setMetaData的值去做判断这边的例子是从url判断有没有admin权限

//role.guard.ts
import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
import { Observable } from 'rxjs';
import { Reflector } from '@nestjs/core';
import type { Request } from 'express';
@Injectable()
export class RoleGuard implements CanActivate {
  constructor(private reflector: Reflector) {}
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    const admin = this.reflector.get<string[]>('role', context.getHandler());
    const request = context.switchToHttp().getRequest<Request>();
    if (admin.includes(request.query.role as string)) {
      return true;
    } else {
      return false;
    }
  }
}

# 自定义装饰器

在nest中我们使用了大量装饰器decorator 所以Nestjs也允许我们去自定义装饰器

nest g d [name]

// src\guard\role\role.decorator.ts
import { SetMetadata } from '@nestjs/common';

export const Role = (...args: string[]) => {
  console.log(args);

  return SetMetadata('role', args);
};

// src\guard\guard.controller.ts
  @Get()
  // @SetMetadata('role', ['admin']) 使用自定义装饰器 =>
  @Role('admin')
  findAll(@ReqUrl() url) {
    console.log(url);

    return this.guardService.findAll();
  }

自定义装饰器返回一个url

// src\guard\req-url\req-url.decorator.ts
import { ExecutionContext, createParamDecorator } from '@nestjs/common';
import type { Request } from 'express';

export const ReqUrl = createParamDecorator(
  (data: string, ctx: ExecutionContext) => {
    const req = ctx.switchToHttp().getRequest<Request>();
    return req.url;
  },
);

# swagger接口文档

npm install  @nestjs/swagger swagger-ui-express

//main.ts
async function bootstrap() {
  const app = await NestFactory.create<NestExpressApplication>(AppModule);
  const options = new DocumentBuilder().setTitle('小满接口文档').setDescription('描述，。。。').setVersion('1').build()
  const document = SwaggerModule.createDocument(app,options)
  SwaggerModule.setup('/api-docs',app,document)
  await app.listen(3000);
}
bootstrap();

# ApiTags 分组

@Controller('pipe')
@ApiTags('管道')

# ApiOperation 接口描述

  @Get()
  // @SetMetadata('role', ['admin'])
  @Role('admin')
  @ApiOperation({ summary: '测试admin', description: '请求接口需要admin权限' })

# ApiParam 动态参数描述 => /pipe/12312312

  @Get()  
  @ApiParam({ name: 'role', description: '角色', required: true })

# ApiQuery 修饰get => /pipe?name=sonsdsds

@Get()
  // @SetMetadata('role', ['admin'])
  @Role('admin')
  @ApiOperation({ summary: '测试admin', description: '请求接口需要admin权限' })
  @ApiParam({ name: 'role', description: '角色', required: true })
  @ApiQuery({ name: 'role', description: '角色' })

# ApiProperty 定义Post

// dto
import { ApiProperty, ApiParam } from '@nestjs/swagger';
import { IsNotEmpty, IsNumber, IsString } from 'class-validator';
export class CreatePipeDto {
  @IsNotEmpty()
  @IsString()
  @ApiProperty({ description: '姓名', example: 'songth1ef' })
  name: string;

  @IsNotEmpty()
  @IsString()
  @ApiProperty({ description: '年龄', example: 18 })
  age: number;
}

# ApiResponse 自定义返回信息


  @Get()
  @ApiResponse({ status: 304, description: '这是一段描述' })

# ApiBearerAuth jwt token

 // main.ts 增加 addBearerAuth()
  // swagger文档
  const options = new DocumentBuilder()
    .addBearerAuth()
    .setTitle('nest接口文档')
    .setDescription('这是描述')
    .setVersion('1')
    .build();
  const document = SwaggerModule.createDocument(app, options);
  SwaggerModule.setup('/api/api-docs', app, document);

// src\guard\guard.controller.ts
@Controller('guard')
@UseGuards(RoleGuard)
@ApiTags('守卫')
@ApiBearerAuth()

# 连接mysql

ORM框架（typeOrm）

typeOrm 是 TypeScript 中最成熟的对象关系映射器( ORM )。因为它是用 TypeScript 编写的，所以可以很好地与 Nest 框架集成

npm install --save @nestjs/typeorm typeorm mysql2

在app.module.ts 注册

    TypeOrmModule.forRoot({
      type: 'mysql',
      username: 'root',
      password: '1qaz2wsx',
      host: 'localhost', //host
      port: 3306, //
      database: 'test', //库名
      entities: [__dirname + '/**/*.entity{.ts,.js}'], //实体文件
      synchronize: true, //synchronize字段代表是否自动将实体类同步到数据库
      retryDelay: 500, //重试连接数据库间隔
      retryAttempts: 10, //重试连接数据库的次数
      autoLoadEntities: true, //如果为true,将自动加载实体 forFeature()方法注册的每个实体都将自动添加到配置对象的实体数组
    }),

定义实体

// count/entities/count.entry.ts
import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';

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

  @Column()
  ip: string;
}

关联实体

// \src\count\count.module.ts 
import { TypeOrmModule } from '@nestjs/typeorm';
import { Count } from './entities/count.entity';
@Module({
  imports: [TypeOrmModule.forFeature([Count])],
  controllers: [CountController],
  providers: [CountService],
})

# 实体

实体是一个映射到数据库表的类你可以通过定义一个新类来创建一个实体并用@Entity()来标记：

import {Entity,Column,PrimaryGeneratedColumn} from 'typeorm'
 
@Entity()
export class Test {
    @PrimaryGeneratedColumn()
    id:number
    
    @Column()
    name:string
 
    @Column()
    password:string
 
    @Column()
    age:number
}

主列

自动递增的主键

@PrimaryGeneratedColumn()
id:number

自动递增的uuid

@PrimaryGeneratedColumn("uuid")
id:number

列类型

    @Column({type:"varchar",length:200})
    password: string
 
    @Column({ type: "int"})
    age: number
 
    @CreateDateColumn({type:"timestamp"})
    create_time:Date

在 MySQL 中，常用的数据类型包括：

整型数据类型：
- INT: 用于存储整数值。范围：-2147483648 到 2147483647（有符号），0 到 4294967295（无符号）
- TINYINT: 用于存储小整数值。范围：-128 到 127（有符号），0 到 255（无符号）
- BIGINT: 用于存储大整数值。范围：-9223372036854775808 到 9223372036854775807（有符号），0 到 18446744073709551615（无符号）
浮点数数据类型：
- FLOAT: 用于存储单精度浮点数。范围：-3.402823466E+38 到 -1.175494351E-38、0，以及 1.175494351E-38 到 3.402823466E+38。
- DOUBLE: 用于存储双精度浮点数。
字符串类型：
- CHAR: 定长字符串类型。
- VARCHAR: 变长字符串类型。
- TEXT: 用于存储较大文本数据。
- JSON: 用于存储 JSON 格式数据。
日期和时间类型：
- DATE: 用于存储日期值。
- DATETIME: 用于存储日期和时间值。
- TIMESTAMP: 用于存储时间戳。
- TIME: 用于存储时间值。
- YEAR: 用于存储年份值。

自动生成列

@Generated('uuid')
uuid:string

枚举列

@Column({
    type:'enum',
    enum:['1','2','3','4'],
    default:'1'
})
xx:string

列选项

 @Column({
        type:"varchar",
        name:"ipaaa", //数据库表中的列名
        nullable:true, //在数据库中使列NULL或NOT NULL。 默认情况下，列是nullable：false
        comment:"注释",
        select:true,  //定义在进行查询时是否默认隐藏此列。 设置为false时，列数据不会显示标准查询。 默认情况下，列是select：true
        default:"xxxx", //加数据库级列的DEFAULT值
        primary:false, //将列标记为主要列。 使用方式和@ PrimaryColumn相同。
        update:true, //指示"save"操作是否更新列值。如果为false，则只能在第一次插入对象时编写该值。 默认值为"true"
        collation:"", //定义列排序规则。
    })
    ip:string

ColumnOptions中可用选项列表：

type: ColumnType - 列类型。其中之一在上面. name: string - 数据库表中的列名。默认情况下，列名称是从属性的名称生成的。你也可以通过指定自己的名称来更改它。

length: number - 列类型的长度。例如，如果要创建varchar（150）类型，请指定列类型和长度选项。 width: number - 列类型的显示范围。仅用于MySQL integer types(opens new window) onUpdate: string - ON UPDATE触发器。仅用于 MySQL (opens new window). nullable: boolean - 在数据库中使列NULL或NOT NULL。默认情况下，列是nullable：false。 update: boolean - 指示"save"操作是否更新列值。如果为false，则只能在第一次插入对象时编写该值。默认值为"true"。 select: boolean - 定义在进行查询时是否默认隐藏此列。设置为false时，列数据不会显示标准查询。默认情况下，列是select：true default: string - 添加数据库级列的DEFAULT值。 primary: boolean - 将列标记为主要列。使用方式和@ PrimaryColumn相同。 unique: boolean - 将列标记为唯一列（创建唯一约束）。 comment: string - 数据库列备注，并非所有数据库类型都支持。 precision: number - 十进制（精确数字）列的精度（仅适用于十进制列），这是为值存储的最大位数。仅用于某些列类型。 scale: number - 十进制（精确数字）列的比例（仅适用于十进制列），表示小数点右侧的位数，且不得大于精度。仅用于某些列类型。 zerofill: boolean - 将ZEROFILL属性设置为数字列。仅在 MySQL 中使用。如果是true，MySQL 会自动将UNSIGNED属性添加到此列。 unsigned: boolean - 将UNSIGNED属性设置为数字列。仅在 MySQL 中使用。 charset: string - 定义列字符集。并非所有数据库类型都支持。 collation: string - 定义列排序规则。 enum: string[]|AnyEnum - 在enum列类型中使用，以指定允许的枚举值列表。你也可以指定数组或指定枚举类。 asExpression: string - 生成的列表达式。仅在MySQL (opens new window)中使用。 generatedType: "VIRTUAL"|"STORED" - 生成的列类型。仅在MySQL (opens new window)中使用。 hstoreType: "object"|"string" -返回HSTORE列类型。以字符串或对象的形式返回值。仅在Postgres中使用。 array: boolean - 用于可以是数组的 postgres 列类型（例如 int []） transformer: { from(value: DatabaseType): EntityType, to(value: EntityType): DatabaseType } - 用于将任意类型EntityType的属性编组为数据库支持的类型DatabaseType。

simple-array 列类型

有一种称为simple-array的特殊列类型，它可以将原始数组值存储在单个字符串列中。所有值都以逗号分隔

@Entity()
export class User {
    @PrimaryGeneratedColumn()
    id: number;
 
    @Column("simple-array")
    names: string[];
}

simple-json列类型

还有一个名为simple-json的特殊列类型，它可以存储任何可以通过 JSON.stringify 存储在数据库中的值。当你的数据库中没有 json 类型而你又想存储和加载对象，该类型就很有用了。例如:

@Entity()
export class User {
    @PrimaryGeneratedColumn()
    id: number;
 
    @Column("simple-json")
    profile: { name: string; nickname: string };
}

# typeOrm 表关联

在我们开始的过程中，肯定不会把数据存在一个表里面，我们会进行分表，把数据分开存，然后通过关联关系，联合查询 (opens new window)。

定义Tags数据表

import {
  Column,
  Entity,
  JoinColumn,
  ManyToOne,
  PrimaryGeneratedColumn,
} from 'typeorm';
import { Sqluser } from './sqluser.entity';
@Entity()
export class Tags {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  tags: string;

  @ManyToOne(() => Sqluser, (user) => user.tags)
  @JoinColumn()
  user: Sqluser;
}

module关联tag表

@Module({
  imports: [TypeOrmModule.forFeature([Sqluser, Tags])],

然后user表跟tags表进行关联

import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from 'typeorm';
import { Tags } from './tags.entity';
@Entity({ name: 'users' })
export class Sqluser {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ type: 'varchar', length: 100, nullable: false })
  name: string;

  @Column({ type: 'int' }) // 更改数据类型为整数
  age: number;

  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
  create_time;

  @OneToMany(() => Tags, (tags) => tags.user)
  tags: Tags[];
}

OneToMany 接收两个参数

第一个参数是函数返回关联的类所以在user表关联tag

第二个参数创建双向关系

ManyToOne用法一样

@OneToMany(()=>Tags,(tags)=>{tags.user})

保存该关系


  async addTags(params: { tags: string[]; userId: number }) {
    const userInfo = await this.sqluser.findOne({
      where: { id: params.userId },
    });
    const tagList: Tags[] = [];
    for (let i = 0; i < params.tags.length; i++) {
      const T = new Tags();
      T.tags = params.tags[i];
      await this.tag.save(T);
      tagList.push(T);
    }
    userInfo.tags = tagList;
    console.log(userInfo, 1);
    return this.sqluser.save(userInfo);
  }

# 事务

事务具有4个基本特征，分别是：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Duration），简称ACID

① 原子性事务的原子性是指事务必须是一个原子的操作序列单元。事务中包含的各项操作在一次执行过程中，只允许出现两种状态之一，要么都成功，要么都失败

任何一项操作都会导致整个事务的失败，同时其它已经被执行的操作都将被撤销并回滚，只有所有的操作全部成功，整个事务才算是成功完成

② 一致性（Consistency）事务的一致性是指事务的执行不能破坏数据库数据的完整性和一致性，一个事务在执行之前和执行之后，数据库都必须处以一致性状态。

③ 隔离性事务的隔离性是指在并发环境中，并发的事务是互相隔离的，一个事务的执行不能被其它事务干扰。也就是说，不同的事务并发操作相同的数据时，每个事务都有各自完整的数据空间。

一个事务内部的操作及使用的数据对其它并发事务是隔离的，并发执行的各个事务是不能互相干扰的

④ 持久性（Duration）事务的持久性是指事务一旦提交后，数据库中的数据必须被永久的保存下来。即使服务器系统崩溃或服务器宕机等故障。只要数据库重新启动，那么一定能够将其恢复到事务成功结束后的状态

举例说明

例如小满 (opens new window)要给陈冠希转账 **三百块，**转账需要两步首先小满-300，第二步陈冠希+300，只要任何一个步骤失败了都算失败，如果第一步成功了，第二步失败了，那小满就亏损三百块。

DTO

export class CreateSqluserDto {
  name: string;

  age: number;
}
export class transferMoneyDto {
  fromId: number;
  toId: number;
  money: number;
}

service


  async transferMoney(transferMoneyDto: transferMoneyDto) {
    try {
      return await this.sqluser.manager.transaction(async (manager) => {
        const from = await this.sqluser.findOne({
          where: { id: transferMoneyDto.fromId },
        });
        const to = await this.sqluser.findOne({
          where: { id: transferMoneyDto.toId },
        });
        if (from.money >= transferMoneyDto.money) {
          await manager.update(Sqluser, transferMoneyDto.fromId, {
            money: from.money - transferMoneyDto.money,
          });

          await manager.update(Sqluser, transferMoneyDto.toId, {
            money: Number(to.money) + Number(transferMoneyDto.money),
          });
          return {
            message: '转账成功',
          };
        } else {
          return {
            message: '转账失败',
          };
        }
      });
    } catch (e) {
      return {
        message: e,
      };
    }
  }

# Q&A

# 跨域解决

// main.ts

async function bootstrap() {
  const app = await NestFactory.create(AppModule); 
  app.enableCors();
}

# nestjs mvp (opens new window)

# 类型ORM

连接数据库

npm install --save @nestjs/typeorm typeorm pg

// app.module.ts

// add import
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  imports: [
	// add TypeOrm module, warning: in production, don't expose password
	// one option is to hide the password in environment variables
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'sample_nestjs_user',
      password: 'sample_nestjs_password',
      database: 'sample_nestjs_db',
      entities: [],
	  // for local only
	  // setting this flat to true in production may lose data
      synchronize: true,
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

# config

配置多个环境 dev pro test ...

$ npm i --save @nestjs/config

// app.module.ts

ConfigModule.forRoot({
  isGlobal: true,
  envFilePath: [`.env.${process.env.NODE_ENV}`],
}),

// package.json
{
	"scripts": {
		"start:local": "NODE_ENV=local nest start --watch"
	}
}

# 生成代码

nest g resource

#

# bili nestjs 官方教程 (opens new window)

安装

npm i -g @nestjs/cli

创建项目

nest new project-name
cd ./project-name
npm i

# 解决CRLF格式报错 (opens new window)

# 项目目录结构

-app.controller.ts	// 处理路由接口，引用app.service的方法
-app.module.ts		// 模块构成，指定app.controller和app.service
-app.service.ts		// 提供方法
-main.ts			// 根文件 导入add.module

启动

npm run start:dev //开发

# controller

nest generate controller
nest g co //简写 会自动引用创建的文件
nest g co --no-spec //不要spec文件
nest g co modules/abc --dry-run //可以指定生成的目录 加--dry-run 先预览创建的目录是否正确

@controller('string-url-path')
@controller()可以传递一个字符串 传递Nest创建路由映射所需的元数据

# Get 静态路径

直接访问string-url-path是404

@Controller('juice')
export class JuiceController {
  @Get()	// localhost:3000/juice
  findAll() {
    return 'this is all juice';
  }
  @Get('orange')	// localhost:3000/juice/orange
  findAllOrange() {
    return 'this is all orange';
  }
}

# Get 动态参数

  @Get(':id')
  findOne(@Param() Params) {	//接收param对象
    return 'this is juice and id is ' + Params.id;
  }
  findTwo(@Param('id') id: string) {	//接收指定属性
    return 'this is juice and id is ' + id;
  }

# Post参数

  @Post()
  create(@Body() body) {	//接收body对象
    return body;
  }
  createTwo(@Body('name') name: string) {	//接收body中的name键值对
    return name;
  }

# HttpCode()装饰

  @Post()
  @HttpCode(HttpStatus.GONE) //响应状态码410
  create(@Body() body) {
    return body;
  }

# Patch() 和 Delete()

  @Patch(':id')
  update(@Param('id') id: string, @Body() body) {
    return ' patch to id:' + id + 'and body:' + JSON.stringify(body);
  }
  @Delete(':id')
  remove(@Param('id') id: string) {
    return 'delete id:' + id;
  }

# Query()

  @Get()
  findAll(@Query() paginationQuery) { // 也是url上的
    const { name, age } = paginationQuery;
    return 'name:' + name + 'age:' + age;
  }

# service

nest g s

@Injectable()
export class JuiceService {
  private juices: Juice[] = [
    {
      id: 1,
      name: 'apple',
      color: 'red',
      flavors: ['1', '2', '3'],
    },
  ];
  findAll() {
    return this.juices;
  }
  findOneById(id: string) {
    return this.juices.find((item) => item.id === +id);
  }
  create(createJuiceDto: any) {
    this.juices.push(createJuiceDto);
  }
  update(id: string, undateJuiceDto: any) {
    const existingJuice = this.findOneById(id);
    if (existingJuice) {
    }
  }
  remove(id: string) {
    const JuiceIndex = this.juices.findIndex((item) => item.id === +id);
    if (JuiceIndex >= 0) {
      this.juices.splice(JuiceIndex, 1);
    }
  }
}
// 提供增删改查数据的方法

# 抛出错误

  findOneById(id: string) {
    const juice = this.juices.find((item) => item.id === +id);
    if (!juice) {
      //   throw new HttpException(
      //     'juice ' + id + ' is not find',
      //     HttpStatus.NOT_FOUND,
      //   );
      throw new NotFoundException('juice ' + id + ' is not find');
    }
    return juice;
  }

# module

nest g module

@Module({
  imports: [UserModule, JuiceModule], //main.ts中会自动引入
  controllers: [AppController],
  providers: [AppService],
})

# DTO

nest g class juice/dto/create-juice.dto --no-spec

export class CreateJuiceDto {
  readonly name: string;
  readonly color: string;
  readonly flavors: string[];
}

# useGlobalPipes()

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new ValidationPipe()); //add this line
  await app.listen(3000);
}

npm i class-validator	// 验证
npm i class-transformer	// 转换

import { IsString } from 'class-validator';

export class CreateJuiceDto {
  @IsString() //判断是否是字符串 如果不是 报错400 BadRequest
  readonly name?: string;

  @IsString()
  readonly color?: string;

  @IsString({
    each: true,
  })
  readonly flavors?: string[];
}

# mapped-types

npm i @nestjs/mapped-types

import { PartialType } from '@nestjs/mapped-types';
import { CreateJuiceDto } from '../create-juice.dto/create-juice.dto';
export class UpdateJuiceDto extends PartialType(CreateJuiceDto) {}
// 继承其他Dto

# whitelist

// main.ts
  app.useGlobalPipes(
    new ValidationPipe({
      whitelist: true,
      forbidNonWhitelisted: true, //启用的话 多余参数将会抛出错误
    }),
  );

过滤掉dto里没有的键值对

# transform:true

  app.useGlobalPipes(
    new ValidationPipe({
      whitelist: true,
      transform: true, // 自动转换入参 
      forbidNonWhitelisted: true,
    }),
  );

  create(@Body() createJuiceDto: CreateJuiceDto) { 
    console.log(createJuiceDto instanceof CreateJuiceDto);
    会自动转换类型

  findTwo(@Param('id') id: number) {
    console.log(typeof id); // 会尝试自动把参数转换为想要的类型

# Docker

Docker compose

YAML

# PostgreSQL

docker-compose.yml

services:
  db:
    image: postgres
    restart: always
    ports:
      - "5432:5432"
    environment:
      POSTGRES_PASSWORD: password

docker-compose up db -d 运行
《     启动     》《db要运行的服务》《-d本地》		
docker-compose up -d 启动全部

# TypeORM

npm i @nestjs/typeorm typeorm pg

// app.module.ts
@Module({
  imports: [
    UserModule,
    JuiceModule,
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'postgres',
      password: 'password',
      database: 'juice_db',
      autoLoadEntities: true,
      synchronize: true, //自动同步代码中的表到数据库中，开发模式可以用 生产环境不能
    }),
  ],

@Entity('juice') 	//表名称 'juice'
export class CreateJuiceDto {
  @PrimaryGeneratedColumn()	//主键自增
  id: number;

  @Column()	//列 默认必要
  @IsString()
  readonly name?: string;

  @Column()
  @IsString()
  readonly color?: string;

  @Column('json', { nullable: true })	//列 数据为json 不必要
  @IsString({
    each: true,
  })
  readonly flavors?: string[];
}

// juice.service.ts
  constructor(	//使用数据库中的数据
    @InjectRepository(Juice)
    private readonly juiceRepository: Repository<Juice>,
  ) {}
  	// 查询
    return this.juiceRepository.find();
    // 条件查询
    const juice = await this.juiceRepository.findOne({ where: { id } });
    if (!juice) {
      throw new NotFoundException('juice ' + id + ' is not find');
    }
    // 新增
    const juice = this.juiceRepository.create(createJuiceDto);
    return this.juiceRepository.save(juice);
    // 修改
    const juice = await this.juiceRepository.preload({
      ...undateJuiceDto,
      id: +id,
    });
    if (!juice) {
      throw new NotFoundException('juice ' + id + ' is not find');
    }
    return this.juiceRepository.save(juice);
    // 删除
    const juice = await this.findOneById(+id);
    return this.juiceRepository.remove(juice);

# 表关系

# 一对一

主表中的每一行在外部表中都有一个且只有一个关联行

在TypeORM中使用 @OneToOne()

# 一对多多对一

主表中的每一行在外部表中都有一个或多个相关行

在TypeORM中使用 @OneToMany()和@ManyToOne()

# 多对多

主表中的每一行在外表中都有许多相关的行，并且外表中的每条记录在主表中都有许多相关的行

在TypeORM中使用 @ManyToMany()

// juice\entities\juice.entity.ts
  @JoinTable()
  @ManyToMany(() => FlavorEntity, (flavor) => flavor.juice)
  flavors: FlavorEntity[];
// juice\entities\flavor.entity\flavor.entity.ts
  @ManyToMany(() => Juice, (juice) => juice.flavors)
  juice: Juice[];

// juice\juice.service.ts
  findAll() {
    return this.juiceRepository.find({
      relations: ['flavors'],	//关系
    });
  }
  async findOneById(id: number) {
    const juice = await this.juiceRepository.findOne({
      where: { id },
      relations: ['flavors'],	//关系
    });
    if (!juice) {
      throw new NotFoundException('juice ' + id + ' is not find');
    }
    return juice;
  }

# 级联

// juice\entities\juice.entity.ts
  @JoinTable()
  @ManyToMany(() => FlavorEntity, (flavor) => flavor.juice, {
    cascade: true,
  })

// juice\juice.service.ts
    @InjectRepository(FlavorEntity)
    private readonly flavorRepository: Repository<FlavorEntity>,
  ) {}
  async create(createJuiceDto: CreateJuiceDto) {
    const flavors = await Promise.all(
      createJuiceDto.flavors.map((name) => {
        return this.preloadFlavorByName(name);
      }),
    );
    const juice = this.juiceRepository.create({
      ...createJuiceDto,
      flavors,
    });
    return this.juiceRepository.save(juice);
  }
    private async preloadFlavorByName(name: string): Promise<FlavorEntity> {
    const existingFlavor = await this.flavorRepository.findOne({
      where: { name },
    });
    if (existingFlavor) {
      return existingFlavor;
    }
    return this.flavorRepository.create({ name });
  }
// juice\dto\create-juice.dto\create-juice.dto.ts
  @IsString({
    each: true,
  })
  readonly flavors?: string[];	//用string[]

# 分页

nest g class common/dto/pagination-query.dto --no-spec

src\common\dto\pagination-query.dto\pagination-query.dto.ts
import { Type } from 'class-transformer';
import { IsOptional, IsPositive } from 'class-validator';
export class PaginationQueryDto {
  @IsOptional()	// 可选的
  @IsPositive()	// 正数
  @Type(() => Number)	//自动转换为数字
  limit: number;	// 数字

或者

src\main.ts
  app.useGlobalPipes(
    new ValidationPipe({
      whitelist: true, // 只允许 DTO 中定义的属性
      transform: true, // 自动转换请求体中的数据类型
      forbidNonWhitelisted: true, // 禁止未在 DTO 中定义的属性
      transformOptions: {
        enableImplicitConversion: true, // 启用隐式类型转换
      },
    }),
  );

// src\juice\juice.service.ts
findAll(paginationQuery: PaginationQueryDto) {
  const { limit, offset } = paginationQuery;
  return this.juiceRepository.find({
    relations: ['flavors'], // 关联查询 flavors
    skip: offset, // 跳过前 offset 条记录
    take: limit, // 取 limit 条记录
  });
}

# 事务

nest g class events/entities/event.entity --no-spec

// src\events\entities\event.entity\event.entity.ts
import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
@Entity() // 声明这是一个实体类
export class Event {
  @PrimaryGeneratedColumn() // 主键，自动生成的列
  id: number;

  @Column() // 普通列，存储事件类型
  type: string;

  @Column() // 普通列，存储事件名称
  name: string;

  @Column('json') // JSON 列，存储事件的有效载荷
  payload: Record<string, any>;
}

// src\juice\juice.module.ts
@Module({
  imports: [TypeOrmModule.forFeature([Juice, FlavorEntity, Event])], // 使用前需在TypeOrmModule中添加Event

// src\juice\juice.service.ts
    private readonly connection: Connection,// 数据库连接
    
    async recommendJuice(juice: Juice) {
  const queryRunner = this.connection.createQueryRunner(); // 创建一个查询运行器

  await queryRunner.connect(); // 连接到数据库
  await queryRunner.startTransaction(); // 开始一个事务
  try {
    juice.recommendations++; // 增加推荐计数
    const recommendEvent = new Event(); // 创建一个新的事件实例
    recommendEvent.name = 'recommend_juice'; // 设置事件名称
    recommendEvent.type = 'juice'; // 设置事件类型
    recommendEvent.payload = { juiceId: juice.id }; // 设置事件有效载荷，包含果汁 ID
    await queryRunner.manager.save(juice); // 保存更新后的果汁
    await queryRunner.manager.save(recommendEvent); // 保存推荐事件
    await queryRunner.commitTransaction(); // 提交事务
  } catch (err) {
    await queryRunner.rollbackTransaction(); // 回滚事务
  } finally {
    await queryRunner.release(); // 释放查询运行器
  }
}

# @Index（）

这个装饰器用于在数据库中创建一个复合索引，包含 name 和 type 列。复合索引可以提高基于这两个列的查询性能，尤其是在需要同时使用这两个列进行过滤时。

// src\events\entities\event.entity\event.entity.ts

@Index(['name', 'type']) // 创建一个复合索引，包含 name 和 type 列
@Entity() // 声明这是一个实体类
export class Event {
  @PrimaryGeneratedColumn() // 主键，自动生成的列
  id: number;

  @Column() // 普通列，存储事件类型
  type: string;

  //这个装饰器用于为 name 列创建单独的索引。索引可以提高基于该列的查询性能。
  @Index() // 为 name 列创建单独的索引
  @Column() // 普通列，存储事件名称
  name: string;

  @Column('json') // JSON 列，存储事件的有效载荷
  payload: Record<string, any>;
}

# 数据库迁移

// 根目录/ormconfig.js
module.exports = {
    type: 'postgres',
    host: 'localhost',
    port: 5432,
    username: 'postgres',
    password: 'password',
    database: 'juice-db',
    entities: ['dist/**/*.entity.js'],
    migrations: ['dist/migrations/*.js'],
    cli: {
        migrationsDir: 'src/migrations',
    },
};

生成迁移文件

npx typeorm migration:create -n JuiceRefactor
// 报错尝试=>
npx typeorm migration:create src/migrations/JuiceRefactor

开发环境更改entity文件会同步更改数据库但是生产环境不会

在entity中更改 @Column()时，不但会更改列名，还会删除原列的数据

迁移帮助我们重命名现有列并维护我们以前的所有数据

import { MigrationInterface, QueryRunner } from 'typeorm';

export class JuiceRefactor1732098895763 implements MigrationInterface {
  public async up(queryRunner: QueryRunner): Promise<void> {}
	// up是我们要指示需要更改的内容以及如何更改的内容
  public async down(queryRunner: QueryRunner): Promise<void> {}
  	// down方法是我们要撤销或回滚任何这些更改的地方
}

import { MigrationInterface, QueryRunner } from 'typeorm';

// 定义迁移类，类名包含时间戳以确保唯一性
export class JuiceRefactor1732098895763 implements MigrationInterface {
  
  // 在迁移时执行的操作
  public async up(queryRunner: QueryRunner): Promise<void> {
    // 使用 queryRunner 执行 SQL 查询，将 "juice" 表中的 "name" 列重命名为 "title"
    await queryRunner.query(`
      ALTER TABLE "juice" RENAME COLUMN "name" TO "title";
    `);
  }

  // 在回滚迁移时执行的操作
  public async down(queryRunner: QueryRunner): Promise<void> {
    // 使用 queryRunner 执行 SQL 查询，将 "juice" 表中的 "title" 列重命名回 "name"
    await queryRunner.query(`
      ALTER TABLE "juice" RENAME COLUMN "title" TO "name";
    `);
  }
}

npm run build

// 更新ormconfig.js
const { DataSource } = require('typeorm');
module.exports = new DataSource({
    type: 'postgres',
    host: 'localhost',
    port: 5432,
    username: 'postgres',
    password: 'password',
    database: 'juice_db',
    entities: ['dist/**/*.entity.js'],
    migrations: ['dist/migrations/*.js'],
    cli: {
        migrationsDir: 'src/migrations',
    },
    synchronize: false, // 推荐设置为 false 以避免生产环境数据丢失
});

npx typeorm migration:run
// 报错 解决=>
npx typeorm migration:run -d ormconfig.js

# 撤回迁移

 npx typeorm migration:revert
 //报错 解决=>
 npx typeorm migration:revert -d ormconfig.js

# 自动生成迁移

npx typeorm migration:generate -n SchemaSync
 //报错 解决=>
npx typeorm migration:generate src/migrations/SchemaSync -d ormconfig.js
// 这里实际操作未成功

# 33 依赖注入（Dependency Injection, DI）

  constructor(private readonly juiceService: JuiceService) {}

@Injectable() // Injectable()装饰器声明了一个可以由Nest“容器”管理的类
export class JuiceService { // 将JuiceService类标记为“提供者”
  constructor(

  constructor(private readonly juiceService: JuiceService 这个请求告诉Nest将提供程序“注入”到我们的控制器类中) {}
  //构造函数中请求JuiceService 这个请求告诉Nest将提供程序“注入”到我们的控制器类中
  Nest知道-this-类也是一个“提供者”，因为我们在JuiceModule中包含

nest g mo juice-rating

nest g s juice-rating

@Module({
  imports: [JuiceModule],
  providers: [JuiceRatingService],
})

@Injectable()
export class JuiceRatingService {
  constructor(private readonly juiceService: JuiceService) {}
} // 会报错 因为 JuiceModule中 没有export JuiceService

// 解决 
  exports: [JuiceService]

# useValue()

const MockJuiceService = {}; // 定义一个空的 MockJuiceService 对象

@Module({  
  providers: [
    {
      provide: JuiceService, // 提供 JuiceService
      useValue: MockJuiceService, // 使用 MockJuiceService 作为 JuiceService 的实现
    },
  ], 
})

写法二

// juice\juice.module.ts
providers: [
  JuiceService, // 注册 JuiceService 作为提供者
  {
    provide: JUICE_BRANDS, // 定义一个提供者，标识符为 JUICE_BRANDS
    useValue: ['JuiceBrand1', 'JuiceBrand2'], // 使用一个数组作为 JUICE_BRANDS 的值
  },
],

// juice\juice.service.ts
    @Inject(JUICE_BRANDS) juiceBrands: string[],// 使用

// juice\juice.constants.ts // 创建一个存变量的文件 统一管理
export const JUICE_BRANDS = 'JUICE_BRANDS'; // 导出变量

# useClass()

允许动态确认一个token应该解析到的class


class ConfigService {}
class DevelopmentConfigService {}
class ProductionConfigService {}

@Module({
  imports: [TypeOrmModule.forFeature([Juice, FlavorEntity, Event])],  
  controllers: [JuiceController], 
  providers: [
    JuiceService,  
    {
      provide: ConfigService, // 提供 ConfigService
      useClass:
        process.env.NODE_ENV === 'development' // 根据环境选择使用的配置服务
          ? DevelopmentConfigService
          : ProductionConfigService,
    },

# useFactory()

允许我们动态创建提供者

@Injectable()
export class JuiceBrandsFactory {
  create() {
    return ['JuiceBrand1', 'JuiceBrand2'];
  }
}

providers: [
  JuiceService, 
  JuiceBrandsFactory, // 注册 JuiceBrandsFactory 作为提供者
  {
    provide: JUICE_BRANDS, // 定义一个提供者，标识符为 JUICE_BRANDS
    // useValue: ['JuiceBrand1', 'JuiceBrand2'], 
    // useFactory: () => ['JuiceBrand1', 'JuiceBrand2'],  
    useFactory: (juiceBrandsFactory: JuiceBrandsFactory) => // 使用工厂函数提供 JUICE_BRANDS
      juiceBrandsFactory.create(), // 调用 JuiceBrandsFactory 的 create 方法
    inject: [JuiceBrandsFactory], // 注入 JuiceBrandsFactory 作为依赖
  },
],

# async()

使用场景

异步提供者：这种方式允许您在提供者中执行异步操作，例如从数据库中获取数据或进行其他异步计算。在这个例子中，虽然没有实际使用 connection，但您可以在工厂函数中使用它来执行与数据库相关的操作。

useFactory: async (connection: Connection): Promise<string[]> => {
  const JuiceBrands = await Promise.resolve([
    'JuiceBrand1',
    'JuiceBrand2',
  ]);
  return JuiceBrands; // 返回果汁品牌数组
},
inject: [Connection], // 注入 Connection 作为依赖

# 动态模块与依赖注入实现数据库连接管理的设计模式

// src\database\database.module.ts
export class DatabaseModule {
  static register(options: ConnectionOptions): DynamicModule {
    return {
      module: DatabaseModule,
      providers: [
        { provide: 'CONNECTION', useValue: createConnection(options) },
      ],
    };
  }
}

@Module({
  imports: [
    JuiceModule,
    DatabaseModule.register({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'postgres',
      password: 'password',
      database: 'juice_db',
    }),
  ],
  providers: [JuiceRatingService],
})
export class JuiceRatingModule {}

# SCOPE

# DEFAULT

建议使用单例范围作为最佳实践

单例范围：这是默认的范围，意味着服务在应用程序的整个生命周期中只会被实例化一次。适用于大多数情况，因为它节省资源。

@Injectable({ scope: Scope.DEFAULT })

# TRANSIENT

生命周期瞬态‘transient’

瞬态范围：每次注入时都会创建一个新的实例。适用于需要独立状态的服务。

瞬态提供者不会在consumers之间共享

@Injectable({ scope: Scope.TRANSIENT })

使用TRANSIENT会实例化两次

scope 指定我们的自定义提供程序的范围

添加一个名为scope的额外属性

@Module({
  imports: [TypeOrmModule.forFeature([Juice, FlavorEntity, Event])],
  controllers: [JuiceController],
  providers: [
    JuiceService,
    JuiceBrandsFactory,
    {
      provide: JUICE_BRANDS,
      // useValue: ['JuiceBrand1', 'JuiceBrand2'],
      useFactory: async (connection: Connection): Promise<string[]> => {
        const JuiceBrands = await Promise.resolve([
          'JuiceBrand1',
          'JuiceBrand2',
        ]);
        return JuiceBrands;
      },
      inject: [Connection],
      scope: Scope.TRANSIENT, //也可以这种写法

# REQUST scope

每次请求时都会创建一个新的实例。适用于需要在请求期间保持状态的服务。

如果contorller依赖于属于REQUEST scope范围的Service，contorller也隐式地变为REQUEST scope

当一个 Controller 依赖于一个 REQUEST 范围的 Service 时，Controller 也会隐式地变为 REQUEST 范围。这意味着每次请求都会创建新的 Controller 和 Service 实例。这种设计在需要处理与请求相关的状态时非常有用，但也可能对性能产生影响，尤其是在高并发的情况下，因为每个请求都会导致更多的实例化操作。

意味着两者都是专门为每个请求创建的

@Controller('juice')
export class JuiceController {
  constructor(
    private readonly juiceService: JuiceService,
    @Inject(REQUEST) private readonly request: Request,
  ) {
    console.log('控制器实例化');
  }

可能对性能产生影响

评估需求：首先评估是否真的需要 REQUEST 范围。如果不需要与请求相关的状态，考虑使用 DEFAULT 范围。

优化代码：确保 Service 和 Controller 的构造函数中没有复杂的逻辑，以减少实例化的开销。

缓存：在可能的情况下，使用缓存来减少对 Service 的调用次数。

在使用 REQUEST 范围时，确保它是必要的，并且代码经过优化以减少性能影响。

# 运行环境

process.env

@nestjs/config

npm install @nestjs/config

// app.moudle.ts
@Module({
  imports: [
    ConfigModule.forRoot(),// 将从默认位置解析.env文件中的键值对，将结果存储在私有结构中，我们可以通过ConfigService类在应用程序的任何位置访问该结构

// .env
DATABASE_USERNAME=postgres
DATABASE_PASSWORD=password
DATABASE_NAME=juice_db
DATABASE_PORT=5432
DATABASE_HOST=localhost

记得在 gitignore添加.env

使用

@Module({
  imports: [
    ConfigModule.forRoot({
      envFilePath: '.env', // 寻找env文件的路径
      // ignoreEnvFile: true, //忽略env文件
    }),
    UserModule,
    JuiceModule,
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: process.env.DATABASE_HOST,
      port: +process.env.DATABASE_PORT, //默认是文字 所以转下数字
      username: process.env.DATABASE_USERNAME,
      password: process.env.DATABASE_PASSWORD,
      database: process.env.DATABASE_NAME,
      autoLoadEntities: true,
      synchronize: true,
    }),
    JuiceRatingModule,
    DatabaseModule,
  ],

# 环境抛错

npm i @hapi/joi // 已经弃用
 npm install joi //解决

npm i --save-dev @types/hapi__joi

// import Joi from '@hapi/joi';// 已经弃用
import * as Joi from 'joi';//解决

# ConfigModule

// src\juice\juice.module.ts
@Module({
  imports: [
    TypeOrmModule.forFeature([Juice, FlavorEntity, Event]),
    ConfigModule, // 引用
  ],

ConfigModule有configService提供get方法

// src\juice\juice.service.ts
@Injectable()
export class JuiceService {
  constructor( 
    private readonly configService: ConfigService,
  ) { 
    const databaseHost = this.configService.get<string>('DATABASE_HOST'); // 默认情况下 每个环境变量都是字符串
    console.log(databaseHost);
  }
  // 也可以
      const databaseHost = this.configService.get<string>(
      'DATABASE_HOST',
      'localhost', //如果该环境变量不存在或未定义，则使用 'localhost' 作为默认值。
    );

# app.config.ts

// src\config\app.config.ts
export default () => ({
  environment: process.env.NODE_ENV || 'development',
  database: {
    host: process.env.DATABASE_HOST,
    port: parseInt(process.env.DATABASE_PORT, 10) || 5432,
  },
});
 // 这里可以自由更改env中的数据类型和任何更改

加载配置

// src\juice\juice.module.ts
@Module({
  imports: [
    TypeOrmModule.forFeature([Juice, FlavorEntity, Event]),
    ConfigModule.forRoot({
      load: [appConfig], // 加载appconfig
    }),

如何使用

// src\juice\juice.service.ts
    const databaseHost = this.configService.get('database.host', 'localhost'); // 默认情况下 每个环境变量都是字符串

# src\juice\config\juice.config.ts

// src\juice\config\juice.config.ts
 registerAs 函数来注册一个名为 'juice' 的配置模块。这个模块返回一个对象，其中包含一个键值对 foo: 'bar'。

// src\juice\juice.module.ts
@Module({
  imports: [
    TypeOrmModule.forFeature([Juice, FlavorEntity, Event]),
    ConfigModule.forFeature(juiceConfig), // 注册
  ],

// src\juice\juice.service.ts
@Injectable()
export class JuiceService {
  constructor( 
    private readonly configService: ConfigService,
  ) { 
    const databaseHost = this.configService.get('database.host', 'localhost'); // 默认情况下 每个环境变量都是字符串
    console.log(databaseHost);
  }

@Injectable()
export class JuiceService {
  constructor( 
    private readonly configService: ConfigService,
  ) { 
    const juice = this.configService.get('juice');
    console.log(juice);
  }

@Injectable()
export class JuiceService {
  constructor( 
    @Inject(juiceConfig.KEY)
    private readonly juiceConfiguration: ConfigType<typeof juiceConfig>,
  ) { 
    console.log(juiceConfiguration);
  }

// src\app.module.ts
    TypeOrmModule.forRoot({ 
    }),
    ConfigModule.forRoot({ 
    }),

ConfigModule不能在使用之后注册不然会报错

// src\app.module.ts
    TypeOrmModule.forRootAsync({
      useFactory: () => ({ 
      }),
    }),
    ConfigModule.forRoot({
      load: [appConfig],
    }),

# forRootAsync ，useFactory

这种工厂函数可以异步获取

# GLOBAL

# controller

# method

# param（pipes only）

# PIPES（管道）

管道的主要功能是转换和验证数据类型。

数据转换：将输入的数据转换为目标类型。

数据验证：验证数据的有效性，如果无效则抛出异常。

# APP_PIPE

使用 APP_PIPE 令牌注册了一个全局管道

将 ValidationPipe 设置为全局验证管道

// src\app.module.ts
  providers: [
    AppService,
    {
      provide: APP_PIPE,
      useClass: ValidationPipe,
    },
  ],

// src\juice\juice.controller.ts
import { ValidationPipe } from '@nestjs/common';
// 1
@UsePipes(ValidationPipe) //建议使用类
@Controller('juice') //整个controller生效
// 2
@UsePipes(new ValidationPipe({ transform: true }))
@Get() // 仅get生效
// 3 
  @Patch(':id')
  update(
    @Param('id') id: number,
    @Body(ValidationPipe)
	// 仅body生效
	updateJuiceDto: UpdateJuiceDto,
  ) {

# 自定义管道

nest g pipe common/pipes/parse-int

@Injectable()
export class ParseIntPipe implements PipeTransform {
  transform(value: any, metadata: ArgumentMetadata) {
    const val = parseInt(value, 10); // 将输入值转换为整数
    if (isNaN(val)) { // 检查转换后的值是否为NaN
      throw new BadRequestException(val + `is not an integer`); // 抛出异常，提示值不是整数
    }
    return val; // 返回转换后的整数
  }
}

  findTwo(@Param('id', ParseIntPipe// 添加管道) id: number) { 
    return this.juiceService.findOneById(id);
  }

# GUARDS（守卫）

确认请求是否满足一些条件如身份验证授权角色

nest g guard common/guards/api-key

// 使用 @Injectable 装饰器将类标记为可注入的服务
@Injectable()
export class ApiKeyGuard implements CanActivate {
  // 实现 CanActivate 接口的 canActivate 方法
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    // 获取 HTTP 请求对象
    const request = context.switchToHttp().getRequest<Request>();
    // 从请求头中获取 'Authorization' 字段
    const authHeader = request.header('Authorization');
    // 检查请求头中的 API 密钥是否与环境变量中的 API_KEY 相匹配
    return authHeader === process.env.API_KEY;
  }
}

# SetMetadata

  @SetMetadata('isPublic', true)
  @Get()

// src\common\decorators
import { SetMetadata } from '@nestjs/common';
export const IS_PUBLIC_KEY = 'isPublic';
export const Public = () => SetMetadata(IS_PUBLIC_KEY, true);

  @Public()
  @Get()

nest g mo common

// src\common\common.module.ts
// 使用 @Module 装饰器定义一个模块
@Module({
  // 导入其他模块，这里导入了 ConfigModule
  imports: [ConfigModule],
  // 定义提供者
  providers: [
    {
      // 提供一个全局守卫
      provide: APP_GUARD,
      // 使用 ApiKeyGuard 作为守卫的实现
      useClass: ApiKeyGuard,
    },
  ],
})
// 定义 CommonModule 类
export class CommonModule {}

# INTERCEPTORS(拦截器)

请求和响应的转换：可以在请求到达处理程序之前或响应发送到客户端之前对其进行转换。

日志记录：可以记录请求和响应的详细信息，帮助进行调试和监控。

错误处理：可以捕获和处理在处理程序中抛出的异常，提供统一的错误处理机制。

缓存：可以在请求处理之前检查缓存，并在可能的情况下返回缓存的响应，而不必调用处理程序。

性能监控：可以测量请求处理的时间，帮助识别性能瓶颈。

nest g interceptor common/interceptor/wrap-response

// 使用 @Injectable 装饰器将类标记为可注入的服务
@Injectable()
export class WrapResponseInterceptor implements NestInterceptor {
  // 实现 NestInterceptor 接口的 intercept 方法
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    // 使用 RxJS 的 map 操作符包装响应数据
    return next.handle().pipe(map((data) => ({ data })));
    // 或者使用tap
    return next.handle().pipe(tap((data) => ({ data })));
  }
}

// main.ts
  app.useGlobalInterceptors(new WrapResponseInterceptor());

# ExceptionFilter 异常过滤器

nest g filter common/filters/http-exception

// 使用 @Catch 装饰器捕获 HttpException 类型的异常
@Catch(HttpException)
export class HttpExceptionFilter<T extends HttpException>
  implements ExceptionFilter
{
  // 实现 ExceptionFilter 接口的 catch 方法
  catch(exception: T, host: ArgumentsHost) {
    // 获取 HTTP 上下文
    const ctx = host.switchToHttp();
    // 获取 Express 的响应对象
    const response = ctx.getResponse<Response>();
    // 获取异常的 HTTP 状态码
    const status = exception.getStatus();
    // 获取异常的响应内容
    const exceptionResponse = exception.getResponse();
    // 判断响应内容是否为字符串，如果是则包装为对象
    const error =
      typeof response === 'string'
        ? { message: exceptionResponse }
        : (exceptionResponse as object);
    // 发送 JSON 响应，包含异常信息和时间戳
    response.status(status).json({
      ...error,
      timestamp: new Date().toISOString(), // 添加时间戳
    });
  }
}

// src\main.ts 使用
  app.useGlobalFilters(new HttpExceptionFilter());

# 请求超时

nest g interceptor common/interceptors/timeout

@Injectable() 
export class TimeoutInterceptor implements NestInterceptor {  
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> { // 拦截方法，接收执行上下文和下一个处理程序
    return next.handle().pipe(timeout(3000)); // 处理请求并设置超时时间为3000毫秒
  }
}

  @Get()
  async findAll(@Query() paginationQuery: PaginationQueryDto) {
    await new Promise((resolve) => setTimeout(resolve, 5000));
    return this.juiceService.findAll(paginationQuery);
  }

中间件

nest g middleware common/middleware/logging

export class LoggingMiddleware implements NestMiddleware {
  use(req: any, res: any, next: () => void) {  
    // 在响应结束时记录请求-响应时间
    res.on('finish', () => console.timeEnd('Request-response time'));
    next(); // 继续处理请求
  }
}

// src\common\common.module.ts
export class CommonModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    // 应用 LoggingMiddleware 到所有路由
    consumer.apply(LoggingMiddleware).forRoutes('*'); 
    // 以下是其他可能的路由配置示例
    // consumer.apply(LoggingMiddleware).forRoutes('juice'); // 仅应用于 'juice' 路由
    // consumer.apply(LoggingMiddleware).forRoutes({ // 应用于 'juice' 路由的 GET 请求
    //   path: 'juice',
    //   method: RequestMethod.GET,
    // });
    // consumer.apply(LoggingMiddleware).exclude('juice').forRoutes('*'); // 排除 'juice' 路由
  }
}

自定义参数装饰器

// src\common\decorators\protocol.decorator.ts 
export const Protocol = createParamDecorator(
  (defaultValue: string, ctx: ExecutionContext) => {
    console.log({ defaultValue }); 
    const request = ctx.switchToHttp().getRequest();
    return request.protocol;
  },
);

@Controller('juice')
export class JuiceController {
  @Public()
  @Get()
  async findAll(
    @Protocol('https') Protocol: string,
    @Query() paginationQuery: PaginationQueryDto,
  ) {
    console.log(Protocol);}}

# swagger

npm i @nestjs/swagger swagger-ui-express

  const options = new DocumentBuilder()
    .setTitle('juice') // 设置API标题
    .setDescription('juice application') // 设置API描述
    .setVersion('1.0') // 设置API版本
    .build();
  const document = SwaggerModule.createDocument(app, options); // 创建Swagger文档
  SwaggerModule.setup('api', app, document); // 设置Swagger模块

# 自动生成

// nest-cli.json
  "compilerOptions": {
    "deleteOutDir": true,
    "plugins": [
      "@nestjs/swagger/plugin" // 添加 Swagger 插件以支持 API 文档生成
    ]
  }

import { PartialType } from '@nestjs/swagger';

# ApiProperty

export class CreateJuiceDto {
  @ApiProperty({ description: '果汁名称' })
  @IsString()
  readonly name?: string;}

# ApiResponse

  @ApiResponse({
    status: 403,
    description: 'forbidden',
  })
  @ApiForbiddenResponse({
    description: 'forbidden',
  })
  @Public()
  @Get()

# ApiTags

@ApiTags('juice') //模块标签

# nestjs 处理 HTTP 请求和响应的核心流程

![img](file:///C:/Users/Administrator/AppData/Local/Temp/企业微信截图_17333877431674.png)

# test

最小可测试单元（通常是函数或方法）进行验证
npm run test # for unit tests
运行测试并生成测试覆盖率报告
npm run test:cov # for test coverage
端到端（E2E）测试。E2E 测试是对整个应用程序进行测试，以确保所有组件和服务在一起正常工作，模拟用户的实际使用场景。
npm run test:e2e # for e2e tests

一般以spec.ts文件名结尾

describe //包裹要测试的内容
beforeEach//每次测试之前执行（设置阶段）
有时候在测试执行之后
afterEach afterAll
it()//单独测试

npm run test:watch -- juice.service
// watch模式下运行 任何文件更改时自动重新测试

// src\juice\juice.service.spec.ts
describe('JuiceService', () => {
  let service: JuiceService;
  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      // 提供 JuiceService 及其依赖项
      providers: [
        JuiceService,
        { provide: Connection, useValue: {} }, // 模拟 Connection
        {
          provide: getRepositoryToken(FlavorEntity),
          useValue: {}, // 模拟 FlavorEntity 的存储库
        },
        {
          provide: getRepositoryToken(Juice),
          useValue: {}, // 模拟 Juice 的存储库
        },
      ],
    }).compile();
    service = module.get<JuiceService>(JuiceService); // 获取 JuiceService 实例
  });
  it('should be defined', () => {
    expect(service).toBeDefined(); // 确保服务已定义
  });
});

68 - 71 test 跳过

# MongoDB

// learn\docker-compose.yml
version: "3"

services:
  db:
    image: mongo
    restart: always
    ports:
      - 27017:27017
    environment:
       MONGODB_DATABASE: nest-course

 docker-compose up -d

依赖安装

npm i mongoose @nestjs/mongoose

npm i -D @types/mongoose

// src\juice\entities\juice.entity.ts
import { Schema, Prop, SchemaFactory } from '@nestjs/mongoose';

@Schema()
export class Juice extends Document {
  @Prop()
  name: string;

  @Prop()
  color: string;

  @Prop([String])
  flavors: string[];
}

export const JuiceSchema = SchemaFactory.createForClass(Juice);

// src\juice\juice.module.ts
@Module({
  imports: [
    MongooseModule.forFeature([{ name: Juice.name, schema: JuiceSchema }]),
  ],
  controllers: [JuiceController],
  providers: [JuiceService],
})
export class JuiceModule {}

# 增删改查

@Injectable()
export class JuiceService {
  constructor(@InjectModel(Juice.name) private juiceModel: Model<Juice>) {}

  findAll() {
    return this.juiceModel.find().exec();
  }

  async findOneById(id: number) {
    const juice = await this.juiceModel.findOne({ _id: id }).exec();
    if (!juice) {
      //   throw new HttpException(
      //     'juice ' + id + ' is not find',
      //     HttpStatus.NOT_FOUND,
      //   );
      throw new NotFoundException('juice ' + id + ' is not find');
    }
    return juice;
  }

  create(createJuiceDto: CreateJuiceDto) {
    const juice = new this.juiceModel(createJuiceDto);
    return juice.save();
  }

  async update(id: string, undateJuiceDto: UpdateJuiceDto) {
    const existingJuice = await this.juiceModel
      .findOneAndUpdate({ _id: id }, { $set: undateJuiceDto }, { new: true })
      .exec();
    if (!existingJuice) {
      throw new NotFoundException('juice ' + id + ' is not find');
    }
    return existingJuice;
  }

  async remove(id: string) {
    const juice = await this.juiceModel.findByIdAndDelete(id).exec();
    if (!juice) {
      throw new NotFoundException('juice ' + id + ' is not find');
    }
    return juice;
  }
}

# 分页查询

nest g class common/dto/pagination-query.dto --no-spec

export class PaginationQueryDto {
  @IsOptional() // 可选字段
  @IsPositive() // 必须是正数
  @Type(() => Number) // 转换为数字类型
  limit: number; // 每页限制数量

  @IsOptional() // 可选字段
  @IsPositive() // 必须是正数
  @Type(() => Number) // 转换为数字类型
  offset: number; // 偏移量
}

  @Get()
  findAll(@Query() paginationQuery: PaginationQueryDto) { 
    return this.juiceService.findAll(paginationQuery);
  }

  findAll(paginationQuery: PaginationQueryDto) {
    const { limit, offset } = paginationQuery;
    return this.juiceModel.find().skip(offset).limit(limit).exec();
  }

# 事务

nest g class events/entities/event.entity --no-spec

// src\events\entities\event.entity\event.entity.ts
@Schema()
export class EventEntity extends Document {
  @Prop()
  type: string;

  @Prop()
  name: string;

  @Prop({ type: mongoose.Schema.Types.Mixed })
  payload: Record<string, any>;
}

export const EventSchema = SchemaFactory.createForClass(EventEntity);

# 设计模式

# IOC

# DI

# 类装饰器

# 属性装饰器

# 参数装饰器

# 方法装饰器

# Nest.js

# 安装

# 换行格式

# 目录结构

# demo

# 快速创建

# Module

# Controller

# Provider

# 数据库

# schema

# 控制器

# 路由

# Request

# 请求装饰器

# 路由通配符

# 状态码

# headers

# 重定向

# 路由参数

# 子域路由

# 请求负载

# 最后一步

# Providers

# 依赖注入

# 可选提供者

# 基于属性的注入

# 小满nest

# RESTful风格设计

# Controller Request (获取前端传过来的参数)

# 获取get请求传参

# post获取参数

# 动态路由

# 读取header信息

# 状态码

# session

# Providers

# module引入service在providers注入

# 在Controller就可以使用注入好的service了

# 第二种用法（自定义名称）

# 自定义名称之后 要用对应的inject取 不然会找不到

# 自定义注入值

# 工厂模式

# 异步模式

# 模块@Module

# 共享模块

# 全局模块

# 动态模块

# 中间件

# 创建一个依赖注入中间件

# 全局中间件

# 接入第三方中间间 例如cors处理跨域

# nest上传图片

# 主要用两个包

# controller

# 3.生成静态目录访问上传之后的图片

# 下载图片

# RXJS

# 响应拦截器

# 拦截器

# 异常拦截器

# 全局异常拦截器

# 管道转换

# 案例一 我们接收一个动态参数希望是一个number类型 现在是string

# 案例二 验证UUID

# 管道验证DTO

# nest爬虫

# 守卫

# 自定义装饰器

# swagger接口文档

# ApiTags 分组

# ApiOperation 接口描述

# ApiParam 动态参数描述 => /pipe/12312312

# 自定义名称之后要用对应的inject取不然会找不到

# 接入第三方中间间例如cors处理跨域

# 案例一我们接收一个动态参数希望是一个number类型现在是string

# 案例二验证UUID

# 一对多多对一