Como personalizar a resposta de erro para uma rota específica no FastAPI

No FastAPI, gerar um RequestValidationError permite que você envie uma resposta de erro personalizada. Isso é útil para endpoints que exigem que condições específicas sejam atendidas, como um cabeçalho obrigatório.

Opção 1: substituir o manipulador de exceção padrão

Esta opção permite substituir o manipulador de exceção padrão para RequestValidationError, permitindo que você personalize a resposta de erro.

from fastapi import FastAPI, Request, Header, status
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse

app = FastAPI()
routes_with_custom_exception = ['/']

@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
    if request.url.path in routes_with_custom_exception:
        return JSONResponse(content={'401': 'Unauthorized'}, status_code=401)
    
    return JSONResponse(
        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
        content=jsonable_encoder({'detail': exc.errors(), 'body': exc.body}),
    )

Opção 2: usar um subaplicativo

A criação de um subaplicativo permite que você crie uma instância de API separada com seu próprio manipulador de exceções. Isso permite que você personalize o tratamento de erros especificamente para o subaplicativo.

from fastapi import FastAPI
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse

app = FastAPI()
subapi = FastAPI()

@subapi.exception_handler(RequestValidationError)
async def validation_exception_handler(exc: RequestValidationError):
    return JSONResponse(content={'401': 'Unauthorized'}, status_code=401)
    
@subapi.get('/')
async def subapi_route(some_custom_header: str = Header(...)):
    return {'some-custom-header': some_custom_header}

app.mount('/sub', subapi)

Opção 3: Use uma classe APIRoute personalizada

Este método permite alterar o comportamento de uma rota específica usando uma classe APIRoute personalizada.

from fastapi import FastAPI, APIRouter, Response, Request, Header, HTTPException
from fastapi.exceptions import RequestValidationError

class ValidationErrorHandlingRoute(APIRoute):
    def get_route_handler(self) -> Callable:
        original_route_handler = super().get_route_handler()

        async def custom_route_handler(request: Request) -> Response:
            try:
                return await original_route_handler(request)
            except RequestValidationError as e:
                raise HTTPException(status_code=401, detail='401 Unauthorized')

        return custom_route_handler

app = FastAPI()
router = APIRouter(route_class=ValidationErrorHandlingRoute)

@router.get('/custom')
async def custom_route(some_custom_header: str = Header(...)):
    return {'some-custom-header': some_custom_header}

app.include_router(router)

Qual opção você deve usar?

A opção 1 é simples de implementar quando você só precisa personalizar a resposta de erro para rotas específicas. A opção 2 é adequada quando você deseja mais controle sobre a subárea da sua API, como aplicar diferentes políticas de segurança ou tratamento de exceções. A opção 3 oferece mais controle sobre rotas individuais e é útil para lidar com casos específicos dentro de uma rota.