feat(codegen): generate builder APIs for multipart/related

Implement code generation for multipart/related request bodies with
expanded builder patterns. Instead of a single body parameter,
multipart schemas are expanded into individual builder methods for
each property (e.g., .file() and .metadata() methods).

Key changes:
- Parse multipart/related schemas and expand into typed properties
- Convert binary schema properties (format: binary) to Vec<u8>
- Generate MultipartRelatedBody trait implementations
- Reconstruct multipart structs in builder send() methods
- Binary fields serialized as application/octet-stream
- JSON fields serialized with serde_json

Addresses #1240

Author: lanej

progenitor-impl/src/cli.rs

@@ -440,7 +440,8 @@ impl Generator {
                 // are currently...
                 OperationParameterType::RawBody => None,
 
-                OperationParameterType::Type(body_type_id) => Some(body_type_id),
+                OperationParameterType::Type(body_type_id)
+                | OperationParameterType::MultipartRelated(body_type_id) => Some(body_type_id),
             });
 
         if let Some(body_type_id) = maybe_body_type_id {

progenitor-impl/src/httpmock.rs

@@ -161,8 +161,14 @@ impl Generator {
                         .get_type(arg_type_id)
                         .unwrap()
                         .parameter_ident(),
+                    OperationParameterType::MultipartRelated(arg_type_id) => self
+                        .type_space
+                        .get_type(arg_type_id)
+                        .unwrap()
+                        .parameter_ident(),
                     OperationParameterType::RawBody => match kind {
-                        OperationParameterKind::Body(BodyContentType::OctetStream) => quote! {
+                        OperationParameterKind::Body(BodyContentType::OctetStream)
+                        | OperationParameterKind::Body(BodyContentType::MultipartRelated) => quote! {
                             ::serde_json::Value
                         },
                         OperationParameterKind::Body(BodyContentType::Text(_)) => quote! {
@@ -250,8 +256,14 @@ impl Generator {
 
                             },
                         ),
+                        OperationParameterType::MultipartRelated(_) => (
+                            true,
+                            quote! {
+                                Self(self.0.json_body_obj(value))
+                            },
+                        ),
                         OperationParameterType::RawBody => match body_content_type {
-                            BodyContentType::OctetStream => (
+                            BodyContentType::OctetStream | BodyContentType::MultipartRelated => (
                                 true,
                                 quote! {
                                     Self(self.0.json_body(value))

progenitor-impl/src/lib.rs

@@ -11,7 +11,7 @@ use proc_macro2::TokenStream;
 use quote::quote;
 use serde::Deserialize;
 use thiserror::Error;
-use typify::{TypeSpace, TypeSpaceSettings};
+use typify::{TypeId, TypeSpace, TypeSpaceSettings};
 
 use crate::to_schema::ToSchema;
 
@@ -50,6 +50,7 @@ pub type Result<T> = std::result::Result<T, Error>;
 /// OpenAPI generator.
 pub struct Generator {
     type_space: TypeSpace,
+    multipart_related: indexmap::IndexSet<TypeId>,
     settings: GenerationSettings,
     uses_futures: bool,
     uses_websockets: bool,
@@ -261,6 +262,7 @@ impl Default for Generator {
     fn default() -> Self {
         Self {
             type_space: TypeSpace::new(TypeSpaceSettings::default().with_type_mod("types")),
+            multipart_related: Default::default(),
             settings: Default::default(),
             uses_futures: Default::default(),
             uses_websockets: Default::default(),
@@ -312,6 +314,7 @@ impl Generator {
 
         Self {
             type_space: TypeSpace::new(&type_settings),
+            multipart_related: Default::default(),
             settings: settings.clone(),
             uses_futures: false,
             uses_websockets: false,
@@ -374,6 +377,71 @@ impl Generator {
 
         let types = self.type_space.to_stream();
 
+        // Generate MultipartRelatedBody trait impl for multipart/related types
+        let multipart_helpers = TokenStream::from_iter(
+            self.multipart_related
+                .iter()
+                .map(|type_id| {
+                    let typ = self.get_type_space().get_type(type_id).unwrap();
+                    let type_name = typ.ident();
+
+                    let td = typ.details();
+                    let typify::TypeDetails::Struct(tstru) = td else {
+                        panic!("multipart/related type must be a struct");
+                    };
+
+                    // Generate code to extract each property
+                    let parts_extraction = tstru.properties().map(|(prop_name, prop_id)| {
+                        let prop_ty = self.get_type_space().get_type(&prop_id).ok();
+                        let field_ident = quote::format_ident!("{}", prop_name);
+
+                        // Check if this is a binary field - if it's Vec<u8>, it's binary
+                        let is_binary = prop_ty.map(|t| {
+                            // Check if this is a Vec type with u8 elements
+                            if let typify::TypeDetails::Vec(inner_id) = t.details() {
+                                // Check if the inner type is u8 by looking at its ident
+                                if let Ok(inner_ty) = self.get_type_space().get_type(&inner_id) {
+                                    inner_ty.ident().to_string() == "u8"
+                                } else {
+                                    false
+                                }
+                            } else {
+                                false
+                            }
+                        }).unwrap_or(false);
+
+                        if is_binary {
+                            quote! {
+                                progenitor_client::MultipartPart {
+                                    content_type: "application/octet-stream",
+                                    content_id: #prop_name,
+                                    bytes: self.#field_ident.clone(),
+                                }
+                            }
+                        } else {
+                            quote! {
+                                progenitor_client::MultipartPart {
+                                    content_type: "application/json",
+                                    content_id: #prop_name,
+                                    bytes: ::serde_json::to_vec(&self.#field_ident)
+                                        .expect("failed to serialize field"),
+                                }
+                            }
+                        }
+                    }).collect::<Vec<_>>();
+
+                    quote! {
+                        impl progenitor_client::MultipartRelatedBody for #type_name {
+                            fn as_multipart_parts(&self) -> Vec<progenitor_client::MultipartPart> {
+                                vec![
+                                    #(#parts_extraction),*
+                                ]
+                            }
+                        }
+                    }
+                }),
+        );
+
         let (inner_type, inner_fn_value) = match self.settings.inner_type.as_ref() {
             Some(inner_type) => (inner_type.clone(), quote! { &self.inner }),
             None => (quote! { () }, quote! { &() }),
@@ -440,6 +508,8 @@ impl Generator {
             #[allow(clippy::all)]
             pub mod types {
                 #types
+
+                #multipart_helpers
             }
 
             #[derive(Clone, Debug)]