Any way to render errors as late as possible?

[RAnders00]

Hi!

I've been looking for a way to "render" errors in a custom way, say for example, I have an API endpoint that's only accessible via GET:

let app = Router::new().route("/hello-world", get(|| "Hello, World!"));

Calling POST /hello-world generates a 405 Method Not Allowed response with empty body by default. I instead would like all errors stemming from axum to be returned in a JSON format like this:

{
    "status": 405,
    "status_message": "Method Not Allowed",
    "error": "Method Not Allowed",
    "error_code": "method_not_allowed"
}

I suppose I could do this via .layer() on the router, by inspecting the response generated by the wrapped rest of the app, and replacing the empty body with a JSON body, purely based on the response code I'm seeing on the Response instance.

Not only does this feel like a hack, it would also have to do horrible string/content-based heuristics to determine if the error response was generated by axum or one of my own endpoints. For example, let's say an authentication middleware has encountered an expired authentication token, and has returned a custom error that I implemented IntoResponse on:

{
    "status": 403,
    "status_message": "Forbidden",
    "error": "Given authentican token has expired",
    "error_code": "authentication_token_expired"
}

I've played with the warp framework before, where errors are not immediately converted to responses, instead they are bubbled up and can later be cast to the original types again to make use of the data stored on the actual error objects. In axum, it seems like the design makes it so errors are immediately "stringified" into Responses, so-to-say, so that means later down the line they are not inspectable/downcastable anymore, correct?

If not, is something like this possible in axum? (A generic error handler that generates error responses based upon the Error data returned by the handlers further inside the pipeline?

[davidpdrsn]

For 404s axum has Router::falback but we don't have something like that for 405s. That is because there isn't one single method router. When you do get(foo) in one place and post(bar) somewhere, those two don't know about each other and thus cannot coordinate their fallbacks.

So to handle this in one place you have to write a middleware that checks the response status code. I don't think thats a hack especially because returning 405 from domain logic is very rare, so if you see one its probably safe to assume its from axum and thus valid to override the response body.

[RAnders00]

Hm, alright, now that I think about it, I can't really think of any other errors that a barebones app like shown above would generate (as far as I can see, it only generates the stock 404 and 405 responses, correct?) - I was just under the impression that there were a bunch more rare edgecases that would also result in error responses, and that those esoteric cases were hidden somewhere deep in the library.

If it's just 405 I have to worry about, I might give axum another shot.

[paolobarbolini]

What about the errors generated by the various built-in extractors?

[davidpdrsn]

Extractor rejections can be customize like this https://docs.rs/axum/latest/axum/extract/index.html#customizing-extractor-responses

[RAnders00]

Thank you for the swift answer!

[jamesreprise]

For anyone else trying to do exactly what @RAnders00 was aiming for.

Using https://docs.rs/axum/latest/axum/middleware/fn.from_fn.html:

#[derive(Serialize, Debug)]
pub struct Error {
    pub response: String,
    pub text: String,
}

impl Error {
    pub fn new(text: &str) -> Self {
        Self {
            response: "ERROR".to_string(),
            text: text.to_string(),
        }
    }
}

pub async fn method_not_allowed<B>(req: Request<B>, next: Next<B>) -> impl IntoResponse {
    let resp = next.run(req).await;
    let status = resp.status();
    match status {
        StatusCode::METHOD_NOT_ALLOWED => Err((
            StatusCode::METHOD_NOT_ALLOWED,
            Json(Error::new("Method not allowed")),
        )
            .into_response()),
        _ => Ok(resp),
    }
}

...

let app = Router::new()
        .route("/", get(frontpage))
        .layer(middleware::from_fn(method_not_allowed))

Generates a response with a 405 status:

{
  "response": "ERROR",
  "text": "Method not allowed"
}

No guarantees about performance!

[LyonRust]

It‘s right