nestjs入门实践 #

// 主入口main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();
// NestFactory公开了一些允许创建应用程序实例的静态方法。这个create()方法返回一个application对象

- prebuild 删除dist目录，为重新完整构建做准备（每次构建时，nest会自动执行这个）；

- build 构建当前工作区nest项目，会产生一个dist目录，其中是经过编译的代码

- format 使用prettier格式化当前项目的代码

- start 启动当前项目

- start:dev 以开发模式启动当前项目，相比上面的start，区别是你可以边开发边调试程序，当发生文件被改动（保存），nest会自动重新加载；

- start:debug 开发模式下，输出更多的调试信息；

- start:prod 以生产模式运行，此时项目不在运行再nest cli中，而是直接运行编译后的项目；

- lint 格式化所有ts代码，并修正代码的格式问题；

- test 运行jest进行测试；

- test:watch 同上，程序文件变化后自动测试；

- test:cov 输出测试覆盖信息；

- test:debug 运行一个websocket是的在浏览器中可以直接调试；

- test:e2e 根据配置文件进行测试；

sage: nest <command> [options]

Options:
  -v, --version                                   Output the current version.
  -h, --help                                      Output usage information.

Commands:
  new|n [options] [name]                          Generate Nest application.
  build [options] [app]                           Build Nest application.
  start [options] [app]                           Run Nest application.
  info|i                                          Display Nest project details.
  update|u [options]                              Update Nest dependencies.
  add [options] <library>                         Adds support for an external library to your project.
  generate|g [options] <schematic> [name] [path]  Generate a Nest element.
    Available schematics:
      ┌───────────────┬─────────────┬──────────────────────────────────────────────┐
      │ name  应用名   │ alias别名    │ description       描述                       │
      │ application   │ application │ Generate a new application workspace         │
      │ class         │ cl          │ Generate a new class                         │
      │ configuration │ config      │ Generate a CLI configuration file            │
      │ controller    │ co          │ Generate a controller declaration            │
      │ decorator     │ d           │ Generate a custom decorator                  │
      │ filter        │ f           │ Generate a filter declaration                │
      │ gateway       │ ga          │ Generate a gateway declaration               │
      │ guard         │ gu          │ Generate a guard declaration                 │
      │ interceptor   │ in          │ Generate an interceptor declaration          │
      │ interface     │ interface   │ Generate an interface                        │
      │ middleware    │ mi          │ Generate a middleware declaration            │
      │ module        │ mo          │ Generate a module declaration                │
      │ pipe          │ pi          │ Generate a pipe declaration                  │
      │ provider      │ pr          │ Generate a provider declaration              │
      │ resolver      │ r           │ Generate a GraphQL resolver declaration      │
      │ service       │ s           │ Generate a service declaration               │
      │ library       │ lib         │ Generate a new library within a monorepo     │
      │ sub-app       │ app         │ Generate a new application within a monorepo │
      │ resource      │ res         │ Generate a new CRUD resource

 // 创建控制器
 nest g co controllername
 // 创建模块
 nest g mo modelname
 // 创建服务
 nest g s servicename
 // 不带单元测试
 nest g s auth/auth  --no-spec
 // 创建curd
 nest g res resname

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import {CatModule} from "./cat/cat.module"
@Module({
  imports: [CatModule],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

// cat.module.ts
import { Module } from "@nestjs/common";
import { CatController } from "./cat.controller";
import { CatService } from "./cat.service";
@Module({
  controllers: [CatController],
  providers: [CatService], 
  exports: [CatService], 
})
export class CatModule {}

import { Module } from '@nestjs/common';
import { ModuleA } from './ModuleA';
import { ModuleB } from './ModuleB';
@Global
@Module({
  imports: [ModuleA,ModuleB],
  exports: [ModuleA,ModuleB],
})
export class ShareModule {
}

const app = await NestFactory.create(AppModule);
app.use(logger);
await app.listen(3000);

{
  "statusCode": 500,
  "message": "Internal server error"
}

@Get()
async findAll() {
  throw new HttpException('Forbidden', HttpStatus.FORBIDDEN);
}

{
  "statusCode": 403,
  "message": "Forbidden"
}

@Get()
async findAll() {
  throw new HttpException({
    status: HttpStatus.FORBIDDEN,
    error: 'This is a custom message',
  }, HttpStatus.FORBIDDEN);
}

{
  "status": 403,
  "error": "This is a custom message"
}

export class ForbiddenException extends HttpException {
  constructor() {
    super("Forbidden", HttpStatus.FORBIDDEN);
  }
}

@Get()
async findAll() {
  throw new ForbiddenException();
}

// src/common/filters/http-exception.filter.ts
import {
  ExceptionFilter,
  Catch,
  ArgumentsHost,
  HttpException,
} from "@nestjs/common";
import { Request, Response } from "express";

@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    console.log('上下文',ctx);
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();
    const status = exception.getStatus();
    const exceptionRes:any=exception.getResponse()
    const {error,msg}=exceptionRes
    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
      error,
      msg
    });
  }
}

