Use serde_bytes crate for serializing Schema::Bytes

Cargo.toml

@@ -16,6 +16,7 @@ glob = "0.3"
 heck = "0.4"
 lazy_static = "1"
 serde = { version = "1", features = ["serde_derive"] }
+serde_bytes = "0.11"
 serde_json = "1"
 tera = { version = "1", default-features = false }
 thiserror = "1"

src/gen.rs

@@ -40,7 +40,7 @@ impl Generator {
     }
 
     /// Generates Rust code from an Avro schema [`Source`](Source).
-    /// Writes all generated types to the ouput.
+    /// Writes all generated types to the output.
     pub fn gen(&self, source: &Source, output: &mut impl Write) -> Result<()> {
         match source {
             Source::Schema(schema) => {

src/templates.rs

@@ -42,6 +42,9 @@ pub struct {{ name }} {
     {%- if defaults is containing(f) and not fields | length == defaults | length %}
     #[serde(default = "default_{{ name | lower }}_{{ f | lower | trim_start_matches(pat="r#") }}")]
     {%- endif %}
+    {%- if bytes is containing(f) %}
+    #[serde(with = "serde_bytes")]
+    {%- endif %}
     pub {{ f }}: {{ type }},
     {%- endfor %}
 }
@@ -409,6 +412,7 @@ impl Templater {
             let mut t = HashMap::new(); // field name -> field type
             let mut o = HashMap::new(); // field name -> original name
             let mut d = HashMap::new(); // field name -> default value
+            let mut b = HashSet::new(); // bytes fields;
 
             let mut fields_by_pos = fields.iter().clone().collect::<Vec<_>>();
             fields_by_pos.sort_by_key(|f| f.position);
@@ -482,6 +486,7 @@ impl Templater {
                     }
 
                     Schema::Bytes => {
+                        b.insert(name_std.clone());
                         f.push(name_std.clone());
                         t.insert(name_std.clone(), "Vec<u8>".to_string());
                         if let Some(default) = default {
@@ -599,6 +604,13 @@ impl Templater {
                             let default = self.parse_default(schema, gen_state, default)?;
                             d.insert(name_std.clone(), default);
                         }
+                        union.variants().iter().any(|variant| {
+                            if let Schema::Bytes = variant {
+                                b.insert(name_std.clone());
+                                return true;
+                            }
+                            false
+                        });
                     }
 
                     Schema::Null => err!("Invalid use of Schema::Null")?,
@@ -609,6 +621,7 @@ impl Templater {
             ctx.insert("types", &t);
             ctx.insert("originals", &o);
             ctx.insert("defaults", &d);
+            ctx.insert("bytes", &b);
             ctx.insert("is_eq_derivable", &gen_state.is_eq_derivable(schema));
             if self.nullable {
                 ctx.insert("nullable", &true);

tests/schemas/record.avsc

@@ -6,6 +6,7 @@
     {"name": "favoriteNumber",  "type": "int", "default": 7},
     {"name": "likes_pizza", "type": "boolean", "default": false},
     {"name": "b", "type": "bytes", "default": "\u00FF"},
+    {"name": "union_b", "type": ["null", "bytes"], "default": null},
     {"name": "a-bool", "type": {"type": "array", "items": "boolean"}, "default": [true, false]},
     {"name": "a-i32", "type": {"type": "array", "items": "int"}, "default": [12, -1]},
     {"name": "m-f64", "type": {"type": "map", "values": "double"}}

tests/schemas/record.rs

@@ -8,7 +8,11 @@ pub struct User {
     #[serde(default = "default_user_likes_pizza")]
     pub likes_pizza: bool,
     #[serde(default = "default_user_b")]
+    #[serde(with = "serde_bytes")]
     pub b: Vec<u8>,
+    #[serde(default = "default_user_union_b")]
+    #[serde(with = "serde_bytes")]
+    pub union_b: Option<Vec<u8>>,
     #[serde(rename = "a-bool")]
     #[serde(default = "default_user_a_bool")]
     pub a_bool: Vec<bool>,
@@ -28,6 +32,9 @@ fn default_user_likes_pizza() -> bool { false }
 #[inline(always)]
 fn default_user_b() -> Vec<u8> { vec![195, 191] }
 
+#[inline(always)]
+fn default_user_union_b() -> Option<Vec<u8>> { None }
+
 #[inline(always)]
 fn default_user_a_bool() -> Vec<bool> { vec![true, false] }