使用Nest.js我想修整所有@body输入值

如何解决使用Nest.js我想修整所有@body输入值

我想修剪所有正文值（输入字段的开头/结尾处为空白）。我不想循环所有身体元素 为每个API请求清理字段。

我想知道是否可以覆盖@body（）批注，然后将代码放在其中，或者是否有输入格式化程序或管道来执行此操作。

此刻，我正在这样做：

createAccount(@Body() body: any) {
  this.account.create(body.map(s => s.trim()))
}

谢谢

解决方法

我为此专门制造了一个拦截器。我在全球范围内使用它，但是您可以在@UseInterceptors装饰器的任何地方使用它。这是也可以扩展为其他主体转换的基类：

import { CallHandler,ExecutionContext,NestInterceptor } from '@nestjs/common'
import { Observable } from 'rxjs'

export abstract class TransformRequest implements NestInterceptor {
  intercept(context: ExecutionContext,next: CallHandler): Observable<any> {
    this.cleanRequest(context.switchToHttp().getRequest())
    return next.handle()
  }

  cleanRequest(req: any): void {
    req.query = this.cleanObject(req.query)
    req.params = this.cleanObject(req.params)

    // If you use express adapter you will have
    // req.method
    // If you use fastify adapter you will have
    // req.raw.method

    if (req.raw.method !== 'GET') {
      req.body = this.cleanObject(req.body)
    }
  }

  cleanObject(obj: object | null | undefined) {
    if (!obj) {
      return obj
    }

    for (const key in obj) {
      // Prototype of obj is null
      // if (!obj.hasOwnProperty(key)) {
      //   continue
      // }

      const value = obj[key]

      // If the value is another nested object we need to recursively
      // clean it too. This will work for both array and object.
      if (value instanceof Object) {
        this.cleanObject(value)
      } else {
        // If the value is not an object then it's a scalar
        // so we just let it be transformed.
        obj[key] = this.transform(key,value)
      }
    }

    return obj
  }

  abstract transform(key: string | number,value: boolean | number | string | null | undefined): any
}

这是修饰字符串类：

import { Injectable } from '@nestjs/common'
import { TransformRequest } from './transform.request'

@Injectable()
export class TrimStrings extends TransformRequest {
  private except = ['password']

  transform(key: string | number,value: any) {
    if (this.isString(value) && this.isString(key) && !this.except.includes(key)) {
      return value.trim()
    }

    return value
  }

  isString(value: any): value is string {
    return typeof value === 'string' || value instanceof String
  }
}

您也可以在this存储库中找到它。

我实际上认为，如果可以的话，最好在前端侧修剪车身。

,

谢谢UrošAnđelić的建议。我创建了PipeTransform来解决这个问题：

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

@Injectable()
export class TrimPipe implements PipeTransform {
  private isObj(obj: any): boolean {
    return typeof obj === 'object' && obj !== null
  }

  private trim(values) {
    Object.keys(values).forEach(key => {
      if (key !== 'password') {
        if (this.isObj(values[key])) {
          values[key] = this.trim(values[key])
        } else {
          if (typeof values[key] === 'string') {
            values[key] = values[key].trim()
          }
        }
      }
    })
    return values
  }

  transform(values: any,metadata: ArgumentMetadata) {
    const { type } = metadata
    if (this.isObj(values) && type === 'body') {
      return this.trim(values)
    }

    throw new BadRequestException('Validation failed')
  }
}

这是使用方法

  @UsePipes(new TrimPipe())
  createAccount(@Body() body: any) {
    this.account.create(body)
  }

您还可以将其设置为全局管道：

app.useGlobalPipes(new TrimPipe());