如何在Nest.js中通过ID验证实体是否存在？

在Nest.js里，ValidationPipe能处理常规的入参格式校验，但要验证ID对应的实体是否存在，需要结合自定义逻辑实现，下面是几种实用方案：

方案一：自定义类验证器（结合class-validator） #

通过自定义class-validator的验证器和装饰器，把实体存在性校验整合到DTO的规则中。

1. 实现自定义验证器 #

注入数据仓库（Repository）或服务，查询实体是否存在：

import { ValidatorConstraint, ValidatorConstraintInterface, ValidationArguments } from 'class-validator';
import { Injectable } from '@nestjs/common';
import { UserRepository } from './user.repository';

@ValidatorConstraint({ name: 'entityExists', async: true })
@Injectable()
export class EntityExistsValidator implements ValidatorConstraintInterface {
  constructor(private readonly userRepository: UserRepository) {}

  async validate(id: number, args: ValidationArguments) {
    const entity = await this.userRepository.findOneBy({ id });
    return !!entity; // 存在返回true，不存在返回false触发校验失败
  }

  defaultMessage(args: ValidationArguments) {
    return `ID为${args.value}的${args.property}对应的实体不存在`;
  }
}

2. 创建自定义装饰器 #

注册装饰器关联上述验证器：

import { registerDecorator, ValidationOptions } from 'class-validator';
import { EntityExistsValidator } from './entity-exists.validator';

export function EntityExists(validationOptions?: ValidationOptions) {
  return function (target: any, propertyName: string) {
    registerDecorator({
      target: target.constructor,
      propertyName: propertyName,
      options: validationOptions,
      validator: EntityExistsValidator,
    });
  };
}

3. 在DTO中使用 #

把装饰器加到需要校验的ID字段上：

import { IsNumber } from 'class-validator';
import { EntityExists } from './entity-exists.decorator';

export class GetUserDto {
  @IsNumber()
  @EntityExists({ message: '指定ID的用户不存在' })
  id: number;
}

最后记得把EntityExistsValidator添加到模块的providers数组中，确保依赖注入生效。

方案二：自定义参数管道 #

创建专门的管道处理ID校验，直接返回实体对象，减少控制器重复查询。

实现管道 #

import { PipeTransform, Injectable, NotFoundException } from '@nestjs/common';
import { UserRepository } from './user.repository';

@Injectable()
export class UserExistsPipe implements PipeTransform<number> {
  constructor(private readonly userRepository: UserRepository) {}

  async transform(id: number) {
    const user = await this.userRepository.findOneBy({ id });
    if (!user) {
      throw new NotFoundException(`ID为${id}的用户不存在`);
    }
    return user; // 直接返回实体，控制器可直接使用
  }
}

在控制器中使用 #

import { Controller, Get, Param } from '@nestjs/common';
import { UserExistsPipe } from './user-exists.pipe';
import { User } from './user.entity';

@Controller('users')
export class UsersController {
  @Get(':id')
  async getUser(@Param('id', UserExistsPipe) user: User) {
    return user;
  }
}

方案三：路由守卫 #

如果多个路由需要统一验证实体存在性，可使用守卫在路由层面拦截校验。

实现守卫 #

import { CanActivate, ExecutionContext, Injectable, NotFoundException } from '@nestjs/common';
import { UserRepository } from './user.repository';

@Injectable()
export class UserExistsGuard implements CanActivate {
  constructor(private readonly userRepository: UserRepository) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    const request = context.switchToHttp().getRequest();
    const userId = parseInt(request.params.id);
    
    const user = await this.userRepository.findOneBy({ id: userId });
    if (!user) {
      throw new NotFoundException('指定用户不存在');
    }
    
    request.user = user; // 将实体挂载到request对象，后续控制器可直接获取
    return true;
  }
}

在路由中使用 #

import { Controller, Get, UseGuards, Request } from '@nestjs/common';
import { UserExistsGuard } from './user-exists.guard';

@Controller('users')
export class UsersController {
  @Get(':id')
  @UseGuards(UserExistsGuard)
  async getUser(@Request() req) {
    return req.user;
  }
}

方案选择建议 #

• 自定义类验证器：适合和其他DTO校验规则（如格式、范围）结合，统一在DTO层面管理校验逻辑。
• 自定义管道：适合单个参数的校验，且希望直接返回实体，简化控制器代码。
• 路由守卫：适合多路由共享相同的实体存在性校验逻辑，实现统一拦截。

内容的提问来源于stack exchange，提问作者Artyom Ionash