// app.controller.ts
  @Get()
  @UseFilters(new HttpExceptionFilter)
  async getHello(@Query() { id },): Promise<any> {
    if (!id) {
      throw new HttpException({
        status: HttpStatus.BAD_REQUEST,
        msg: '请求参数id必传',
        error: 'id is required'
      }, HttpStatus.BAD_REQUEST)
    }
    return await this.appService.getHello();
  }

{
    "statusCode": 400,
    "timestamp": "2021-06-20T06:56:26.387Z",
    "path": "/api/user",
    "error": "id is required",
    "msg": "请求参数id必传"
}

// main.ts
import { HttpExceptionFilter } from "./common/filters/http-exception.filter"
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.setGlobalPrefix('api')
  app.useGlobalFilters(new HttpExceptionFilter())
  await app.listen(3000);
}

@Get(':id')
async findOne(@Param('id', ParseIntPipe) id: number) {
  return this.catService.findOne(id);
}

{
  "statusCode": 400,
  "message": "Validation failed (numeric string is expected)",
  "error": "Bad Request"
}

@Get(':id')
async findOne(
  @Param('id', new ParseIntPipe({ errorHttpStatusCode: HttpStatus.NOT_ACCEPTABLE }))
  id: number,
) {
  return this.catService.findOne(id);
}

import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from "@nestjs/common";

@Injectable()
export class ValidationPipe implements PipeTransform<string> {
  transform(value: string, metadata: ArgumentMetadata) {
    const val=parseInt(value,10)
    if(isNaN(val)){
      throw new BadRequestException('参数不合法，需为Number类型')
    }
    return value;
  }
}

export interface ArgumentMetadata {
  type: "body" | "query" | "param" | "custom";
  metatype?: Type<unknown>;
  data?: string;
}

export class CreateCatDto {
  name: string;
  age: number;
  breed: string;
}

@Post()
async create(@Body() createCatDto: CreateCatDto) {
  this.catsService.create(createCatDto);
}

import { IsString, IsInt } from "class-validator";

export class CreateCatDto {
  @IsString()
  name: string;

  @IsInt()
  age: number;

  @IsString()
  breed: string;
}

import {
  PipeTransform,
  Injectable,
  ArgumentMetadata,
  BadRequestException,
} from "@nestjs/common";
import { validate } from "class-validator";
import { plainToClass } from "class-transformer";

@Injectable()
export class ValidationPipe implements PipeTransform<any> {
  async transform(value: any, { metatype }: ArgumentMetadata) {
    if (!metatype || !this.toValidate(metatype)) {
      return value;
    }
    const object = plainToClass(metatype, value);
    const errors = await validate(object);
    if (errors.length > 0) {
      throw new BadRequestException("Validation failed");
    }
    return value;
  }

