Recover reqwest::Client ergonomics from a tower::Service wrapped client

[conectado]

For a project I've a tower::Service and tower::Layer that modifies the body of any request in such a way that

impl Service<reqwest::Request> for WrapperService {
    type Response = reqwest::Response;

    type Error = Error;

    type Future = PendingWrapper;

    fn poll_ready(
        &mut self,
        _cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Result<(), Self::Error>> {
        std::task::Poll::Ready(Ok(()))
    }

    fn call(&mut self, mut req: reqwest::Request) -> Self::Future {
        <...>

        let new_body =
            match Wrapper::wrap(bytes, &self.extra) {
                Ok(new_body) => new_body,
                Err(err) => return PendingWrapper { pending: Err(err) },
            };
         
         <...>

        *req.body_mut() = Some(Body::from(new_body));

        PendingWrapper {
            pending: Ok(self.client.call(req)),
        }
    }
}

The reason for doing this isn't very important, the PendingWrapper only wraps Pending and returns an err if the service failed.

I have a trivial implementation of WrapperServiceLayer that just takes the reqwest::Client as inner and creates a WrapperService.

Then, I create a client like this:

let client = tower::ServiceBuilder::new()
    .layer(wrapper_middleware)
    .service(reqwest::Client::new());

The problem is that now to use client I have to do client.call(req).await where I need to manually create the reqwest::Request and I lose all the ergonomics from reqwest::Client where I could do client.post(url).header(...).... and so on.

It's not so bad, but before going down this road I wanted to see if there was an alternative I didn't know about where I could keep the ergonomics from reqwest::Client/reqwest::RequestBuilder and have a service that intercept and modifies the body of every request.

Thanks!

[seanmonstar]

There currently isn't a way that I can see. Well, I suppose you could keep a clone of the client, and use it to prepare a request, and then call .build() instead of send(), and pass that to your stack?

It could be possible if we followed the suggestions a couple people have made to completely disconnect the RequestBuilder from the client. I'm sympathetic to the desire, but I also feel very strongly that the builder style being able to just end in .send() is useful for a large portion of usage.

[conectado]

Keeping a client to only prepare the request seems like it could be a bit confusing for other people looking at the code.

What about another RequestBuilder that only builds request and keep the current one as a wrapper. Or maybe have the possibility of constructing a RequestBuilder from any tower::Service<Request, Future = impl Future<Output = reqwest::Response>>, or is that impossible due to mutability requirements on that trait?