How to catch "Invalid URL param." error?

[shengsheng]

use axum::{Router, extract::Path, handler::get, response::Html};
use std::net::SocketAddr;

#[tokio::main]
async fn main() {
    // build our application with a route
    let app = Router::new().route("/:type/:id", get(handler));

    // run it
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

async fn handler(Path((ty, id)): Path<(String, u8)>) -> Html<String> {
    let content = format!("<p>{}</p><p>{}</p>", ty, id);
    Html(content)
}

$ curl http://127.0.0.1:3000/hello/world
Invalid URL param. can not parse `"world"` to a `u8`% 

How to catch the "Invalid URL param...." error? I want print a custom response to user.

[davidpdrsn]

Use Result<Path<...>, PathParamsRejection> as the extractor which allows you to handle errors.

You can find an example here https://docs.rs/axum/0.2.4/axum/extract/index.html#optional-extractors.

[kyle-mccarthy]

tangentially related - is there an easy way to get the underlying serde error for things like JsonRejection? I'd like to return the error as JSON rather than text.

if you'd like I can open another discussion post.

[davidpdrsn]

All axum's rejections implement std::error::Error so you can get the source and downcast it:

use std::error::Error as StdError;

async fn handler(payload: Result<Json<Value>, JsonRejection>) -> impl IntoResponse {
    let Json(input) = match payload {
        Ok(input) => input,
        Err(err) => {
            if let Some(serde_err) = find_in_sources::<serde_json::Error>(&err) {
                return Err((StatusCode::BAD_REQUEST, serde_err.to_string()));
            } else {
                return Err((StatusCode::BAD_REQUEST, "Unknown error".to_string()));
            }
        }
    };

    Ok(())
}

fn find_in_sources<T>(err: &dyn StdError) -> Option<&T>
where
    T: StdError + 'static,
{
    let source = if let Some(source) = err.source() {
        source
    } else {
        return None;
    };

    if let Some(inner) = source.downcast_ref::<T>() {
        Some(inner)
    } else {
        find_in_sources(source)
    }
}

If you need this in multiple places I would recommend creating your own json extractor that wraps axum::Json and returns a different rejection.