Nodejs web框架之Nestjs 使用笔记

import { Module, DynamicModule } from '@nestjs/common';
import { createDatabaseProviders } from './database.providers';
import { Connection } from './connection.provider';

动态模块扩展了模块，而不是覆盖了基础的module配置，并没有覆盖下边的connection
@Module({
  providers: [Connection],
})
export class DatabaseModule {
  // forRoot 返回一个可能是同步或者异步的动态模块
  static forRoot(entities = [], options?): DynamicModule {
    const providers = createDatabaseProviders(options, entities);
          return {
            global: true,
            module: DatabaseModule,
            providers: providers,
            exports: providers,
          };
    }
}

// 使用动态模块
import { Module } from '@nestjs/common';
import { DatabaseModule } from './database/database.module';
import { User } from './users/entities/user.entity';

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

如下是一个简单的模块定义和引用

// 1 定义UsersModule 
import { Module } from '@nestjs/common';
import { UsersService } from './users.service';

@Module({
  providers: [UsersService],
  exports: [UsersService],
})
export class UsersModule {}

// 2 定义 AuthModule 
import { Module } from '@nestjs/common';
import { AuthService } from './auth.service';
import { UsersModule } from '../users/users.module';

@Module({
  imports: [UsersModule],
  providers: [AuthService],
  exports: [AuthService],
})
export class AuthModule {}

// 3 使用
import { Injectable } from '@nestjs/common';
import { UsersService } from '../users/users.service';

@Injectable()
export class AuthService {
  constructor(private usersService: UsersService) {}
  /*
    Implementation that makes use of this.usersService
  */
}

这种叫做静态模块绑定，以上代码发生的过程是，
1 实例化 UsersModule，传递的解析它的依赖模块和其他依赖、
2 实例化 AuthModule，使UsersModule的导出providers在 AuthModule 中可用
3 在 AuthService 注入一个 UsersService 的实例。

Dynamic Module 使用

比如，@nestjs/config 包ConfigModule 可以动态加载.env文件来加载环境变量

使用静态模块绑定，消费者模块不能影响来自宿主模块的providers配置，有时候我们需要宿主模块在不同的状态下有不同的行为。有点像是插件，在消费者使用之前要进行配置。

比如配置模块，使用配置模块来让配置细节外部化很有用，这样在不同的环境可以动态改变应用的设置。通过将配置参数的功能管理委托给配置模块，应用程序源代码保持独立于配置参数。

通过将配置参数的管理委托给配置模块，应用程序源代码保持独立于配置参数。
因为配置模块是通用的，需要由消费模块来定制，这就是动态模块的作用了。
可以让消费模块通过API控制消费模块的行为。

动态模块提供了一个API，用于将一个模块导入到另一个模块中的时候自定义该模块的属性和行为，而不是使用我们到目前为止看到的静态绑定。

指定module的imports属性的参数，不仅可以是module类名，也可以是返回module类的方法
Dynamic Module同样可以 import 别的 module。

// 一般的模块是这样的
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { ConfigModule } from './config/config.module';

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

// 我们推断，配置模块应该这样
// 一般动态模块，按照惯例都有应该叫forRoot()或Register()的静态方法,
// 方法应该接受一个配置对象，返回一个module,实际上是一个Dynamic Module，
// Dynamic Module是一个有module作为必须参数的module哈
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { ConfigModule } from './config/config.module';

