wip

Author: paolobarbolini

benzina-derive/Cargo.toml

@@ -27,6 +27,7 @@ diesel = { version = "2", default-features = false, features = ["postgres", "mys
 [features]
 postgres = []
 mysql = []
+json = []
 
 [lints]
 workspace = true

benzina-derive/src/enum_derive.rs

@@ -34,11 +34,20 @@ struct EnumVariant {
     original_name: String,
     original_name_span: Span,
     rename: Option<String>,
+    #[cfg(all(feature = "postgres", feature = "json"))]
+    payload: Option<EnumVariantPayload>,
 
     crate_name: Option<Path>,
 }
 
+#[cfg(all(feature = "postgres", feature = "json"))]
+struct EnumVariantPayload {
+    type_: Type,
+    span: Span,
+}
+
 impl Enum {
+    #[expect(clippy::too_many_lines)]
     pub(crate) fn parse(input: DeriveInput) -> Result<Self, syn::Error> {
         let Data::Enum(e) = input.data else {
             fail!(input, "`benzina::Enum` macro available only for enums");
@@ -97,9 +106,29 @@ impl Enum {
             .variants
             .into_iter()
             .map(|variant| {
-                if !matches!(variant.fields, Fields::Unit) {
-                    fail!(variant, "only unit variants are supported");
-                }
+                let payload = match &variant.fields {
+                    Fields::Unit => None,
+                    #[cfg(all(feature = "postgres", feature = "json"))]
+                    Fields::Unnamed(fields) => {
+                        let mut fields = fields.unnamed.iter();
+                        let (Some(field), None) = (fields.next(), fields.next()) else {
+                            fail!(variant, "only single-item variants are supported");
+                        };
+
+                        let span = field.span();
+                        Some(EnumVariantPayload {
+                            type_: field.ty.clone(),
+                            span,
+                        })
+                    }
+                    #[cfg(not(all(feature = "postgres", feature = "json")))]
+                    Fields::Unnamed(_fields) => {
+                        fail!(variant, "fields require both the `postgres` and the `json` feature to be enabled");
+                    }
+                    Fields::Named(_fields) => {
+                        fail!(variant, "only unit an unnamed variants are supported");
+                    }
+                };
 
                 let name = variant.ident.to_string();
                 let mut rename = None;
@@ -120,11 +149,18 @@ impl Enum {
                     })?;
                 }
 
+                // Suppress build breakage when building without the
+                // PostgreSQL JSON feature.
+                #[cfg(not(all(feature = "postgres", feature = "json")))]
+                let _: Option<()> = payload;
+
                 let original_name_span = variant.span();
                 Ok(EnumVariant {
                     original_name: name,
                     original_name_span,
                     rename,
+                    #[cfg(all(feature = "postgres", feature = "json"))]
+                    payload,
 
                     crate_name: crate_name.clone(),
                 })
@@ -139,6 +175,22 @@ impl Enum {
             crate_name,
         })
     }
+
+    #[cfg(all(feature = "postgres", feature = "json"))]
+    fn has_json_fields(&self) -> bool {
+        self.variants
+            .iter()
+            .any(|variant| variant.payload.is_some())
+    }
+
+    #[cfg(not(all(feature = "postgres", feature = "json")))]
+    #[expect(
+        clippy::unused_self,
+        reason = "kept for compatibility with the above implementation"
+    )]
+    fn has_json_fields(&self) -> bool {
+        false
+    }
 }
 
 impl ToTokens for Enum {
@@ -153,16 +205,23 @@ impl ToTokens for Enum {
         } = &self;
         let crate_name = crate::crate_name(crate_name);
 
+        let has_json_fields = self.has_json_fields();
         let from_bytes_arms = variants
             .iter()
-            .map(|variant| variant.gen_from_bytes(*rename_all))
+            .map(|variant| variant.gen_from_bytes(has_json_fields, *rename_all))
             .collect::<Vec<_>>();
         let to_byte_str_arms = variants
             .iter()
-            .map(|variant| variant.gen_to_byte_str(*rename_all))
+            .map(|variant| variant.gen_to_byte_str(has_json_fields, *rename_all))
             .collect::<Vec<_>>();
 
-        #[cfg(feature = "postgres")]
+        let pg_sql_type = if self.has_json_fields() {
+            #[cfg(all(feature = "postgres", feature = "json"))]
+            quote! { (#sql_type, #crate_name::__private::diesel::pg::sql_types::Jsonb) }
+        } else {
+            quote! { #sql_type }
+        };
+
         tokens.append_all(quote! {
             impl diesel::deserialize::Queryable<#sql_type, #crate_name::__private::diesel::pg::Pg> for #ident {
                 type Row = Self;
@@ -173,7 +232,7 @@ impl ToTokens for Enum {
             }
 
             #[automatically_derived]
-            impl #crate_name::__private::diesel::deserialize::FromSql<#sql_type, #crate_name::__private::diesel::pg::Pg> for #ident {
+            impl #crate_name::__private::diesel::deserialize::FromSql<#pg_sql_type, #crate_name::__private::diesel::pg::Pg> for #ident {
                 fn from_sql(bytes: #crate_name::__private::diesel::pg::PgValue<'_>) -> #crate_name::__private::diesel::deserialize::Result<Self> {
                     match bytes.as_bytes() {
                         #(#from_bytes_arms)*
@@ -189,7 +248,7 @@ impl ToTokens for Enum {
             }
 
             #[automatically_derived]
-            impl #crate_name::__private::diesel::serialize::ToSql<#sql_type, #crate_name::__private::diesel::pg::Pg> for #ident {
+            impl #crate_name::__private::diesel::serialize::ToSql<#pg_sql_type, #crate_name::__private::diesel::pg::Pg> for #ident {
                 fn to_sql<'b>(&'b self, out: &mut #crate_name::__private::diesel::serialize::Output<'b, '_, #crate_name::__private::diesel::pg::Pg>) -> #crate_name::__private::diesel::serialize::Result {
                     let s = match self {
                         #(#to_byte_str_arms)*
@@ -204,44 +263,48 @@ impl ToTokens for Enum {
         });
 
         #[cfg(feature = "mysql")]
-        tokens.append_all(quote! {
-            #[automatically_derived]
-            impl #crate_name::__private::diesel::deserialize::FromSql<#sql_type, #crate_name::__private::diesel::mysql::Mysql> for #ident {
-                fn from_sql(bytes: #crate_name::__private::diesel::mysql::MysqlValue<'_>) -> #crate_name::__private::diesel::deserialize::Result<Self> {
-                    match bytes.as_bytes() {
-                        #(#from_bytes_arms)*
-                        _ => {
-                            #crate_name::__private::std::result::Result::Err(
-                                #crate_name::__private::std::convert::Into::into(
-                                    "Unrecognized enum variant"
+        if !self.has_json_fields() {
+            tokens.append_all(quote! {
+                #[automatically_derived]
+                impl #crate_name::"mysql"__private::diesel::deserialize::FromSql<#sql_type, #crate_name::__private::diesel::mysql::Mysql> for #ident {
+                    fn from_sql(bytes: #crate_name::__private::diesel::mysql::MysqlValue<'_>) -> #crate_name::__private::diesel::deserialize::Result<Self> {
+                        match bytes.as_bytes() {
+                            #(#from_bytes_arms)*
+                            _ => {
+                                #crate_name::__private::std::result::Result::Err(
+                                    #crate_name::__private::std::convert::Into::into(
+                                        "Unrecognized enum variant"
+                                    )
                                 )
-                            )
-                        },
+                            },
+                        }
                     }
                 }
-            }
 
-            #[automatically_derived]
-            impl #crate_name::__private::diesel::serialize::ToSql<#sql_type, #crate_name::__private::diesel::mysql::Mysql> for #ident {
-                fn to_sql<'b>(&'b self, out: &mut #crate_name::__private::diesel::serialize::Output<'b, '_, #crate_name::__private::diesel::mysql::Mysql>) -> #crate_name::__private::diesel::serialize::Result {
-                    let s = match self {
-                        #(#to_byte_str_arms)*
-                    };
-                    #crate_name::__private::std::io::Write::write_all(out, s)?;
+                #[automatically_derived]
+                impl #crate_name::__private::diesel::serialize::ToSql<#sql_type, #crate_name::__private::diesel::mysql::Mysql> for #ident {
+                    fn to_sql<'b>(&'b self, out: &mut #crate_name::__private::diesel::serialize::Output<'b, '_, #crate_name::__private::diesel::mysql::Mysql>) -> #crate_name::__private::diesel::serialize::Result {
+                        let s = match self {
+                            #(#to_byte_str_arms)*
+                        };
+                        #crate_name::__private::std::io::Write::write_all(out, s)?;
 
-                    #crate_name::__private::std::result::Result::Ok(#crate_name::__private::diesel::serialize::IsNull::No)
+                        #crate_name::__private::std::result::Result::Ok(#crate_name::__private::diesel::serialize::IsNull::No)
+                    }
                 }
-            }
-        });
+            });
+        }
     }
 }
 
 impl EnumVariant {
-    fn gen_from_bytes(&self, rename_rule: RenameRule) -> impl ToTokens {
+    fn gen_from_bytes(&self, has_fields: bool, rename_rule: RenameRule) -> impl ToTokens {
         let Self {
             original_name,
             original_name_span,
             rename,
+            #[cfg(all(feature = "postgres", feature = "json"))]
+            payload,
 
             crate_name,
         } = self;
@@ -258,11 +321,13 @@ impl EnumVariant {
         }
     }
 
-    fn gen_to_byte_str(&self, rename_rule: RenameRule) -> impl ToTokens {
+    fn gen_to_byte_str(&self, has_fields: bool, rename_rule: RenameRule) -> impl ToTokens {
         let Self {
             original_name,
             original_name_span,
             rename,
+            #[cfg(all(feature = "postgres", feature = "json"))]
+            payload,
 
             crate_name: _,
         } = self;

benzina/Cargo.toml

@@ -51,7 +51,7 @@ utoipa = ["dep:utoipa"]
 example-generated = ["typed-uuid"]
 dangerous-construction = ["typed-uuid"]
 
-json = ["postgres", "dep:serde_core", "dep:serde_json", "diesel/serde_json"]
+json = ["postgres", "benzina-derive?/json", "dep:serde_core", "dep:serde_json", "diesel/serde_json"]
 ctid = ["postgres", "diesel/i-implement-a-third-party-backend-and-opt-into-breaking-changes"]
 
 [lints]

benzina/src/__private.rs

@@ -23,6 +23,35 @@ pub fn new_indexmap<K, V>() -> IndexMap<K, V> {
     IndexMap::with_hasher(Hasher::default())
 }
 
+#[cfg(all(feature = "postgres", feature = "json"))]
+pub mod json {
+    use diesel::{
+        deserialize::{FromSql, FromSqlRow},
+        expression::AsExpression,
+        pg::{Pg, PgValue},
+        serialize::ToSql,
+        sql_types,
+    };
+
+    use crate::json::convert::{sql_deserialize_binary_raw, sql_serialize_binary_raw};
+
+    #[derive(Debug, FromSqlRow, AsExpression)]
+    #[diesel(sql_type = sql_types::Jsonb)]
+    pub struct RawJsonb(Box<[u8]>);
+
+    impl FromSql<sql_types::Jsonb, Pg> for RawJsonb {
+        fn from_sql(value: PgValue) -> diesel::deserialize::Result<Self> {
+            sql_deserialize_binary_raw(&value).map(Box::from).map(Self)
+        }
+    }
+
+    impl ToSql<sql_types::Jsonb, Pg> for RawJsonb {
+        fn to_sql(&self, out: &mut diesel::serialize::Output<Pg>) -> diesel::serialize::Result {
+            sql_serialize_binary_raw(&self.0, out)
+        }
+    }
+}
+
 pub mod deep_clone {
     pub trait DeepClone {
         type Output;

benzina/src/json/convert.rs

@@ -55,6 +55,15 @@ where
     sql_serialize(value, out)
 }
 
+pub(crate) fn sql_serialize_binary_raw(
+    value: &[u8],
+    out: &mut diesel::serialize::Output<'_, '_, Pg>,
+) -> diesel::serialize::Result {
+    out.write_all(&[1])?;
+    out.write_all(value)?;
+    Ok(IsNull::No)
+}
+
 pub(super) fn sql_deserialize<T>(value: PgValue<'_>) -> diesel::deserialize::Result<T>
 where
     T: DeserializeOwned,
@@ -66,6 +75,13 @@ pub(super) fn sql_deserialize_binary<T>(value: PgValue<'_>) -> diesel::deseriali
 where
     T: DeserializeOwned,
 {
+    let bytes = sql_deserialize_binary_raw(&value)?;
+    serde_json::from_slice(bytes).map_err(Into::into)
+}
+
+pub(crate) fn sql_deserialize_binary_raw<'a>(
+    value: &'a PgValue<'_>,
+) -> diesel::deserialize::Result<&'a [u8]> {
     let (version, bytes) = value
         .as_bytes()
         .split_first()
@@ -75,5 +91,5 @@ where
         return Err("Unsupported JSONB encoding version".into());
     }
 
-    serde_json::from_slice(bytes).map_err(Into::into)
+    Ok(bytes)
 }