How to get multiple parameters while destructuring them at the same time?

[Alc-Alc]

Heya, what changes should I do in err_route so that it behaves the same as ok_route? I want to destructure two path parameters into Something while receiving one path parameter directly.

use axum::{Router, extract::Path, routing::get, serve};
use tokio::net::TcpListener;

#[derive(serde::Deserialize)]
pub struct Something {x: i32, y: i32 }

async fn ok_route(Path((s, x, y)): Path<(String, i32, i32)>) -> String {
    format!("{s} {x} {y}")
}

async fn err_route(Path((s, Something { x, y })): Path<(String, Something)>) -> String {
    format!("{s} {x} {y}")
}

#[tokio::main]
async fn main() {
    let router = Router::new()
        .route("/ok/{s}/{x}/{y}", get(ok_route))
        .route("/err/{s}/{x}/{y}", get(err_route));
    let listener = TcpListener::bind("localhost:8080").await.unwrap();
    serve(listener, router).await.unwrap();
}

Current Behavior

% curl localhost:8080/ok/test/2/3
test 2 3
% curl localhost:8080/err/test/2/3
Wrong number of path arguments for `Path`. Expected 2 but got 3

Expected Behavior

% curl localhost:8080/ok/test/2/3
test 2 3
% curl localhost:8080/err/test/2/3
test 2 3

Version Information

rustc and cargo 1.88.0, edition 2024

[dependencies]
axum = { version = "0.8.4", features = ["macros"] }
serde = { version = "1.0.219", features = ["derive"] }
tokio = { version = "1.46.1", features = ["rt-multi-thread", "tokio-macros"] }

[jplatte]

That's not possible. If you use the tuple form, every element of the tuple has to correspond to one path parameter. I think the last one being Vec for a wildcarm parameter works too, but not capturing multiple distinct parameters in a single tuple element.

[Alc-Alc]

Thank you for the prompt response and clarifying this. Appreciate the work you do here 🙂

[mladedav]

You can try using something else than a tuple (anything implementing Deserialize), having another wrapper struct like this and then flattening the inner struct kind of works:

#[derive(serde::Deserialize)]
pub struct Wrapper {
    s: String,
    #[serde(flatten)]
    something: Something,
}

#[derive(serde::Deserialize)]
pub struct Something {
    x: String,
    y: String,
}
//...
async fn err_route(
    Path(Wrapper {
        s,
        something: Something { x, y },
    }): Path<Wrapper>,
) -> String {
    format!("{s} {x} {y}")
}

However, notice that I had to change x and y to Strings, for some reason the flattened deserialization does not work with other types. I'm not yet sure if there's just a small bug somewhere or there is a problem with supporting this.

[jplatte]

I would not recommend #[serde(flatten)] unless there is no other solution - the sort of thing you're seeing with only Strings working is very commonplace when using it, due to serde-rs/serde#1183.

[mladedav]

Oh, ok. We use it at work in some places with json and it seemed to work there.