fix(progenitor-macro): if 'client.inner' is not set by user do not provide it to user-specified functions. (#933)

Co-authored-by: Adam H. Leventhal <[email protected]>

Author: JosiahBull

example-macro/src/main.rs

@@ -4,8 +4,7 @@ use progenitor::generate_api;
 
 generate_api!(
     spec = "../sample_openapi/keeper.json",
-    inner_type = (),
-    pre_hook = (|_, request| {
+    pre_hook = (|request| {
         println!("doing this {:?}", request);
     }),
     pre_hook_async = crate::add_auth_headers,
@@ -14,7 +13,6 @@ generate_api!(
 );
 
 async fn add_auth_headers(
-    _: &(),
     req: &mut reqwest::Request,
 ) -> Result<(), reqwest::header::InvalidHeaderValue> {
     // You can perform asynchronous, fallible work in a request hook, then
@@ -29,7 +27,7 @@ async fn add_auth_headers(
     Ok(())
 }
 
-fn all_done(_: &(), _result: &reqwest::Result<reqwest::Response>) {}
+fn all_done(_result: &reqwest::Result<reqwest::Response>) {}
 
 mod buildomat {
     use progenitor::generate_api;

progenitor-impl/src/lib.rs

@@ -337,22 +337,30 @@ impl Generator {
             &self.settings.interface,
             &self.settings.tag,
         ) {
-            (InterfaceStyle::Positional, TagStyle::Merged) => {
-                self.generate_tokens_positional_merged(&raw_methods)
-            }
+            (InterfaceStyle::Positional, TagStyle::Merged) => self
+                .generate_tokens_positional_merged(
+                    &raw_methods,
+                    self.settings.inner_type.is_some(),
+                ),
             (InterfaceStyle::Positional, TagStyle::Separate) => {
                 unimplemented!("positional arguments with separate tags are currently unsupported")
             }
-            (InterfaceStyle::Builder, TagStyle::Merged) => {
-                self.generate_tokens_builder_merged(&raw_methods)
-            }
+            (InterfaceStyle::Builder, TagStyle::Merged) => self
+                .generate_tokens_builder_merged(
+                    &raw_methods,
+                    self.settings.inner_type.is_some(),
+                ),
             (InterfaceStyle::Builder, TagStyle::Separate) => {
                 let tag_info = spec
                     .tags
                     .iter()
                     .map(|tag| (&tag.name, tag))
                     .collect::<BTreeMap<_, _>>();
-                self.generate_tokens_builder_separate(&raw_methods, tag_info)
+                self.generate_tokens_builder_separate(
+                    &raw_methods,
+                    tag_info,
+                    self.settings.inner_type.is_some(),
+                )
             }
         }?;
 
@@ -503,10 +511,11 @@ impl Generator {
     fn generate_tokens_positional_merged(
         &mut self,
         input_methods: &[method::OperationMethod],
+        has_inner: bool,
     ) -> Result<TokenStream> {
         let methods = input_methods
             .iter()
-            .map(|method| self.positional_method(method))
+            .map(|method| self.positional_method(method, has_inner))
             .collect::<Result<Vec<_>>>()?;
 
         // The allow(unused_imports) on the `pub use` is necessary with Rust 1.76+, in case the
@@ -530,10 +539,13 @@ impl Generator {
     fn generate_tokens_builder_merged(
         &mut self,
         input_methods: &[method::OperationMethod],
+        has_inner: bool,
     ) -> Result<TokenStream> {
         let builder_struct = input_methods
             .iter()
-            .map(|method| self.builder_struct(method, TagStyle::Merged))
+            .map(|method| {
+                self.builder_struct(method, TagStyle::Merged, has_inner)
+            })
             .collect::<Result<Vec<_>>>()?;
 
         let builder_methods = input_methods
@@ -577,10 +589,13 @@ impl Generator {
         &mut self,
         input_methods: &[method::OperationMethod],
         tag_info: BTreeMap<&String, &openapiv3::Tag>,
+        has_inner: bool,
     ) -> Result<TokenStream> {
         let builder_struct = input_methods
             .iter()
-            .map(|method| self.builder_struct(method, TagStyle::Separate))
+            .map(|method| {
+                self.builder_struct(method, TagStyle::Separate, has_inner)
+            })
             .collect::<Result<Vec<_>>>()?;
 
         let (traits_and_impls, trait_preludes) =

progenitor-impl/src/method.rs

@@ -592,6 +592,7 @@ impl Generator {
     pub(crate) fn positional_method(
         &mut self,
         method: &OperationMethod,
+        has_inner: bool,
     ) -> Result<TokenStream> {
         let operation_id = format_ident!("{}", method.operation_id);
 
@@ -658,7 +659,7 @@ impl Generator {
             success: success_type,
             error: error_type,
             body,
-        } = self.method_sig_body(method, quote! { self })?;
+        } = self.method_sig_body(method, quote! { self }, has_inner)?;
 
         let method_impl = quote! {
             #[doc = #doc_comment]
@@ -814,6 +815,7 @@ impl Generator {
         &self,
         method: &OperationMethod,
         client: TokenStream,
+        has_inner: bool,
     ) -> Result<MethodSigBody> {
         let param_names = method
             .params
@@ -1129,22 +1131,26 @@ impl Generator {
             }
         };
 
+        let inner = match has_inner {
+            true => quote! { &#client.inner, },
+            false => quote! {},
+        };
         let pre_hook = self.settings.pre_hook.as_ref().map(|hook| {
             quote! {
-                (#hook)(&#client.inner, &#request_ident);
+                (#hook)(#inner &#request_ident);
             }
         });
         let pre_hook_async = self.settings.pre_hook_async.as_ref().map(|hook| {
             quote! {
-                match (#hook)(&#client.inner, &mut #request_ident).await {
+                match (#hook)(#inner &mut #request_ident).await {
                     Ok(_) => (),
                     Err(e) => return Err(Error::PreHookError(e.to_string())),
                 }
             }
         });
         let post_hook = self.settings.post_hook.as_ref().map(|hook| {
             quote! {
-                (#hook)(&#client.inner, &#result_ident);
+                (#hook)(#inner &#result_ident);
             }
         });
 
@@ -1474,6 +1480,7 @@ impl Generator {
         &mut self,
         method: &OperationMethod,
         tag_style: TagStyle,
+        has_inner: bool,
     ) -> Result<TokenStream> {
         let struct_name = sanitize(&method.operation_id, Case::Pascal);
         let struct_ident = format_ident!("{}", struct_name);
@@ -1718,7 +1725,8 @@ impl Generator {
             success,
             error,
             body,
-        } = self.method_sig_body(method, quote! { #client_ident })?;
+        } =
+            self.method_sig_body(method, quote! { #client_ident }, has_inner)?;
 
         let send_doc = format!(
             "Sends a `{}` request to `{}`",