  private toValidate(metatype: Function): boolean {
    const types: Function[] = [String, Boolean, Number, Array, Object];
    return !types.includes(metatype);
  }
}

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

@Get()
async findAll(
  @Query('activeOnly', new DefaultValuePipe(false), ParseBoolPipe) activeOnly: boolean,
  @Query('page', new DefaultValuePipe(0), ParseIntPipe) page: number,
) {
  return this.catsService.findAll({ activeOnly, page });
}

// src/common/guard/auth.guard.ts
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();
    return validateRequest(request);
  }
}
// 实现validateRequest 方法，函数中的逻辑可以根据需要变得简单或复杂
const validateRequest=request=>{
  return true
}

import { Controller, Get, Post, Body, Query, UseGuards } from '@nestjs/common';
import { CreateCatDto } from './dto/create-cat.dto';
import { CatService } from './cat.service';
import { Cat } from './interfaces/cat.interface';
import {AuthGuard} from "./../common/guard/auth.guard"

@Controller('cat')
// controller全局
@UseGuards(AuthGuard)
export class CatController {
  constructor(private catService: CatService) {}

  @Post()
  // 单个请求
  @UseGuards(AuthGuard)
  async create(@Body() createCatDto: CreateCatDto) {
    this.catService.create(createCatDto);
  }

  @Get()
  async findAll(@Query() query): Promise<Cat[]> {
    console.log('获猫猫',query);
    return this.catService.findAll();
  }
}

// app.module.ts
@Module({
  imports: [CatModule],
  controllers: [AppController],
  // providers: [AppService],
  providers: [
    {
      provide: APP_GUARD,
      useClass: AuthGuard,
    },
    AppService
  ],
})

import {AuthGuard} from "./common/guard/auth.guard"
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.setGlobalPrefix('api')
  // 设置全局守卫
  app.useGlobalGuards(new AuthGuard())
  await app.listen(3000);
}
bootstrap()

// src/common/guard/auth.guard.ts
import { Injectable, CanActivate, ExecutionContext } from "@nestjs/common";
import { Observable } from "rxjs";
import { Reflector } from '@nestjs/core';
@Injectable()
export class AuthGuard implements CanActivate {
  constructor(private reflector: Reflector) {}
  canActivate(
    context: ExecutionContext
  ): boolean | Promise<boolean> | Observable<boolean> {
    const request = context.switchToHttp().getRequest();
    const roles =this.reflector.get<string[]>("auth", context.getHandler());
    console.log('获取的auth权限',roles);
    // 获取的auth权限 [ 'admin', 'man' ]
    return validateRequest(request);
  }
}
const validateRequest=request=>{
  console.log('守卫',request.headers);
  /*
    {
      'content-type': 'application/json',
      'user-agent': 'PostmanRuntime/7.28.0',
      accept: '',
      'cache-control': 'no-cache',
      'postman-token': '55855348-ac4b-4b84-9202-77503a5ed6ab',
      host: '127.0.0.1:3000',
      'accept-encoding': 'gzip, deflate, br',
      connection: 'keep-alive',
      'content-length': '17',
      cookie: 'csrfToken=5vJ8HPpNQZmycqSmzN1JzyuJ'
    }
   */
  return true
}

// src/cat/cat.controller.ts
import {AuthGuard} from "./../common/guard/auth.guard"
@Controller('cat')
export class CatController {
  constructor(private catService: CatService) {}
  @Put(":id")
  // 自定义元数据
  @SetMetadata('auth',['admin','man'])
  @UseGuards(AuthGuard)
  async update(@Param() {id}){
    console.log('参数',id);
    return "更新成功"
  }
}

 @SetMetadata('auth',['admin','man'])

// src/common/decorator/auth.decorator.ts
import { SetMetadata } from '@nestjs/common';
export const Auth = (...roles: string[]) => SetMetadata('auth', roles);

  @Auth('admin','man')
  @UseGuards(AuthGuard)