@Module({
  imports: [ConfigModule.register({ folder: './config' })],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

// 一个配置模块是这么写的
import { DynamicModule, Module } from '@nestjs/common';
import { ConfigService } from './config.service';

@Module({})
export class ConfigModule {
  static register(): DynamicModule {
    return {
      module: ConfigModule,
      providers: [ConfigService],
      exports: [ConfigService],
    };
  }
}

// 然后我们假设这个动态模块的service是这样的
import { Injectable } from '@nestjs/common';
import * as dotenv from 'dotenv';
import * as fs from 'fs';
import { EnvConfig } from './interfaces';

@Injectable()
export class ConfigService {
  private readonly envConfig: EnvConfig;

  constructor() {
    const options = { folder: './config' };

    const filePath = `${process.env.NODE_ENV || 'development'}.env`;
    const envFile = path.resolve(__dirname, '../../', options.folder, filePath);
    this.envConfig = dotenv.parse(fs.readFileSync(envFile));
  }

  get(key: string): string {
    return this.envConfig[key];
  }
}

// ConfigModule提供ConfigService。
// ConfigService又依赖于仅在运行时提供的Options对象。
// 因此在运行时，我们需要首先将Options对象绑定到Nest IOC容器，
// 然后让Nest将其注入到ConfigService中

import { DynamicModule, Module } from '@nestjs/common';
import { ConfigService } from './config.service';

@Module({})
export class ConfigModule {
  static register(options): DynamicModule {
    return {
      module: ConfigModule,
      providers: [
        {
          provide: 'CONFIG_OPTIONS',
          useValue: options,
        },
        ConfigService,
      ],
      exports: [ConfigService],
    };
  }
}

// 我们把传入的options作为一个provider，然后在service中依赖注入
import * as dotenv from 'dotenv';
import * as fs from 'fs';
import { Injectable, Inject } from '@nestjs/common';
import { EnvConfig } from './interfaces';

@Injectable()
export class ConfigService {
  private readonly envConfig: EnvConfig;

  constructor(@Inject('CONFIG_OPTIONS') private options) {
    const filePath = `${process.env.NODE_ENV || 'development'}.env`;
    const envFile = path.resolve(__dirname, '../../', options.folder, filePath);
    this.envConfig = dotenv.parse(fs.readFileSync(envFile));
  }

  get(key: string): string {
    return this.envConfig[key];
  }
}

Nest 中间件

中间件是在路由处理方法之前调用的方法，中间件函数可以访问请求和响应对象，以及使用Next方法。

Nest的中间件默认等价于Express的中间件，中间件有以下功能，执行任意代码、修改请求和响应对象、结束响应、调用Next方法(必须调用，否则请求无法处理)。

// 文件 logger.middleware.ts 声明中间件的3个方式
@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  // eslint-disable-next-line @typescript-eslint/ban-types
  use(req: Request, res: Response, next: Function) {
    console.log('Request...');
    next();
  }
}

@Injectable()
export class LoggerMiddleware2 {
  use(req, res, next) {
    console.log(req._parsedUrl.pathname)
    console.log(req.query)
    console.log('n');
    next();
  }
}

export function LoggerMiddleware3(req: Request, res: Response, next: Function) {
  console.log(`logger3...`);
  next();
};

// 使用 
export class AppModule {
  // module的configure来使用中间件,此方法可以async
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware2) //  apply可以使用多个中间件 .apply(LoggerMiddleware1, logger2)
      .exclude(
          { path: 'cats', method: RequestMethod.GET },
          { path: 'cats', method: RequestMethod.POST },
          'cats/(.*)',
       )
      .forRoutes({ path: 'ca*', method: RequestMethod.ALL });
    // 可使用控制器      forRoutes(CatsController)
    // 简单使用         forRoutes('cats')
    // 正则匹配路由      forRoutes('cat*') forRoutes('cat*')
    // 指定http请求方法  forRoutes({ path: 'cats', method: RequestMethod.GET });
    // exclude排除哪些路由
  }
}

// 全局过滤器
app.use(logger)

Exception filters 异常过滤器

Nest内置了一个异常层处理所有未处理的异常，一个全局的异常过滤器来处理HttpException类型(及其子类)的异常，如果不是就会返回如下json数据

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

主动抛出一个 HttpException

import {HttpException， HttpStatus} from '@nestjs/common';
@Get('/admin')
async gundan(): Promise<Cat[]> {
    throw new HttpException('Forbidden', HttpStatus.FORBIDDEN);
}

自定义异常

import {HttpException， HttpStatus} from '@nestjs/common';
export class ForbiddenException extends HttpException {
  constructor() {
    super('Forbidden', HttpStatus.FORBIDDEN);
  }
}

内置很多继承于HttpException的类

NotFoundException、
ForbiddenException、
UnauthorizedException

异常过滤器

完全控制抛出异常之后返回的信息

