Was ist der Fehlerbehandlungsansatz von nestjs (Geschäftslogikfehler vs. HTTP-Fehler)?

Bei der Verwendung von NestJS zum Erstellen von APIs habe ich mich gefragt, wie Fehler/Ausnahmen am besten behandelt werden. Ich habe zwei verschiedene Ansätze gefunden:

1. Haben Sie individuelle Dienste und Validierungsrohre throw new Error()haben den Controller catch sie und werfen Sie dann die entsprechende Art von HttpException(BadRequestException, ForbiddenException usw..)
2. Lassen Sie den Controller einfach die Dienst-/Validierungs-Pipe-Methode aufrufen, die für die Handhabung dieses Teils der Geschäftslogik verantwortlich ist, und lösen Sie die entsprechende aus HttpException.

Beide Ansätze haben Vor- und Nachteile:

1. Dies scheint der richtige Weg zu sein, der Dienst kann jedoch zurückkehren Error Aus verschiedenen Gründen, woher weiß ich vom Controller, welches die entsprechende Art von wäre HttpException zurückgeben?
2. Sehr flexibel, aber mit Http verwandte Dinge in den Diensten scheinen einfach falsch zu sein.

Ich habe mich gefragt, welches (falls vorhanden) die “nest js” -Methode ist?

Wie gehen Sie mit dieser Angelegenheit um?

Nehmen wir an, Ihre Geschäftslogik löst ein aus EntityNotFoundError und Sie möchten es a zuordnen NotFoundException.

Dafür können Sie eine erstellen Interceptor das verwandelt deine Fehler:

@Injectable()
export class NotFoundInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    // next.handle() is an Observable of the controller's result value
    return next.handle()
      .pipe(catchError(error => {
        if (error instanceof EntityNotFoundError) {
          throw new NotFoundException(error.message);
        } else {
          throw error;
        }
      }));
  }
}

Sie können es dann verwenden, indem Sie es hinzufügen @UseInterceptors(NotFoundInterceptor) an die Klasse oder Methoden Ihres Controllers; oder sogar als globaler Abfangjäger für alle Routen. Natürlich können Sie auch mehrere Fehler in einem Interceptor abbilden.

Probieren Sie es darin aus Codesandbox.

Nest Js bietet einen Ausnahmefilter, der Fehler behandelt, die nicht in der Anwendungsschicht behandelt werden. Daher habe ich ihn so geändert, dass er 500, einen internen Serverfehler, für Ausnahmen zurückgibt, die nicht Http sind. Dann protokollieren Sie die Ausnahme auf dem Server, dann können Sie wissen, was falsch ist, und es beheben.

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

@Catch()
export class HttpErrorFilter implements ExceptionFilter {
  private readonly logger : Logger 
  constructor(){
    this.logger = new Logger 
  }
  catch(exception: Error, host: ArgumentsHost): any {
    const ctx = host.switchToHttp();
    const request = ctx.getRequest();
    const response = ctx.getResponse();

    const statusCode = exception instanceof HttpException ? exception.getStatus() : HttpStatus.INTERNAL_SERVER_ERROR
    const message = exception instanceof HttpException ?  exception.message || exception.message?.error: 'Internal server error'

    const devErrorResponse: any = {
      statusCode,
      timestamp: new Date().toISOString(),
      path: request.url,
      method: request.method,
      errorName: exception?.name,
      message: exception?.message
    };

    const prodErrorResponse: any = {
      statusCode,
      message
    };
    this.logger.log( `request method: ${request.method} request url${request.url}`, JSON.stringify(devErrorResponse));
    response.status(statusCode).json( process.env.NODE_ENV === 'development'? devErrorResponse: prodErrorResponse);
  }
}

Möglicherweise möchten Sie Dienste nicht nur an die HTTP-Schnittstelle, sondern auch an GraphQL oder eine andere Schnittstelle binden. Daher ist es besser, Ausnahmen auf Geschäftslogikebene von Diensten in Ausnahmen auf HTTP-Ebene (BadRequestException, ForbiddenException) in Controllern umzuwandeln.

So könnte es im einfachsten Fall aussehen

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

@Injectable()
export class HttpHelperService {
  async transformExceptions(action: Promise<any>): Promise<any> {
    try {
      return await action;
    } catch (error) {
      if (error.name === 'QueryFailedError') {
        if (/^duplicate key value violates unique constraint/.test(error.message)) {
          throw new BadRequestException(error.detail);
        } else if (/violates foreign key constraint/.test(error.message)) {
          throw new BadRequestException(error.detail);
        } else {
          throw error;
        }
      } else {
        throw error;
      }
    }
  }
}

und dann

Sie können auch eine Factory oder einen Handler verwenden, um, wenn der Controller die Ausnahme (Fehler oder Domänenfehler) abfängt, diese einer anderen HttpException zuzuordnen.

@Controller('example')
export class ExampleController {

  @Post('make')
  async make(@Res() res, @Body() data: dataDTO): Promise<any> {
   
    try {
      //process result...
       return res.status(HttpStatus.OK).json(result);
    } catch (error) {
      throw AppErrorHandler.createHttpException(error); //<---here is the error type mapping
    };
  };

};