Custom exception handling not updating OpenAPI status code

[conradogarciaberrotaran]

Hi, I'm trying to override the 422 status code to a 400 across every endpoint on my app, but it keeps showing as 422 on the openapi docs.

Description

This is how i override the 422.

from fastapi import FastAPI, status
from fastapi.encoders import jsonable_encoder
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse

app = FastAPI()

app.include_router(my_router, prefix="/log")


@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request, exc):
    """
    Overrides FastAPI default status code for validation errors
    from 422 to 400
    """
    return JSONResponse(
        status_code=status.HTTP_400_BAD_REQUEST,
        content=jsonable_encoder({"detail": exc.errors(), "body": exc.body}),
    )

It returns 400 successfully but, the OpenAPI shows:

What's the correct way to override the 422 and update the OpenAPI docs schema?
Thank you

Environment

• OS: Linux
• FastAPI Version: 0.61.1

[Kludex]

It's been some time since: #643 and #1376.
And actually no solution was provided on both issues (at least I didn't see it), so I think it's time.

Following the idea on: https://fastapi.tiangolo.com/advanced/extending-openapi/?h=+swagger#override-the-method

from fastapi import FastAPI, status
from fastapi.encoders import jsonable_encoder
from fastapi.exceptions import RequestValidationError
from fastapi.openapi.utils import get_openapi
from fastapi.responses import JSONResponse
from pydantic import BaseModel

app = FastAPI()


class Potato(BaseModel):
    name: str
    color: str


@app.post("/items/")
def post_potato(potato: Potato):
    return potato


@app.get("/schemas")
def get_schemas():
    return app.openapi_schema


@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request, exc):
    """Overrides FastAPI default status code for validation errors from 422 to 400."""
    return JSONResponse(
        status_code=status.HTTP_400_BAD_REQUEST,
        content=jsonable_encoder({"detail": exc.errors(), "body": exc.body}),
    )


def custom_openapi():
    if app.openapi_schema:
        return app.openapi_schema
    openapi_schema = get_openapi(
        title="Custom title",
        version="2.5.0",
        description="This is a very custom OpenAPI schema",
        routes=app.routes,
    )
    for path in openapi_schema["paths"]:
        for method in openapi_schema["paths"][path]:
            if openapi_schema["paths"][path][method]["responses"].get("422"):
                openapi_schema["paths"][path][method]["responses"][
                    "400"
                ] = openapi_schema["paths"][path][method]["responses"]["422"]
                openapi_schema["paths"][path][method]["responses"].pop("422")
    app.openapi_schema = openapi_schema
    return app.openapi_schema


app.openapi = custom_openapi

Images from swagger:
Missing name!

Response!

Documentation!

Feel free to improve the given solution 😃
Please close the issue if that satisfies you 👍

[conradogarciaberrotaran]

Thanks for this solution, hopefully we get something a little less hacky soon.

[phillipuniverse]

@Kludex thanks for the great start! I wanted to have both a custom error code (400) as well as a custom error schema that I already defined as a Pydantic model. Building off of what you did, here's my workaround:

class ErrorSource(BaseModel):
    """The source of the error in the request, either in the request body or a query parameter"""

    parameter: Optional[str] = Field(
        None, description="Which query parameter caused the issue, such as an invalid page size"
    )
    pointer: Optional[str] = Field(
        None,
        description="Which part of the request body caused the error, expressed as a JSON Pointer([RFC6901](https://tools.ietf.org/html/rfc6901)) (examples - '/' for the primary data object or '/attributes/title' to indicate a problem with the 'title' field)",
    )


class Error(BaseModel):
    """Information about an error that occurred"""

    title: str = Field(
        description="Human readable description of what went wrong, can be localized (example: 'Validation Error')"
    )
    status: str = Field(
        description="HTTP Status code describing the problem (example: '503' or '400')"
    )
    code: Optional[str] = Field(
        None,
        description="Similar to 'title' in describing the general error but in machine-readable form (example: 'validation_error')",
    )
    detail: Optional[str] = Field(
        None,
        description="Human readable description specific to this occurrence, can be localized (example: 'Start time cannot be after end time')",
    )
    source: Optional[ErrorSource] = Field(
        None, description="Which part of the request the error occurred"
    )
    meta: Optional[Any] = Field(
        None, description="Contains non-standard meta-information about the error"
    )


class ErrorResponse(BaseModel):
    errors: List[Error] = Field(..., description="What went wrong in the request")

def custom_openapi():


    if app.openapi_schema:
        return app.openapi_schema
    openapi_schema = get_openapi(
        title="Custom title",
        version="2.5.0",
        description="This is a very custom OpenAPI schema",
        routes=app.routes,
    )

    # not quite the ideal scenario but this is the best we can do to override the default
    # error schema. See
    from fastapi.openapi.constants import REF_PREFIX
    import pydantic.schema
    
    paths = openapi_schema["paths"]
    for path in paths:
        for method in paths[path]:
            if paths[path][method]["responses"].get("422"):
                paths[path][method]["responses"]["400"] = {
                    "description": "Validation Error",
                    "content": {
                        "application/json": {"schema": {"$ref": f"{REF_PREFIX}ErrorResponse"}}
                    },
                }
                paths[path][method]["responses"].pop("422")

    error_response_defs = pydantic.schema.schema(
        (ErrorResponse,), ref_prefix=REF_PREFIX, ref_template=f"{REF_PREFIX}{{model}}"
    )
    openapi_schemas = openapi_schema["components"]["schemas"]
    openapi_schemas.update(error_response_defs["definitions"])
    openapi_schemas.pop("ValidationError")
    openapi_schemas.pop("HTTPValidationError")

    app.openapi_schema = openapi_schema

Which produces: