Support multipart/form-data and file uploads

cargo-progenitor/src/main.rs

@@ -234,7 +234,7 @@ pub fn dependencies(builder: Generator, include_client: bool) -> Vec<String> {
     let mut deps = vec![
         format!("bytes = \"{}\"", dependency_versions.get("bytes").unwrap()),
         format!("futures-core = \"{}\"", dependency_versions.get("futures-core").unwrap()),
-        format!("reqwest = {{ version = \"{}\", default-features=false, features = [\"json\", \"stream\"] }}", dependency_versions.get("reqwest").unwrap()),
+        format!("reqwest = {{ version = \"{}\", default-features=false, features = [\"json\", \"stream\", \"multipart\"] }}", dependency_versions.get("reqwest").unwrap()),
         format!("serde = {{ version = \"{}\", features = [\"derive\"] }}", dependency_versions.get("serde").unwrap()),
         format!("serde_urlencoded = \"{}\"", dependency_versions.get("serde_urlencoded").unwrap()),
     ];
@@ -290,7 +290,7 @@ pub fn dependencies(builder: Generator, include_client: bool) -> Vec<String> {
             dependency_versions.get("rand").unwrap()
         ));
     }
-    if type_space.uses_serde_json() {
+    if type_space.uses_serde_json() || builder.uses_form_parts() {
         deps.push(format!(
             "serde_json = \"{}\"",
             dependency_versions.get("serde_json").unwrap()

progenitor-client/Cargo.toml

@@ -10,7 +10,7 @@ description = "An OpenAPI client generator - client support"
 bytes = "1.5.0"
 futures-core = "0.3.28"
 percent-encoding = "2.3"
-reqwest = { version = "0.11.22", default-features = false, features = ["json", "stream"] }
+reqwest = { version = "0.11.22", default-features = false, features = ["json", "stream", "multipart"] }
 serde = "1.0"
 serde_json = "1.0"
 serde_urlencoded = "0.7.1"

progenitor-client/src/progenitor_client.rs

@@ -416,3 +416,32 @@ impl<E> RequestBuilderExt<E> for RequestBuilder {
             })?))
     }
 }
+
+/// Returns a string from any json value which is expected
+/// to work as `multipart/form-data` text. In particular, a
+/// [`serde_json::Value::String`] remains unquoted.
+///
+/// # Example
+/// ```
+/// # use progenitor_client::to_form_string;
+/// use serde_json::json;
+/// assert_eq!(to_form_string::<()>(&json!("a")).unwrap(), "a");
+/// assert_eq!(to_form_string::<()>(&json!(101)).unwrap(), "101");
+/// assert_eq!(
+///  to_form_string::<()>(&json!({"a": 202})).unwrap(),
+///  "{\"a\":202}"
+/// );
+/// ```
+#[doc(hidden)]
+pub fn to_form_string<E>(
+    value: &serde_json::Value,
+) -> Result<String, Error<E>> {
+    match value.as_str() {
+        // Take unquoted String Value
+        Some(v) => Ok(v.to_string()),
+        // otherwise convert to quoted json
+        None => serde_json::to_string(value).map_err(|_| {
+            Error::InvalidRequest("failed to serialize Value".to_string())
+        }),
+    }
+}

progenitor-impl/src/cli.rs

@@ -10,17 +10,18 @@ use typify::{Type, TypeEnumVariant, TypeSpaceImpl, TypeStructPropInfo};
 
 use crate::{
     method::{
-        OperationParameterKind, OperationParameterType, OperationResponseStatus,
+        BodyContentType, OperationParameterKind, OperationParameterType,
+        OperationResponseStatus,
     },
-    to_schema::ToSchema,
     util::{sanitize, Case},
-    validate_openapi, Generator, Result,
+    Generator, Result,
 };
 
 struct CliOperation {
     cli_fn: TokenStream,
     execute_fn: TokenStream,
     execute_trait: TokenStream,
+    uses_request_file_part: bool,
 }
 
 impl Generator {
@@ -30,16 +31,7 @@ impl Generator {
         spec: &OpenAPI,
         crate_name: &str,
     ) -> Result<TokenStream> {
-        validate_openapi(spec)?;
-
-        // Convert our components dictionary to schemars
-        let schemas = spec.components.iter().flat_map(|components| {
-            components.schemas.iter().map(|(name, ref_or_schema)| {
-                (name.clone(), ref_or_schema.to_schema())
-            })
-        });
-
-        self.type_space.add_ref_types(schemas)?;
+        self.add_ref_types(spec)?;
 
         let raw_methods = spec
             .paths
@@ -100,6 +92,26 @@ impl Generator {
             })
             .collect::<Vec<_>>();
 
+        let request_file = methods.iter().any(|method|method.uses_request_file_part).then(|| {
+            quote! {
+                fn request_file_part(
+                    &self,
+                    path: &std::path::PathBuf,
+                ) -> Result<reqwest::multipart::Part, String> {
+                    use std::io::Read;
+                    let mut file = std::fs::File::open(&path).map_err(|e| e.to_string())?;
+                    let mut value = Vec::new();
+                    file.read_to_end(&mut value).map_err(|e| e.to_string())?;
+                    let part = reqwest::multipart::Part::bytes(value);
+                    Ok(if let Some(file_name) = path.file_name() {
+                        part.file_name(file_name.to_string_lossy().into_owned())
+                    } else {
+                        part
+                    })
+                }
+            }
+        });
+
         let crate_ident = format_ident!("{}", crate_name);
 
         let code = quote! {
@@ -151,6 +163,7 @@ impl Generator {
 
             pub trait CliOverride {
                 #(#trait_ops)*
+                #request_file
             }
 
             impl CliOverride for () {}
@@ -182,6 +195,7 @@ impl Generator {
         let CliArg {
             parser: parser_args,
             consumer: consumer_args,
+            uses_request_file_part,
         } = self.cli_method_args(method);
 
         let about = method.summary.as_ref().map(|summary| {
@@ -315,6 +329,7 @@ impl Generator {
             cli_fn,
             execute_fn,
             execute_trait,
+            uses_request_file_part,
         }
     }
 
@@ -390,23 +405,18 @@ impl Generator {
                 }
             };
 
-            args.add_arg(arg_name, CliArg { parser, consumer })
+            args.add_arg(arg_name, CliArg::new(parser, consumer))
         }
 
-        let maybe_body_type_id = method
-            .params
-            .iter()
-            .find(|param| {
-                matches!(&param.kind, OperationParameterKind::Body(_))
-            })
-            .and_then(|param| match &param.typ {
-                // TODO not sure how to deal with raw bodies, but we definitely
-                // need **some** input so we shouldn't just ignore it... as we
-                // are currently...
-                OperationParameterType::RawBody => None,
-
-                OperationParameterType::Type(body_type_id) => {
-                    Some(body_type_id)
+        // args that destructure a structured body
+        let maybe_body_type_id =
+            method.params.iter().find_map(|param| {
+                match (&param.kind, &param.typ) {
+                    (
+                        OperationParameterKind::Body(_),
+                        OperationParameterType::Type(body_type_id),
+                    ) => Some(body_type_id),
+                    _ => None,
                 }
             });
 
@@ -430,6 +440,56 @@ impl Generator {
             }
         }
 
+        // args to send binary files
+        let body_file_args = method
+            .params
+            .iter()
+            .filter_map(|param| match (&param.kind, &param.typ) {
+                // TODO: impl, which should be pretty
+                // straight forward with a custom consumer
+                ( _, OperationParameterType::RawBody) => None,
+                // TODO: impl, which should be pretty
+                // straight forward with a custom consumer
+                ( OperationParameterKind::Body(BodyContentType::OctetStream),
+                    _,
+                ) => None,
+                (
+                    OperationParameterKind::Body(BodyContentType::FormData(
+                        required,
+                    )),
+                    OperationParameterType::FormPart,
+                ) => Some((param, *required)),
+                _ => None,
+            })
+            .map(|(param, required)| {
+                let help = if let Some(description) = &param.description {
+                    quote! { .help(#description) }
+                } else {
+                    quote! { .help("Path to file.") }
+                };
+                let arg_name = param.api_name.to_kebab_case();
+                let request_field = format_ident!("{}", param.name);
+                let parser = quote! {
+                    clap::Arg::new(#arg_name)
+                        .required(#required)
+                        .value_parser(clap::value_parser!(std::path::PathBuf))
+                        #help
+                };
+                let part = if required {
+                    quote! { part }
+                } else {
+                    quote ! { Some(part) }
+                };
+                let consumer = quote! {
+                    if let Some(path) = matches.get_one::<std::path::PathBuf>(#arg_name) {
+                        let part = self.over.request_file_part(path).unwrap();
+                        request = request.#request_field(#part);
+                    }
+                };
+                (param.api_name.clone(), CliArg { parser, consumer, uses_request_file_part: true })
+            });
+        args.args.extend(body_file_args);
+
         let parser_args =
             args.args.values().map(|CliArg { parser, .. }| parser);
 
@@ -497,7 +557,14 @@ impl Generator {
             #body_json_consumer
         };
 
-        CliArg { parser, consumer }
+        CliArg {
+            parser,
+            consumer,
+            uses_request_file_part: args
+                .args
+                .values()
+                .any(|arg| arg.uses_request_file_part),
+        }
     }
 
     fn cli_method_body_arg(
@@ -570,7 +637,7 @@ impl Generator {
                     })
                 }
             };
-            args.add_arg(prop_name, CliArg { parser, consumer })
+            args.add_arg(prop_name, CliArg::new(parser, consumer))
         } else if required {
             args.body_required()
         }
@@ -674,6 +741,19 @@ struct CliArg {
 
     /// Code to consume the argument
     consumer: TokenStream,
+
+    /// Whether request_file_part is used to consume the argument
+    uses_request_file_part: bool,
+}
+
+impl CliArg {
+    fn new(parser: TokenStream, consumer: TokenStream) -> Self {
+        Self {
+            parser,
+            consumer,
+            uses_request_file_part: false,
+        }
+    }
 }
 
 #[derive(Debug, Default, PartialEq, Eq)]