feat: integrate URL-safe byte encoding

Author: lightsofapollo

.beads/issues.jsonl

@@ -128,7 +128,7 @@
 //!
 //! # Examples
 //!
-//! See the [examples](https://github.com/your-repo/examples) directory for complete examples:
+//! See the [examples](https://github.com/gpu-cli/openapi-to-rust/tree/main/examples) directory for complete examples:
 //! - `toml_config_example.rs` - Various configuration patterns
 //! - `complete_workflow.rs` - Full generation workflow with TOML
 //!
@@ -581,7 +581,7 @@ fn inspect_type_config_layout(value: &toml::Value) -> Result<(), GeneratorError>
         .is_some()
     {
         return Err(GeneratorError::ValidationError(
-            "[generator.types.strategies] is obsolete. Move its fields directly under [generator.types]. Use snake_case keys such as date_time (not date-time); valid byte values are string, base64, and vec_u8 (for example: byte = \"base64\")."
+            "[generator.types.strategies] is obsolete. Move its fields directly under [generator.types]. Use snake_case keys such as date_time (not date-time); valid byte values are string, base64, base64_url_unpadded, and vec_u8 (for example: byte = \"base64\")."
                 .to_string(),
         ));
     }

src/config.rs

@@ -501,27 +501,33 @@ impl CodeGenerator {
             .used_type_features
             .contains(crate::type_mapping::TypeFeature::Base64)
         {
+            let engine = match self.config.types.byte {
+                crate::type_mapping::ByteStrategy::Base64UrlUnpadded => {
+                    quote::format_ident!("URL_SAFE_NO_PAD")
+                }
+                _ => quote::format_ident!("STANDARD"),
+            };
             quote! {
                 /// base64 codec for `Vec<u8>` fields produced from
                 /// `format: byte`. Used via `#[serde(with = "base64_serde")]`
                 /// for required/non-null fields; `with = "base64_serde::option"`
                 /// for the Option<Vec<u8>> case.
                 mod base64_serde {
-                    use base64::{Engine as _, engine::general_purpose::STANDARD};
+                    use base64::{Engine as _, engine::general_purpose::#engine as ENGINE};
                     use serde::{Deserialize, Deserializer, Serializer};
 
                     pub fn serialize<S: Serializer>(
                         bytes: &Vec<u8>,
                         ser: S,
                     ) -> Result<S::Ok, S::Error> {
-                        ser.serialize_str(&STANDARD.encode(bytes))
+                        ser.serialize_str(&ENGINE.encode(bytes))
                     }
 
                     pub fn deserialize<'de, D: Deserializer<'de>>(
                         de: D,
                     ) -> Result<Vec<u8>, D::Error> {
                         let s = String::deserialize(de)?;
-                        STANDARD
+                        ENGINE
                             .decode(s.as_bytes())
                             .map_err(serde::de::Error::custom)
                     }
@@ -550,7 +556,7 @@ impl CodeGenerator {
                         ) -> Result<Option<Vec<u8>>, D::Error> {
                             let opt = Option::<String>::deserialize(de)?;
                             opt.map(|s| {
-                                STANDARD
+                                ENGINE
                                     .decode(s.as_bytes())
                                     .map_err(serde::de::Error::custom)
                             })

src/generator.rs

@@ -30,7 +30,8 @@ pub use http_config::{AuthConfig, HttpClientConfig, RetryConfig};
 pub use http_error::{ApiError, ApiOpError, HttpError, HttpResult};
 pub use openapi::{OpenApiSpec, Schema, SchemaType};
 pub use type_mapping::{
-    DepRequirement, MappedType, TypeFeature, TypeMapper, TypeMappingConfig, UsedFeatures,
+    ByteStrategy, DepRequirement, MappedType, TypeFeature, TypeMapper, TypeMappingConfig,
+    UsedFeatures,
 };
 
 pub type Result<T> = std::result::Result<T, GeneratorError>;

src/lib.rs

@@ -477,9 +477,13 @@ pub enum UuidStrategy {
 pub enum ByteStrategy {
     String,
     /// `Vec<u8>` round-tripped via an inlined `base64_serde` module
-    /// (default).
+    /// using the standard padded alphabet (default).
     #[default]
     Base64,
+    /// `Vec<u8>` round-tripped with the URL-safe, unpadded alphabet
+    /// from RFC 7515 section 2. This setting applies to every
+    /// `format: byte` field in the generated module.
+    Base64UrlUnpadded,
     /// `Vec<u8>` with no codec (caller responsible for encoding).
     VecU8,
 }
@@ -921,11 +925,12 @@ impl TypeMapper {
         match strat {
             ByteStrategy::String => MappedType::plain("String"),
             ByteStrategy::VecU8 => MappedType::plain("Vec<u8>"),
-            ByteStrategy::Base64 => {
+            ByteStrategy::Base64 | ByteStrategy::Base64UrlUnpadded => {
                 self.record(TypeFeature::Base64);
                 // Path is resolved relative to the generated
                 // module; the helper module is emitted as
-                // `base64_serde` at the top of `types.rs`.
+                // `base64_serde` at the top of `types.rs`. Its
+                // alphabet is selected once during code generation.
                 MappedType::with_codec("Vec<u8>", "base64_serde", TypeFeature::Base64)
             }
         }
@@ -1086,6 +1091,25 @@ mod tests {
         assert_eq!(mt.feature, Some(TypeFeature::Base64));
     }
 
+    #[test]
+    fn byte_url_unpadded_reuses_base64_codec() {
+        let mapper = TypeMapper::new(TypeMappingConfig {
+            byte: ByteStrategy::Base64UrlUnpadded,
+            ..TypeMappingConfig::default()
+        });
+        let mapped = mapper.string_format(Some("byte"));
+        assert_eq!(mapped.rust_type, "Vec<u8>");
+        assert_eq!(mapped.serde_with.as_deref(), Some("base64_serde"));
+        assert_eq!(mapped.feature, Some(TypeFeature::Base64));
+    }
+
+    #[test]
+    fn byte_url_unpadded_parses_from_toml() {
+        let config: TypeMappingConfig =
+            toml::from_str(r#"byte = "base64_url_unpadded""#).expect("parse type config");
+        assert_eq!(config.byte, ByteStrategy::Base64UrlUnpadded);
+    }
+
     #[test]
     fn conservative_config_collapses_everything_to_string() {
         let m = TypeMapper::new(TypeMappingConfig::conservative());

src/type_mapping.rs

@@ -12,7 +12,7 @@
 //! `SchemaType::Primitive.serde_with`.
 
 use openapi_to_rust::{
-    CodeGenerator, GeneratorConfig, SchemaAnalyzer, TypeMapper, TypeMappingConfig,
+    ByteStrategy, CodeGenerator, GeneratorConfig, SchemaAnalyzer, TypeMapper, TypeMappingConfig,
 };
 use serde_json::json;
 
@@ -47,6 +47,19 @@ fn generate(spec: serde_json::Value, mapper: TypeMapper) -> String {
     codegen.generate(&mut analysis).expect("generate")
 }
 
+fn generate_with_types(spec: serde_json::Value, types: TypeMappingConfig) -> String {
+    let mut analyzer =
+        SchemaAnalyzer::with_type_mapper(spec, TypeMapper::new(types.clone())).expect("analyzer");
+    let mut analysis = analyzer.analyze().expect("analyze");
+    let codegen = CodeGenerator::new(GeneratorConfig {
+        module_name: "sample".into(),
+        enable_async_client: false,
+        types,
+        ..Default::default()
+    });
+    codegen.generate(&mut analysis).expect("generate")
+}
+
 #[test]
 fn date_time_default_emits_chrono_datetime() {
     let code = generate(
@@ -144,6 +157,80 @@ fn byte_default_emits_vec_u8_with_base64_codec() {
         code.contains("mod base64_serde"),
         "Generated file should include the base64_serde helper module. Code:\n{code}"
     );
+    assert!(code.contains("STANDARD as ENGINE"), "Code:\n{code}");
+    assert!(!code.contains("URL_SAFE_NO_PAD"), "Code:\n{code}");
+}
+
+#[test]
+fn byte_url_unpadded_emits_rfc7515_codec() {
+    let code = generate_with_types(
+        spec_with_format("byte"),
+        TypeMappingConfig {
+            byte: ByteStrategy::Base64UrlUnpadded,
+            ..TypeMappingConfig::default()
+        },
+    );
+    assert!(code.contains("URL_SAFE_NO_PAD as ENGINE"), "Code:\n{code}");
+    assert!(!code.contains("STANDARD as ENGINE"), "Code:\n{code}");
+}
+
+#[test]
+fn generated_byte_url_unpadded_codec_round_trips() {
+    let code = generate_with_types(
+        spec_with_format("byte"),
+        TypeMappingConfig {
+            byte: ByteStrategy::Base64UrlUnpadded,
+            ..TypeMappingConfig::default()
+        },
+    );
+    let temp = tempfile::TempDir::new().expect("scratch crate");
+    std::fs::create_dir_all(temp.path().join("src")).expect("scratch src");
+    std::fs::write(temp.path().join("src/generated.rs"), code).expect("generated module");
+    std::fs::write(
+        temp.path().join("Cargo.toml"),
+        r#"[package]
+name = "byte-url-unpadded-roundtrip"
+version = "0.0.0"
+edition = "2024"
+publish = false
+
+[dependencies]
+base64 = "0.22"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+"#,
+    )
+    .expect("scratch manifest");
+    std::fs::write(
+        temp.path().join("src/main.rs"),
+        r##"#![allow(dead_code)]
+mod generated;
+
+fn main() {
+    let value = generated::Sample { value: vec![251, 255] };
+    let json = serde_json::to_string(&value).unwrap();
+    assert_eq!(json, r#"{"value":"-_8"}"#);
+    let decoded: generated::Sample = serde_json::from_str(&json).unwrap();
+    assert_eq!(decoded.value, vec![251, 255]);
+}
+"##,
+    )
+    .expect("scratch main");
+
+    let status = std::process::Command::new("cargo")
+        .args(["run", "--quiet", "--offline"])
+        .current_dir(temp.path())
+        .env(
+            "CARGO_TARGET_DIR",
+            std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+                .join("target/generated-byte-roundtrip"),
+        )
+        .status()
+        .expect("cargo run");
+    assert!(
+        status.success(),
+        "generated URL-safe codec did not round-trip"
+    );
 }
 
 #[test]