Implement IntoResponse for Option mapping it to 404

[imbolc]

I've just asked the question on Discord, and found that the idea was discussed and rejected as being confusing. But I couldn't find the discussion, so I've opened this one, in case someone wonders about it.

Suggested implementation:

impl<R> IntoResponse for Option<R>
where
    R: IntoResponse,
{
    fn into_response(self) -> Response {
        match self {
            Some(r) => r.into_response(),
            None => StatusCode::NOT_FOUND.into_response(),
        }
    }
}

[jplatte]

… the problem being that an empty response body is not the obvious right solution, different services might want different kinds of 404 bodies when a resource isn't found:

• An API server would likely want to return a machine-readable body
• A server that's accessed from browsers directly would want to return an HTML page, likely with a site-specific design and stuff like that

[imbolc]

It's a common issue with Axum, e.g. Path extractor rejects with a plain/text debug string. And it seems to work ok if there's ways to customize this behaviour. I've just tried and found it easy to redirect empty 404 responses to the router fallback:

use axum::{
    body::HttpBody,
    handler::Handler,
    http::{Request, StatusCode},
    middleware::{self, Next},
    response::{IntoResponse, Response},
    routing::get,
    Router,
};

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/", get(handler))
        .route_layer(middleware::from_fn(fallback_on_none))
        .fallback(fallback.into_service());

    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap()
}

async fn handler() -> Option<String> {
    None
}

async fn fallback() -> &'static str {
    "fallback"
}

async fn fallback_on_none<B>(req: Request<B>, next: Next<B>) -> Response {
    let resp = next.run(req).await;
    if resp.status() == StatusCode::NOT_FOUND && resp.body().size_hint().upper() == Some(0) {
        // 404 with an empty body
        fallback().await.into_response()
    } else {
        resp
    }
}