second attempt

Author: tclem

crates/twirp-build/src/lib.rs

@@ -166,7 +166,7 @@ impl prost_build::ServiceGenerator for ServiceGenerator {
         let mut client_methods = Vec::with_capacity(service.methods.len());
         for m in &service.methods {
             let name = &m.name;
-            let build_name = format_ident!("build_{}", name);
+            let name_request = format_ident!("{}_request", name);
             let input_type = &m.input_type;
             let output_type = &m.output_type;
             let request_path = format!("{}/{}", service.fqn, m.proto_name);
@@ -175,18 +175,17 @@ impl prost_build::ServiceGenerator for ServiceGenerator {
                 async fn #name(&self, req: #input_type) -> Result<#output_type, twirp::ClientError>;
             });
             client_trait_methods.push(quote! {
-                fn #build_name(&self, req: #input_type) -> Result<twirp::RequestBuilder<#input_type, #output_type>, twirp::ClientError>;
+                fn #name_request(&self, req: #input_type) -> Result<twirp::RequestBuilder<#input_type, #output_type>, twirp::ClientError>;
             });
 
             client_methods.push(quote! {
-                fn #build_name(&self, req: #input_type) -> Result<twirp::RequestBuilder<#input_type, #output_type>, twirp::ClientError> {
-                    self.build_request(#request_path, req)
+                fn #name_request(&self, req: #input_type) -> Result<twirp::RequestBuilder<#input_type, #output_type>, twirp::ClientError> {
+                    self.request(#request_path, req)
                 }
             });
             client_methods.push(quote! {
                 async fn #name(&self, req: #input_type) -> Result<#output_type, twirp::ClientError> {
-                    let builder = self.#build_name(req)?;
-                    self.request(builder).await
+                    self.#name_request(req)?.send().await
                 }
             });
         }

crates/twirp/src/client.rs

@@ -158,31 +158,10 @@ impl Client {
         }
     }
 
-    pub fn build_request<I, O>(&self, path: &str, body: I) -> Result<RequestBuilder<I, O>>
+    pub(super) async fn execute<O>(&self, req: reqwest::Request) -> Result<O>
     where
-        I: prost::Message,
         O: prost::Message + Default,
     {
-        let mut url = self.inner.base_url.join(path)?;
-        if let Some(host) = &self.host {
-            url.set_host(Some(host))?
-        };
-
-        let req = self
-            .http_client
-            .post(url)
-            .header(CONTENT_TYPE, CONTENT_TYPE_PROTOBUF)
-            .body(serialize_proto_message(body));
-        Ok(RequestBuilder::new(req))
-    }
-
-    /// Make an HTTP twirp request.
-    pub async fn request<I, O>(&self, builder: RequestBuilder<I, O>) -> Result<O>
-    where
-        I: prost::Message,
-        O: prost::Message + Default,
-    {
-        let req = builder.build()?;
         let path = req.url().path().to_string();
 
         // Create and execute the middleware handlers
@@ -216,36 +195,64 @@ impl Client {
             }),
         }
     }
+
+    // Start building a request...
+    pub fn request<I, O>(&self, path: &str, body: I) -> Result<RequestBuilder<I, O>>
+    where
+        I: prost::Message,
+        O: prost::Message + Default,
+    {
+        let mut url = self.inner.base_url.join(path)?;
+        if let Some(host) = &self.host {
+            url.set_host(Some(host))?
+        };
+
+        let req = self
+            .http_client
+            .post(url)
+            .header(CONTENT_TYPE, CONTENT_TYPE_PROTOBUF)
+            .body(serialize_proto_message(body));
+        Ok(RequestBuilder::new(self.clone(), req))
+    }
 }
 
-pub struct RequestBuilder<I, O> {
+pub struct RequestBuilder<I, O>
+where
+    O: prost::Message + Default,
+{
+    client: Client,
     inner: reqwest::RequestBuilder,
     _input: std::marker::PhantomData<I>,
     _output: std::marker::PhantomData<O>,
 }
 
-impl<I, O> RequestBuilder<I, O> {
-    pub fn new(inner: reqwest::RequestBuilder) -> Self {
+impl<I, O> RequestBuilder<I, O>
+where
+    O: prost::Message + Default,
+{
+    pub fn new(client: Client, inner: reqwest::RequestBuilder) -> Self {
         Self {
+            client,
             inner,
             _input: std::marker::PhantomData,
             _output: std::marker::PhantomData,
         }
     }
 
-    pub fn header<K, V>(self, key: K, value: V) -> RequestBuilder<I, O>
+    pub fn header<K, V>(mut self, key: K, value: V) -> RequestBuilder<I, O>
     where
         HeaderName: TryFrom<K>,
         <HeaderName as TryFrom<K>>::Error: Into<http::Error>,
         HeaderValue: TryFrom<V>,
         <HeaderValue as TryFrom<V>>::Error: Into<http::Error>,
     {
-        RequestBuilder::new(self.inner.header(key, value))
+        self.inner = self.inner.header(key, value);
+        self
     }
 
-    /// Builds the request.
-    pub fn build(self) -> Result<reqwest::Request, reqwest::Error> {
-        self.inner.build()
+    pub async fn send(self) -> Result<O> {
+        let req = self.inner.build()?;
+        self.client.execute(req).await
     }
 }
 

crates/twirp/src/test.rs

@@ -121,8 +121,7 @@ pub trait TestApiClient {
 #[async_trait]
 impl TestApiClient for Client {
     async fn ping(&self, req: PingRequest) -> Result<PingResponse> {
-        let req = self.build_request("test.TestAPI/Ping", req)?;
-        self.request(req).await
+        self.request("test.TestAPI/Ping", req)?.send().await
     }
 
     async fn boom(&self, _req: PingRequest) -> Result<PingResponse> {

example/src/bin/client.rs

@@ -38,13 +38,12 @@ pub async fn main() -> Result<(), GenericError> {
         .await;
     eprintln!("{:?}", resp);
 
-    // TODO: Figure out where `with_host` goes in all this...
-    let req = client
+    let resp = client
         .with_host("localhost")
-        .build_make_hat(MakeHatRequest { inches: 1 })?
-        .header("x-custom-header", "a");
-    // Make a request with context
-    let resp = client.request(req).await?;
+        .make_hat_request(MakeHatRequest { inches: 1 })?
+        .header("x-custom-header", "a")
+        .send()
+        .await?;
     eprintln!("{:?}", resp);
 
     Ok(())
@@ -88,7 +87,7 @@ struct MockHaberdasherApiClient;
 
 #[async_trait]
 impl HaberdasherApiClient for MockHaberdasherApiClient {
-    fn build_make_hat(
+    fn make_hat_request(
         &self,
         _req: MakeHatRequest,
     ) -> Result<twirp::RequestBuilder<MakeHatRequest, MakeHatResponse>, twirp::ClientError> {
@@ -98,7 +97,7 @@ impl HaberdasherApiClient for MockHaberdasherApiClient {
         todo!()
     }
 
-    fn build_get_status(
+    fn get_status_request(
         &self,
         _req: GetStatusRequest,
     ) -> Result<twirp::RequestBuilder<GetStatusRequest, GetStatusResponse>, twirp::ClientError>