fix for nullable fields

crates/jacquard-common/src/opt_serde_bytes_helper.rs

···
 //! Custom serde helpers for bytes::Bytes using serde_bytes
 
+use base64::{
+    Engine,
+    prelude::{BASE64_STANDARD, BASE64_STANDARD_NO_PAD, BASE64_URL_SAFE, BASE64_URL_SAFE_NO_PAD},
+};
 use bytes::Bytes;
-use serde::{Deserializer, Serializer};
+use core::fmt;
+use serde::{
+    Deserializer, Serializer,
+    de::{self, MapAccess, Visitor},
+};
 
 /// Serialize Bytes as a CBOR byte string
 pub fn serialize<S>(bytes: &Option<Bytes>, serializer: S) -> Result<S::Ok, S::Error>
···
     S: Serializer,
 {
     if let Some(bytes) = bytes {
-        serde_bytes::serialize(bytes.as_ref(), serializer)
+        if serializer.is_human_readable() {
+            // JSON: {"$bytes": "base64 string"}
+            use serde::ser::SerializeMap;
+            let mut map = serializer.serialize_map(Some(1))?;
+            map.serialize_entry("$bytes", &BASE64_STANDARD.encode(bytes))?;
+            map.end()
+        } else {
+            // CBOR: raw bytes
+            serde_bytes::serialize(bytes.as_ref(), serializer)
+        }
     } else {
         serializer.serialize_none()
     }
···
 where
     D: Deserializer<'de>,
 {
-    let vec: Option<Vec<u8>> = serde_bytes::deserialize(deserializer)?;
-    Ok(vec.map(Bytes::from))
+    if deserializer.is_human_readable() {
+        Ok(deserializer.deserialize_map(OptBytesVisitor)?)
+    } else {
+        let vec: Option<Vec<u8>> = serde_bytes::deserialize(deserializer)?;
+        Ok(vec.map(Bytes::from))
+    }
+}
+
+struct OptBytesVisitor;
+
+impl<'de> Visitor<'de> for OptBytesVisitor {
+    type Value = Option<Bytes>;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("a base64-encoded string")
+    }
+
+    fn visit_none<E>(self) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(None)
+    }
+
+    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let vec: Vec<u8> = serde_bytes::deserialize(deserializer)?;
+        Ok(Some(Bytes::from(vec)))
+    }
+
+    fn visit_unit<E>(self) -> Result<Self::Value, E> {
+        Ok(None)
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: MapAccess<'de>,
+    {
+        let mut bytes = None;
+
+        while let Some(key) = map.next_key()? {
+            match key {
+                "$bytes" => {
+                    if bytes.is_some() {
+                        return Err(de::Error::duplicate_field("$bytes"));
+                    }
+                    let bytes_str: String = map.next_value()?;
+                    // First one should just work. rest are insurance.
+                    bytes = if let Ok(bytes) = BASE64_STANDARD.decode(&bytes_str) {
+                        Some(Bytes::from_owner(bytes))
+                    } else if let Ok(bytes) = BASE64_STANDARD_NO_PAD.decode(&bytes_str) {
+                        Some(Bytes::from_owner(bytes))
+                    } else if let Ok(bytes) = BASE64_URL_SAFE.decode(&bytes_str) {
+                        Some(Bytes::from_owner(bytes))
+                    } else if let Ok(bytes) = BASE64_URL_SAFE_NO_PAD.decode(&bytes_str) {
+                        Some(Bytes::from_owner(bytes))
+                    } else {
+                        return Err(de::Error::custom("invalid base64 string"));
+                    }
+                }
+                _ => {
+                    return Err(de::Error::unknown_field(key, &["$bytes"]));
+                }
+            }
+        }
+
+        Ok(bytes)
+    }
 }

crates/jacquard-common/src/serde_bytes_helper.rs

···
 //! Custom serde helpers for bytes::Bytes using serde_bytes
 
+use core::fmt;
+
+use base64::{
+    Engine,
+    prelude::{BASE64_STANDARD, BASE64_STANDARD_NO_PAD, BASE64_URL_SAFE, BASE64_URL_SAFE_NO_PAD},
+};
 use bytes::Bytes;
