How to create a fn middleware based on first route parameter while ignore rest route parameters?

[qihexiang]

In my example, there are follow routes:

• POST /ws/:ws_id: create a workspace, ws_id is String
• GET /ws/:ws_id/stacks: get all stacks (a data structure for a molecule edition) in the workspace
• GET /ws/:ws_id/stacks/:stack_id: get details of a specified stack, stack_id is usize
• GET /ws/:ws_id/stack/:stack_id/group/:group_name: get atom indexes of specified stack in specified group, group_name is String.
• ...

All data are stored as state in a structure of Arc<RwLock<HashMap<String, Arc<RwLock<Workspace>>>>>.

As almost all routes contains ws_id parameter, I define a function middleware to check whether target workspace existed, and then provide a Arc<RwLock<Workspace>> to handlers of children routes wrapped in Extension, like:

pub async fn workspace_middleware<B>(
    State(store): State<ServerStore>,
    Path(ws): Path<String>,
    mut req: Request<B>,
    next: Next<B>,
) -> Result<Response, StatusCode> {
    if let Some(workspace) = store.read().await.get(&ws) {
        req.extensions_mut().insert(workspace.clone());
        Ok(next.run(req).await)
    } else {
        Err(StatusCode::NOT_FOUND)
    }
}

And register the routes and middleware in main function like:

let store = Arc::new(RwLock::new(HashMap::new()));

let workspace_rt = Router::new()
    .route("/stacks", get(read_stacks))
    .nest("/stacks/:stack_id", get(read_stack))
    .route_layer(middleware::from_fn_with_state(
        store.clone(),
        workspace_middleware,
    ))
    .route("/", post(create_workspace))

let router = Router::new()
    .nest("/ws/:ws_id", workspace_rt)
    .with_state(store);

It works fine on /ws/:ws_id and /ws/:ws_id/stacks, but doesn't work with ws/:ws_id/stacks/:stack_id. For example, if visit /ws/example1/stacks/0, It will response follow notice:

Wrong number of path arguments for `Path`. Expected 1 but got 2. Note that multiple parameters must be extracted with a tuple `Path<(_, _)>` or a struct `Path<YourParams>`

If define middlware function parameters in follow pattern:

pub async fn workspace_middleware<B>(
    State(store): State<ServerStore>,
    Path((ws, _)): Path<(String, Option<usize>)>,
    mut req: Request<B>,
    next: Next<B>,
) -> Result<Response, StatusCode>

It works with /ws/:ws_id/stacks/:stack_id, but when visit /ws/:ws_id/stacks, it response:

Wrong number of path arguments for `Path`. Expected 2 but got 1

I have tried to fix this problem by changing type of the second route parameter declared in the tuple from usize, (), Options<usize>, Option<()>, but none of them works.

Is it impossible to implement this middleware with a function? or I could get route parameters in another way in the function?

[davidpdrsn]

I think the easiest way is to define a struct with the params you want:

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/:a", get(handler_a))
        .route("/:a/:b", get(handler_b));

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

#[derive(Debug, Deserialize)]
struct Params {
    // this field name must correspond to the path param (`:a`)
    // params with other names will be ignored by `Path`
    a: String,
}

async fn handler_a(Path(params): Path<Params>) {
    dbg!(params);
}

async fn handler_b(Path(params): Path<Params>) {
    dbg!(params);
}

But you can also extract Path<HashMap<String, String>> to get all the params.

[qihexiang]

Thank you for your answer! It helps a lot!