Wrapper for handler to handle from/to Json conversion

[kirillsalykin]

Summary

Please help,

I'd like to have a handler wrapper so it can handle Json conversion for me:

for instance I this sign_up handler:

#[derive(Deserialize)]
struct SignUpRequest {
    email: String,
    password: String,
}

#[derive(Serialize)]
struct SignUpResponse {
    user_id: String,
}

async fn sign_up(request: SignUpRequest) -> Result<SignUpResponse, String> {
    let user_id = "some_generated_user_id".to_string();
    Ok(SignUpResponse { user_id })
}

I am looking for a function wrap which I expect to be used this way:

        let router = Router::new()
            .route("/sign-up", post(wrap(sign_up)));

        let listener = tokio::net::TcpListener::bind(addr)
            .await
            .unwrap();
        let addr = listener.local_addr().unwrap();
        println!("listening on {}", addr);
        axum::serve(listener, router);

and it should perform JSON extraction, run the wrapped async function, and then produce the corresponding Response based on the result.

I'm having a hard time producing such code.
Any help would be much appreciated. Thanks!

axum version

0.7.7

[mladedav]

Is Json something that would solve your problem? Or do you really need your signature to be exactly as you wrote and you do need a wrapper around that?

[kirillsalykin]

Json definelty solves the problem, but I'd like to keep Json (both extraction from request and response serializion) in http level.

Would be nice if wrap fn can do this:

• extract `Json< SignUpRequest> and pass it further to wrapped fn
• based on result from the wrapped fn - if Ok - return (Ok, Json(result)), if Err - provide corresponding error code and details

I can imagine I am not the first who thought about this, but cant find much solutions.

Thanks

[kirillsalykin]

It also makes me think how to handle state extractors, like pgpool...
of course I can write handler which extracts things and passes it further and then handles the result, but this is basically boilerplate.
Would appreciate if someone can share ideas/solutions on this

[mladedav]

I'm not sure what do you mean by "http level".

What is it you're trying to achieve? Reuse the handler without it specifying the content type in its signature?

[kirillsalykin]

I'd like to have some generic function which implements some logic for domain entity SignUpRequest and it shouldnt be aware about JSON, I consider details like Json, http code etc - http level, which I believe, should stay at http

[jplatte]

It is possible to write something like this, but it's not easy and I don't have time right now to write down in detail how you would do it. (the basic idea is that you need to write your own version of the Handler trait, and make your wrap function generic over it)

I'm really having a hard time understanding what you're trying to achieve here though. Why are you trying to make your handler functions independent of the HTTP message body content type? Are you looking to support multiple different content types?

[kirillsalykin]

thanks for the answer.

Let me start with answering why:

Why are you trying to make your handler functions independent of the HTTP message body content type?

I'd like to reduce boilerplate a little, cause I know it will be json in - json out.
I was thinking to use these wrappers later to export shape of handlers into typescript, similar to https://trpc.io or https://www.rspc.dev; something like basic version of rspc, fully based on axum router.

Also, it makes handlers simpler (in my understanding), cause they not depend on json or extractors, so can be tested or reused as regular functions (not sure there a big win here, but it feels "cleaner" to me, but probably this is pretty subjective).

the basic idea is that you need to write your own version of the Handler trait

thanks!
It is not urgent and I'd like to figure out this myself, but any help/pointers would be much appreciated!

[2ndDerivative]

It is possible to write something like this, but it's not easy and I don't have time right now to write down in detail how you would do it. (the basic idea is that you need to write your own version of the Handler trait, and make your wrap function generic over it)

I'm really having a hard time understanding what you're trying to achieve here though. Why are you trying to make your handler functions independent of the HTTP message body content type? Are you looking to support multiple different content types?

I have multiple times wanted to use some compile time guarantees in my handler in and outputs elsewhere, e.g. that the output is always Serialize, I imagine this is a similar attempt at it.