//请求时长拦截器
//nest g in common/interceptor/logging
import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';
@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    console.log('Before...');
    const now = Date.now();
    return next
    .handle()
    .pipe(
      tap(() => console.log(`After... ${Date.now() - now}ms`)),
    );
  }
}

 // 路由拦截器
  @Get('man')
  @UseInterceptors(LoggingInterceptor)
  async findOne(@Query() query): Promise<String> {
    return '查找男猫猫'
  }
 // controller
  @Controller('cat')
  @UseInterceptors(LoggingInterceptor)
  export class CatController {
   }
  // module
  import { APP_INTERCEPTOR } from '@nestjs/core';
  @Module({
  providers: [
    {
      provide: APP_INTERCEPTOR,
      useClass: LoggingInterceptor,
    },
  ],
  })
  // 全局
  app.useGlobalInterceptors(new LoggingInterceptor());

// common/interceptor/timeout.interceptor.ts
import { CallHandler, ExecutionContext, Injectable, NestInterceptor, RequestTimeoutException } from '@nestjs/common';
import { Observable, throwError, TimeoutError } from 'rxjs';
import { catchError, timeout } from 'rxjs/operators';

@Injectable()
export class TimeoutInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      timeout(5000),
      catchError(err=>{
        if(err instanceof TimeoutError)
          return throwError(new RequestTimeoutException())
        return throwError(err)
      })
    );
  }
}

// common/interceptor/exception.interceptor.ts
import { CallHandler, ExecutionContext, HttpException, HttpStatus, Injectable, NestInterceptor } from '@nestjs/common';
import { Observable, throwError } from 'rxjs';
import {catchError} from "rxjs/operators"
@Injectable()
export class ExceptionInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      catchError(err=>throwError(new HttpException('系统异常',HttpStatus.BAD_GATEWAY)))
    );
  }
}

import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { Observable } from 'rxjs';
import {map} from "rxjs/operators"
export interface Response<T>{
  code:Number,
  data:T,
  msg:String
}
@Injectable()
export class TransformInterceptor<T> implements NestInterceptor<T, Response<T>> {
  intercept(context: ExecutionContext, next: CallHandler): Observable<Response<T>> {
    //解析上下文
    const ctx=context.switchToHttp()
    const request=ctx.getRequest()
    return next.handle().pipe(map(data => {
      console.log('结果',data);
      return {
        code:0,
        data,
        msg:'请求成功',
        timestamp:+new Date(),
        path:request.url
      }
    }));
  }
}

// src/common/decorator/user.decorator.ts
import { createParamDecorator, ExecutionContext } from "@nestjs/common";

export const User = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return request.user;
  }
);

// src/cat/cat.controller.ts
//http://127.0.0.1:3000/api/cat/man
//请求body { user: { name: '小王', age: 12 } }

@Get('man')
  async findOne(@User() user): Promise<String> {
    console.log('获取请求值',user); //获取请求值 { user: { name: '小王', age: 12 } }
    return '查找男猫猫'
}

// src/common/decorator/user.decorator.ts
import { createParamDecorator, ExecutionContext } from "@nestjs/common";

export const User = createParamDecorator(
  (data: string, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return data?request.body?.user[data]:request.body;
  }
);
// src/cat/cat.controller.ts
 @Get('man')
  async findOne(@User('name') user): Promise<String> {
    console.log('获取请求值',user); //直接取出name值 小王
    return '查找男猫猫'
  }

import { applyDecorators } from "@nestjs/common";

export function Auth(...roles: Role[]) {
  return applyDecorators(
    SetMetadata("roles", roles),
    UseGuards(AuthGuard, RolesGuard),
    ApiBearerAuth(),
    ApiUnauthorizedResponse({ description: 'Unauthorized"' })
  );
}

@Get('users')
@Auth('admin')
findAllUsers() {}