Cómo personalizar la respuesta de error para una ruta específica en FastAPI

En FastAPI, generar un RequestValidationError le permite enviar una respuesta de error personalizada. Esto es útil para puntos finales que requieren que se cumplan condiciones específicas, como un encabezado requerido.

Opción 1: anular el controlador de excepciones predeterminado

Esta opción le permite anular el controlador de excepciones predeterminado para RequestValidationError, que le permite personalizar la respuesta de error.

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}),
    )

Opción 2: Usar una subaplicación

La creación de una subaplicación le permite crear una instancia de API separada con su propio controlador de excepciones. Esto le permite personalizar el manejo de errores específicamente para la subaplicación.

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)

Opción 3: usar una clase APIRoute personalizada

Este método le permite cambiar el comportamiento de una ruta específica mediante el uso de una clase 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)

¿Qué opción debería usar?

La opción 1 es sencilla de implementar cuando solo necesita personalizar la respuesta de error para rutas específicas. La opción 2 es adecuada cuando desea tener más control sobre la subárea de su API, como aplicar diferentes políticas de seguridad o manejo de excepciones. La opción 3 te brinda más control sobre rutas individuales y es útil para manejar casos específicos dentro de una ruta.