return Nest 控制器中的 404 装饰器

Question

我正在使用 NestJS 开发后端（顺便说一句，这太棒了）。我有一个类似于下面这个例子的'standard get a single instance of an entity situation'。

@Controller('user')
export class UserController {
    constructor(private readonly userService: UserService) {}
    ..
    ..
    ..
    @Get(':id')
    async findOneById(@Param() params): Promise<User> {
        return userService.findOneById(params.id);
    }

这非常简单并且有效 - 但是，如果用户不存在，服务 return 未定义并且控制器 return 一个 200 状态代码和一个空响应。

为了使控制器 return 成为 404，我想出了以下方法：

    @Get(':id')
    async findOneById(@Res() res, @Param() params): Promise<User> {
        const user: User = await this.userService.findOneById(params.id);
        if (user === undefined) {
            res.status(HttpStatus.NOT_FOUND).send();
        }
        else {
            res.status(HttpStatus.OK).json(user).send();
        }
    }
    ..
    ..

这行得通，但更代码化（是的，它可以重构）。

这真的可以使用装饰器来处理这种情况：

    @Get(':id')
    @OnUndefined(404)
    async findOneById(@Param() params): Promise<User> {
        return userService.findOneById(params.id);
    }

有谁知道装饰器可以做到这一点，或者有比上面那个更好的解决方案吗？

Answer 1

最短的方法是

@Get(':id')
async findOneById(@Param() params): Promise<User> {
    const user: User = await this.userService.findOneById(params.id);
    if (user === undefined) {
        throw new BadRequestException('Invalid user');
    }
    return user;
}

装饰器在这里没有意义，因为它会有相同的代码。

注意： BadRequestException 是从 @nestjs/common 导入的；

编辑

一段时间后，我想到了另一个解决方案，它是 DTO 中的装饰器：

import { registerDecorator, ValidationArguments, ValidationOptions, ValidatorConstraint } from 'class-validator';
import { createQueryBuilder } from 'typeorm';

@ValidatorConstraint({ async: true })
export class IsValidIdConstraint {

    validate(id: number, args: ValidationArguments) {
        const tableName = args.constraints[0];
        return createQueryBuilder(tableName)
            .where({ id })
            .getOne()
            .then(record => {
                return record ? true : false;
            });
    }
}

export function IsValidId(tableName: string, validationOptions?: ValidationOptions) {
    return (object, propertyName: string) => {
        registerDecorator({
            target: object.constructor,
            propertyName,
            options: validationOptions,
            constraints: [tableName],
            validator: IsValidIdConstraint,
        });
    };
}

然后在你的 DTO 中：

export class GetUserParams {
    @IsValidId('user', { message: 'Invalid User' })
    id: number;
}

希望对大家有所帮助。

Answer 2

没有用于此的内置装饰器，但您可以创建一个 interceptor 检查 return 值并在 undefined 上抛出一个 NotFoundException：

拦截器

@Injectable()
export class NotFoundInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle()
      .pipe(tap(data => {
        if (data === undefined) throw new NotFoundException();
      }));
  }
}

然后您可以通过将 Interceptor 添加到单个端点来使用它：

@Get(':id')
@UseInterceptors(NotFoundInterceptor)
findUserById(@Param() params): Promise<User> {
    return this.userService.findOneById(params.id);
}

或您 Controller 的所有端点：

@Controller('user')
@UseInterceptors(NotFoundInterceptor)
export class UserController {

动态拦截器

您还可以将值传递给拦截器以自定义每个端点的行为。

在构造函数中传递参数：

@Injectable()
export class NotFoundInterceptor implements NestInterceptor {
  constructor(private errorMessage: string) {}
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  intercept(context: ExecutionContext, stream$: Observable<any>): Observable<any> {
    return stream$
      .pipe(tap(data => {
        if (data === undefined) throw new NotFoundException(this.errorMessage);
                                                            ^^^^^^^^^^^^^^^^^
      }));
  }
}

然后用 new:

创建拦截器

@Get(':id')
@UseInterceptors(new NotFoundInterceptor('No user found for given userId'))
findUserById(@Param() params): Promise<User> {
    return this.userService.findOneById(params.id);
}

Answer 3

如果是简单的情况，我通常会用这种懒惰的方式来做，不会添加额外的绒毛：

import {NotFoundException} from '@nestjs/common'
...
@Get(':id')
async findOneById(@Param() params): Promise<User> {
    const user: User = await this.userService.findOneById(params.id)
    if (!user) throw new NotFoundException('User Not Found')
    return user
}

Answer 4

最新 Nestjs 版本的更新版本：

如前所述on the Nestjs docs:

The interceptors API has also been simplified. In addition, the change was required due to this issue which was reported by the community.

更新代码：

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

@Injectable()
export class NotFoundInterceptor implements NestInterceptor {
  constructor(private errorMessage: string) { }

  intercept(context: ExecutionContext, stream$: CallHandler): Observable<any> {
    return stream$
      .handle()
      .pipe(tap(data => {
        if (data === undefined) { throw new NotFoundException(this.errorMessage); }
      }));
  }
}

Answer 5

您可以使用以下方式发送您想要的响应以及 header 中的正确状态代码。

在控制器中的路由处理程序中 class:

this.whateverService.getYourEntity(
  params.id
)
.then(result => {
  return res.status(HttpStatus.OK).json(result)
})
.catch(err => {
  return res.status(HttpStatus.NOT_FOUND).json(err)
})

为此，您必须拒绝服务方法中的 Promise，如下所示：

const entity = await this.otherService
  .getEntityById(id)

if (!entity) {
  return Promise.reject({
    statusCode: 404,
    message: 'Entity not found'
  })
} 

return Promise.resolve(entity)

这里我只是用了服务里面的另一个服务class。你当然可以直接获取你的数据库或者做任何需要的事情来获取你的实体。

Answer 6

export const OnUndefined = (
  Error: new () => HttpException = NotFoundException,
) => {
  return (
    _target: unknown,
    _propKey: string,
    descriptor: PropertyDescriptor,
  ) => {
    const original = descriptor.value;
    const mayThrow = (r: unknown) => {
      if (undefined === r) throw new Error();
      return r;
    };
    descriptor.value = function (...args: unknown[]) {
      const r = Reflect.apply(original, this, args);
      if ('function' === typeof r?.then) return r.then(mayThrow);
      return mayThrow(r);
    };
  };
};

然后这样使用

@Get(':id')
@OnUndefined()
async findOneById(@Param() params): Promise<User> {
    return userService.findOneById(params.id);
}

Answer 7

OnUndefined 函数创建装饰器，必须如上所述使用。

如果服务 return 未定义的响应（搜索的 ID 不存在）控制器 return 404（NotFoundException）或任何其他异常作为参数传递给 @OnUndefined 装饰器

Answer 8

我想最简单的解决方案是这样编辑您的 UserService：

findOneById(id): Promise<User> {
  return new Promise<User>((resolve, reject) => {
    const user: User = await this.userService.findOneById(id);
    user ? 
      resolve(user) :
      reject(new NotFoundException())        
    }
}

您的控制器无需任何更改。

此致

return Nest 控制器中的 404 装饰器

Decorator to return a 404 in a Nest controller

javascript

node.js

nestjs

拦截器

动态拦截器