-use serde::{Deserializer, Serializer};
+use serde::{
+    Deserializer, Serializer,
+    de::{self, MapAccess, Visitor},
+};
 
 /// Serialize Bytes as a CBOR byte string
 pub fn serialize<S>(bytes: &Bytes, serializer: S) -> Result<S::Ok, S::Error>
 where
     S: Serializer,
 {
-    serde_bytes::serialize(bytes.as_ref(), serializer)
+    if serializer.is_human_readable() {
+        // JSON: {"$bytes": "base64 string"}
+        use serde::ser::SerializeMap;
+        let mut map = serializer.serialize_map(Some(1))?;
+        map.serialize_entry("$bytes", &BASE64_STANDARD.encode(bytes))?;
+        map.end()
+    } else {
+        // CBOR: raw bytes
+        serde_bytes::serialize(bytes.as_ref(), serializer)
+    }
 }
 
 /// Deserialize Bytes from a CBOR byte string
···
 where
     D: Deserializer<'de>,
 {
-    let vec: Vec<u8> = serde_bytes::deserialize(deserializer)?;
-    Ok(Bytes::from(vec))
+    if deserializer.is_human_readable() {
+        Ok(deserializer.deserialize_map(BytesVisitor)?)
+    } else {
+        let vec: Vec<u8> = serde_bytes::deserialize(deserializer)?;
+        Ok(Bytes::from(vec))
+    }
+}
+
+struct BytesVisitor;
+
+impl<'de> Visitor<'de> for BytesVisitor {
+    type Value = Bytes;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("a base64-encoded string")
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: MapAccess<'de>,
+    {
+        let mut bytes = None;
+
+        while let Some(key) = map.next_key()? {
+            match key {
+                "$bytes" => {
+                    if bytes.is_some() {
+                        return Err(de::Error::duplicate_field("$bytes"));
+                    }
+                    let bytes_str: String = map.next_value()?;
+                    // First one should just work. rest are insurance.
+                    bytes = if let Ok(bytes) = BASE64_STANDARD.decode(&bytes_str) {
+                        Some(Bytes::from_owner(bytes))
+                    } else if let Ok(bytes) = BASE64_STANDARD_NO_PAD.decode(&bytes_str) {
+                        Some(Bytes::from_owner(bytes))
+                    } else if let Ok(bytes) = BASE64_URL_SAFE.decode(&bytes_str) {
+                        Some(Bytes::from_owner(bytes))
+                    } else if let Ok(bytes) = BASE64_URL_SAFE_NO_PAD.decode(&bytes_str) {
+                        Some(Bytes::from_owner(bytes))
+                    } else {
+                        return Err(de::Error::custom("invalid base64 string"));
+                    }
+                }
+                _ => {
+                    return Err(de::Error::unknown_field(key, &["$bytes"]));
+                }
+            }
+        }
+
+        bytes.ok_or_else(|| de::Error::missing_field("$bytes"))
+    }
 }

crates/jacquard-lexicon/src/codegen/structs.rs

···
         nsid: &str,
         parent_type_name: &str,
         obj: &LexObject<'static>,
-        is_builder: bool,
+        _is_builder: bool,
     ) -> Result<TokenStream> {
         let required = obj.required.as_ref().map(|r| r.as_slice()).unwrap_or(&[]);
+        let nullable = obj.nullable.as_ref().map(|n| n.as_slice()).unwrap_or(&[]);
 
         let mut fields = Vec::new();
         for (field_name, field_type) in &obj.properties {
             let is_required = required.contains(field_name);
+            let is_nullable = nullable.contains(field_name);
             let field_tokens = self.generate_field(
                 nsid,
                 parent_type_name,
                 field_name,
                 field_type,
                 is_required,
-                is_builder,
+                is_nullable,
             )?;
             fields.push(field_tokens);
         }
···
         field_name: &str,
         field_type: &LexObjectProperty<'static>,
         is_required: bool,
-        _is_builder: bool,
+        is_nullable: bool,
     ) -> Result<TokenStream> {
         if field_name.is_empty() {
             eprintln!(
···
             self.property_to_rust_type(nsid, parent_type_name, field_name, field_type)?;
         let needs_lifetime = self.property_needs_lifetime(field_type);
 
-        let rust_type = if is_required {
+        let rust_type = if is_required && !is_nullable {
             rust_type
         } else {
             quote! { std::option::Option<#rust_type> }