How to get request parts uri from inside a middleware?

[squeaktoy]

Summary

I'm working on a project at https://git.sr.ht/~latex/streamlist
I need to retrieve the uri of the request (specifically the query parameters) inside the XsltMiddleware.
I cannot use request directly inside the async move block, so I tried let (req_parts, _) = future.await?.into_parts(), but unfortunately req_parts mysteriously does not contain the uri field that I need, while request does contain it. What's going on?

Compiler error

error[E0609]: no field `uri` on type `axum::http::response::Parts`
   --> src/serve.rs:124:94
    |
124 |                 let query: Query<GetStreamsPagination> = match Query::try_from_uri(req_parts.uri) {
    |                                                                                              ^^^ unknown field
    |
    = note: available fields are: `status`, `version`, `headers`, `extensions`

error[E0609]: no field `uri` on type `axum::http::response::Parts`
   --> src/serve.rs:180:102
    |
180 |                         eprintln!("Failed to create XSLT context from \"{}\"! Error: {}", &req_parts.uri.path(), e);
    |                                                                                                      ^^^ unknown field
    |
    = note: available fields are: `status`, `version`, `headers`, `extensions`

error[E0609]: no field `uri` on type `axum::http::response::Parts`
   --> src/serve.rs:193:102
    |
193 |                         eprintln!("XSLT stylesheet \"{}\" failed to evaluate! Error: {}", &req_parts.uri.path(), e);
    |                                                                                                      ^^^ unknown field
    |
    = note: available fields are: `status`, `version`, `headers`, `extensions`

error[E0609]: no field `uri` on type `axum::http::response::Parts`
   --> src/serve.rs:214:97
    |
214 |                 eprintln!("XSLT stylesheet \"{}\" contains invalid endpoint \"{}\"", &req_parts.uri.path(), endpoint);
    |                                                                                                 ^^^ unknown field
    |
    = note: available fields are: `status`, `version`, `headers`, `extensions`

Info is in this commit on the dev branch: https://git.sr.ht/~latex/streamlist/commit/736e1a8f7b93924a9a28172cc7d6e3993ec49948

axum version

0.7.7

[yanns]

This is working for me:

pub fn my_middleware<B>(req: Request<B>) -> Request<B> {
    let (mut parts, body) = req.into_parts();
    let uri = &parts.uri;
[...]
    Request::from_parts(parts, body)
}

It seems that you're trying to read the uri from the response and not from the request.

[squeaktoy]

I can't really see how I'm getting the uri from the response. Also that's just a from_fn-compatible middleware you made and it only returns a request? Where is the body then? And how would I approach this in the following way: https://docs.rs/axum/latest/axum/middleware/index.html#towerservice-and-pinboxdyn-future ?

[yanns]

could you post more code. It's difficult to help you without seeing the code you're using.
If you need to get access to the response body, you can do it like in the documentation: https://docs.rs/axum/latest/axum/middleware/fn.from_fn.html

async fn my_middleware(request: Request, next: Next) -> Response {
    let uri = request.uri();

    let response = next.run(request).await;
    
    let response_body = response.body();

    // do something with `response_body`...

    response
}

[squeaktoy]

Here is the code. https://git.sr.ht/~latex/streamlist/tree/736e1a8f7b93924a9a28172cc7d6e3993ec49948/item/src/serve.rs#L99
As you can see, I'm using the "tower::Service and Pin<Box>" method of making a middleware. I already figured out how to play with the response, but when I try to access the request, that's where things go wrong. I cannot access the uri field when using let (req_parts, _) = future.await?.into_parts();, but when I try using let (req_parts, _) = request.into_parts();, I get compiler errors like these:

error: lifetime may not live long enough
   --> src/serve.rs:98:9
    |
96  |       fn call(&mut self, request: Request) -> Self::Future {
    |               - let's call the lifetime of this reference `'1`
97  |           let future = self.inner.call(request);
98  | /         Box::pin(async move {
99  | |             let (req_parts, _) = request.into_parts();
100 | |             let response: Response = future.await?;
101 | |             let (resp_parts, resp_body) = response.into_parts();
...   |
220 | |             }
221 | |         })
    | |__________^ returning this value requires that `'1` must outlive `'static`

error[E0382]: use of moved value: `request`
   --> src/serve.rs:98:18
    |
96  |       fn call(&mut self, request: Request) -> Self::Future {
    |                          ------- move occurs because `request` has type `axum::http::Request<axum::body::Body>`, which does not implement the `Copy` trait
97  |           let future = self.inner.call(request);
    |                                        ------- value moved here
98  |           Box::pin(async move {
    |  __________________^
99  | |             let (req_parts, _) = request.into_parts();
    | |                                  ------- use occurs due to use in coroutine
100 | |             let response: Response = future.await?;
101 | |             let (resp_parts, resp_body) = response.into_parts();
...   |
220 | |             }
221 | |         })
    | |_________^ value used here after move

[yanns]

Could read the uri before the async move block?
like:

    fn call(&mut self, request: Request) -> Self::Future {
        let uri = request.uri().clone();
        let future = self.inner.call(request);

        Box::pin(async move {
            println!("Request to {}", uri);
            let response: Response = future.await?;
            Ok(response)
        })
    }