// 创建一个 HttpExceptionFilter

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();
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();
    const status = exception.getStatus();

    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
    });
  }
}

// 在controller中使用
import {UseFilters} from '@nestjs/common';
@Controller('cats')
@UseFilters(HttpExceptionFilter)
export class CatsController {
  ...
}

// 全局使用
 app.useGlobalFilters(new HttpExceptionFilter());

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

@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const request = ctx.getRequest();

    const status =
      exception instanceof HttpException
        ? exception.getStatus()
        : HttpStatus.INTERNAL_SERVER_ERROR;

    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
    });
  }
}

// 定义方法
import { Catch, ArgumentsHost } from '@nestjs/common';
import { BaseExceptionFilter } from '@nestjs/core';

@Catch()
export class AllExceptionsFilter extends BaseExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    super.catch(exception, host);
  }
}

// 使用
async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  const { httpAdapter } = app.get(HttpAdapterHost);
  app.useGlobalFilters(new AllExceptionsFilter(httpAdapter));

  await app.listen(3000);
}
bootstrap();

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

@Controller('demo2')
export class Demo2Controller {
  @Get('/num/:id')
  get1(@Param('id', ParseIntPipe) id: number): number {
    return id;
  }
}

// 如果访问了/demo2/num/1 没问题，如果是/demo2/num/a 就是抛异常，默认是下边的
{
  "statusCode": 400,
  "message": "Validation failed (numeric string is expected)",
  "error": "Bad Request"
}

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

@Injectable()
export class ValidationPipe implements PipeTransform {
  transform(value: any, metadata: ArgumentMetadata) {
    return typeof value;
  }
}

// ***** 开始是这样的 ****** 
// controller 
@Post()
async create(@Body() createCatDto: CreateCatDto) {
  this.catsService.create(createCatDto);
}

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

// ******** 使用 Object schema validation 验证
// 需要下边两个库
$ npm install --save joi
$ npm install --save-dev @types/joi

// 创建一个验证的schema 规则 cat.schema.ts 
import Joi = require('joi');
export default Joi.object({
  name: Joi.string()
    .alphanum()
    .min(3)
    .max(10)
    .required(),
  age: Joi.number()
    .integer()
    .min(1900)
    .max(2020)
    .required(),
  breed: Joi.string().required()
});

// 新建自定义的管道 JoiValidationPipe.ts 
import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';
import { ObjectSchema } from '@hapi/joi';

@Injectable()
export class JoiValidationPipe implements PipeTransform {
  constructor(private schema: ObjectSchema) {}

  transform(value: any, metadata: ArgumentMetadata) {
    const { error } = this.schema.validate(value);
    if (error) {
      throw new BadRequestException('Validation failed');
    }
    return value;
  }
}

// 在controller中直接使用 
import { JoiValidationPipe } from '../pipes/JoiValidationPipe';
import CatSchema from '../schema/cat.schema';

@Controller('cats')
export class CatsController {
  constructor(private catsService: CatsService) {}
  @Post('/add')
  @UsePipes(new JoiValidationPipe(CatSchema))
  async create(@Body() createCatDto: CreateCatDto) {
    console.log(createCatDto);
    this.catsService.create(createCatDto);
  }
}

// 安装需要的包
npm i class-validator class-transformer --save 

//修改DTO，增加需要校验的注解 create-cat.dto.ts
import { IsString, IsInt } from 'class-validator';
export class CreateCatDto {
  @IsString()
  name: string;

  @IsInt()
  age: number;

  @IsString()
  breed: string;
}

// 新建一个检验pipe
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);
  }
}

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 this.validateRequest(request);
  }

  validateRequest(request){
    return true;
  }
}

// 使用全局守卫
app.useGlobalGuards(new RolesGuard());

// LoggingInterceptor.ts 
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } 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() // returns an RxJS Observable 
      .pipe(
        tap(() => console.log(`After... ${Date.now() - now}ms`)),
      );
  }
}

// controller使用
@UseInterceptors(new LoggingInterceptor())
export class CatsController {}

// 全局使用
const app = await NestFactory.create(AppModule);
app.useGlobalInterceptors(new LoggingInterceptor());