taler-rust

lib.rs (18579B)

---

 /*
   This file is part of TALER
   Copyright (C) 2026 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.
 
   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
 
   You should have received a copy of the GNU Affero General Public License along with
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use proc_macro::TokenStream;
 use quote::quote;
 use syn::{
     Data, DeriveInput, Error, Expr, Field, Fields, ItemStruct, Lit, LitStr, Meta, parse::Parser,
     parse_macro_input,
 };
 
 #[proc_macro_derive(EnumMeta, attributes(enum_meta, code))]
 pub fn derive_domain_code(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
     let name = &input.ident;
 
     // Parse features
     let mut enabled_doc = false;
     let mut enabled_domain_code = false;
     let mut enabled_str = false;
 
     for attr in &input.attrs {
         if attr.path().is_ident("enum_meta")
             && let Err(e) = attr.parse_nested_meta(|meta| {
                 if meta.path.is_ident("Description") {
                     enabled_doc = true;
                 } else if meta.path.is_ident("DomainCode") {
                     enabled_domain_code = true;
                 } else if meta.path.is_ident("Str") {
                     enabled_str = true;
                 } else {
                     return Err(meta.error("unknown enum_meta option"));
                 }
                 Ok(())
             })
         {
             return e.to_compile_error().into();
         }
     }
 
     let repr_type = input.attrs.iter().find_map(|attr| {
         if !attr.path().is_ident("repr") {
             return None;
         }
         let mut found = None;
         attr.parse_nested_meta(|it| {
             found = it.path.get_ident().cloned();
             Ok(())
         })
         .unwrap();
         found
     });
 
     let variants = if let Data::Enum(data) = &input.data {
         &data.variants
     } else {
         return Error::new(input.ident.span(), "EnumMeta only supports enums")
             .to_compile_error()
             .into();
     };
 
     // Helper: extract the first string literal from a name-value attribute.
     let extract_str_attr = |variant: &syn::Variant, ident: &str| -> Option<String> {
         variant.attrs.iter().find_map(|a| {
             if a.path().is_ident(ident)
                 && let Meta::NameValue(nv) = &a.meta
                 && let Expr::Lit(expr) = &nv.value
                 && let Lit::Str(s) = &expr.lit
             {
                 Some(s.value())
             } else {
                 None
             }
         })
     };
 
     let mut entries = Vec::new();
     let mut description_arms = Vec::new();
     let mut code_arms = Vec::new();
     let mut from_str_arms = Vec::new();
     let mut as_ref_arms = Vec::new();
     let mut try_from_arms = Vec::new();
 
     for variant in variants {
         let v_ident = &variant.ident;
         let v_str = variant
             .attrs
             .iter()
             .find_map(|attr| {
                 if attr.path().is_ident("enum_meta") {
                     let mut res = None;
                     let _ = attr.parse_nested_meta(|meta| {
                         if meta.path.is_ident("rename") {
                             let value: LitStr = meta.value()?.parse()?;
                             res = Some(value.value());
                         }
                         Ok(())
                     });
                     res
                 } else {
                     None
                 }
             })
             .unwrap_or_else(|| v_ident.to_string());
 
         if repr_type.is_some() {
             if let Some((_, discriminant)) = &variant.discriminant {
                 try_from_arms.push(quote! { #discriminant => Ok(Self::#v_ident) });
             } else {
                 return Error::new(v_ident.span(), "missing discriminant expression")
                     .to_compile_error()
                     .into();
             };
         }
 
         // Single pass: collect doc and code in one go, then use what's needed.
         let doc =
             enabled_doc.then(|| extract_str_attr(variant, "doc").map(|s| s.trim().to_string()));
         let code = (enabled_domain_code).then(|| extract_str_attr(variant, "code"));
 
         if let Some(doc) = doc {
             let doc = match doc {
                 Some(d) => d,
                 None => {
                     return Error::new(
                         v_ident.span(),
                         format!("variant `{v_str}` is missing `/// documentation`"),
                     )
                     .to_compile_error()
                     .into();
                 }
             };
             description_arms.push(quote! { Self::#v_ident => #doc });
         }
 
         if let Some(code) = code {
             let code = match code {
                 Some(c) => c,
                 None => {
                     return Error::new(
                         v_ident.span(),
                         format!("variant `{v_str}` is missing `#[code = \"...\"]`"),
                     )
                     .to_compile_error()
                     .into();
                 }
             };
             from_str_arms.push(quote! { #code => Ok(Self::#v_ident) });
             code_arms.push(quote! { Self::#v_ident => #code });
         } else if enabled_str {
             from_str_arms.push(quote! { #v_str => Ok(Self::#v_ident) });
         }
 
         if enabled_str {
             as_ref_arms.push(quote! { Self::#v_ident => #v_str });
         }
         entries.push(quote! { Self::#v_ident, });
     }
 
     let mut expanded = quote! {
         impl #name {
             /// Returns a slice of all enum variants.
             pub const entries: &'static [Self] = &[#(#entries)*];
         }
     };
 
     if enabled_doc {
         expanded.extend(quote! {
             impl #name {
                 /// Returns the documentation description associated
                 pub fn description(&self) -> &'static str {
                     match self { #(#description_arms),* }
                 }
             }
         });
     }
 
     if enabled_domain_code {
         expanded.extend(quote! {
             impl #name {
                 /// Returns the domain code associated
                 pub fn code(&self) -> &'static str {
                     match self { #(#code_arms),* }
                 }
             }
         });
     }
 
     if enabled_str {
         expanded.extend(quote! {
             impl AsRef<str> for #name {
                 fn as_ref(&self) -> &str {
                     match self { #(#as_ref_arms),* }
                 }
             }
 
             impl std::fmt::Display for #name {
                 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                     f.write_str(self.as_ref())
                 }
             }
         });
     }
 
     if enabled_domain_code || enabled_str {
         let unknown_label = if enabled_domain_code { "code" } else { "name" };
         expanded.extend(quote! {
             impl std::str::FromStr for #name {
                 type Err = String;
                 fn from_str(s: &str) -> Result<Self, Self::Err> {
                     match s {
                         #(#from_str_arms,)*
                         _ => Err(format!("Unknown {0} for {1}: {2}", #unknown_label, stringify!(#name), s))
                     }
                 }
             }
         });
     }
 
     if let Some(repr) = repr_type {
         expanded.extend(quote! {
             impl TryFrom<#repr> for #name {
                 type Error = #repr;
                 fn try_from(value: #repr) -> Result<Self, Self::Error> {
                     match value {
                         #(#try_from_arms,)*
                         _ => Err(value),
                     }
                 }
             }
         });
     }
 
     TokenStream::from(expanded)
 }
 
 #[proc_macro_attribute]
 pub fn api_config(attr: TokenStream, item: TokenStream) -> TokenStream {
     // 1. Cleanly parse the string attribute argument
     let api_name_lit = parse_macro_input!(attr as LitStr);
     let api_name_value = api_name_lit.value();
 
     // 2. Parse the target struct
     let mut input_struct = parse_macro_input!(item as ItemStruct);
     let struct_name = &input_struct.ident;
 
     // 3. Generate deterministic function names for serialization AND deserialization
     let struct_lower = struct_name.to_string().to_lowercase();
     let serialize_fn_ident = syn::Ident::new(
         &format!("_serialize_api_name_for_{}", struct_lower),
         proc_macro2::Span::call_site(),
     );
     let deserialize_fn_ident = syn::Ident::new(
         &format!("_deserialize_api_name_for_{}", struct_lower),
         proc_macro2::Span::call_site(),
     );
 
     // 4. Convert identifiers to string paths for Serde attributes
     let serialize_fn_str = serialize_fn_ident.to_string();
     let deserialize_fn_str = deserialize_fn_ident.to_string();
 
     let crate_path = if std::env::var("CARGO_CRATE_NAME").unwrap_or_default() == "taler_common" {
         quote! { crate }
     } else {
         quote! { ::taler_common }
     };
 
     // 5. Inject the `name` field with BOTH serialization and deserialization hooks
     if let Fields::Named(ref mut fields) = input_struct.fields {
         fields.named.insert(
             0,
             Field::parse_named
                 .parse2(quote! {
                     #[serde(
                         serialize_with = #serialize_fn_str,
                         deserialize_with = #deserialize_fn_str
                     )]
                     pub name: ()
                 })
                 .unwrap(),
         );
         fields.named.insert(
             1,
             Field::parse_named
                 .parse2(quote! {
                     pub version: #crate_path::api::LibtoolVersion
                 })
                 .unwrap(),
         );
         fields.named.insert(
             2,
             Field::parse_named
                 .parse2(quote! {
                     pub implementation: Option<&'a str>
                 })
                 .unwrap(),
         );
     } else {
         return syn::Error::new_spanned(
             input_struct,
             "#[api_config] only works on structs with named fields",
         )
         .to_compile_error()
         .into();
     }
 
     let expanded = quote! {
         #input_struct
 
         #[doc(hidden)]
         #[allow(non_snake_case)]
         pub fn #serialize_fn_ident<S>(_: &(), s: S) -> ::std::result::Result<S::Ok, S::Error>
         where
             S: ::serde::Serializer
         {
             s.serialize_str(#api_name_value)
         }
 
         #[doc(hidden)]
         #[allow(non_snake_case)]
         pub fn #deserialize_fn_ident<'de, D>(deserializer: D) -> ::std::result::Result<(), D::Error>
         where
             D: ::serde::Deserializer<'de>,
         {
             let s: ::std::string::String = ::serde::Deserialize::deserialize(deserializer)?;
             if s == #api_name_value {
                 Ok(())
             } else {
                 Err(::serde::de::Error::custom(::std::format!(
                     "invalid API name: expected '{}', found '{}'",
                     #api_name_value, s
                 )))
             }
         }
     };
 
     TokenStream::from(expanded)
 }
 
 /// Run an async database test with a pool initialized from `crate::CONFIG_SOURCE`.
 ///
 /// An explicit config expression can override the default. Components without
 /// installed configuration can use `#[db_test(sql_dir = "db", component = "name")]`.
 /// Use `#[db_test(raw)]` to reserve a database without initializing schemas; its
 /// argument is `PgConnectOptions` instead of `PgPool`.
 /// Initialized tests can take a `PgPool`, a `PoolConnection<Postgres>`, a
 /// `PgConnection`, or `&mut PgConnection`. A pool and a connection may be combined
 /// in either order. The function must return `()` or `Result<(), E>`.
 /// Do not combine this attribute with `#[test]` or `#[tokio::test]`.
 #[proc_macro_attribute]
 pub fn db_test(attr: TokenStream, item: TokenStream) -> TokenStream {
     let input = parse_macro_input!(item as syn::ItemFn);
     match expand_db_test(attr.into(), input) {
         Ok(tokens) => tokens.into(),
         Err(error) => error.to_compile_error().into(),
     }
 }
 
 fn expand_db_test(
     attr: proc_macro2::TokenStream,
     input: syn::ItemFn,
 ) -> syn::Result<proc_macro2::TokenStream> {
     let sig = &input.sig;
     if sig.asyncness.is_none()
         || !(1..=2).contains(&sig.inputs.len())
         || !sig.generics.params.is_empty()
         || sig.generics.where_clause.is_some()
         || sig.constness.is_some()
         || !matches!(sig.safety, syn::Safety::Default)
         || sig.abi.is_some()
         || sig.variadic.is_some()
         || sig
             .inputs
             .iter()
             .any(|arg| matches!(arg, syn::FnArg::Receiver(_)))
     {
         return Err(Error::new_spanned(
             sig,
             "db_test requires an async function with one or two database arguments and no generics",
         ));
     }
     for attr in &input.attrs {
         if attr
             .path()
             .segments
             .last()
             .is_some_and(|s| s.ident == "test")
         {
             return Err(Error::new_spanned(
                 attr,
                 "db_test supplies the test attribute; remove the other test attribute",
             ));
         }
     }
 
     let name = &sig.ident;
     let callback = || -> syn::Result<proc_macro2::TokenStream> {
         let mut has_pool = false;
         let mut has_conn = false;
         let mut args = Vec::new();
         for arg in &sig.inputs {
             let syn::FnArg::Typed(arg) = arg else {
                 unreachable!()
             };
             let (ty, borrowed) = match arg.ty.as_ref() {
                 syn::Type::Reference(reference) if reference.mutability.is_some() => {
                     (reference.elem.as_ref(), true)
                 }
                 ty => (ty, false),
             };
             let ident = match ty {
                 syn::Type::Path(path) => path.path.segments.last().map(|s| &s.ident),
                 _ => None,
             };
             let (slot, value) = match ident {
                 Some(ident) if ident == "PgPool" && !borrowed => {
                     (&mut has_pool, quote! { __taler_pool })
                 }
                 Some(ident) if ident == "PoolConnection" && !borrowed => {
                     (&mut has_conn, quote! { __taler_conn })
                 }
                 Some(ident) if ident == "PgConnection" => (
                     &mut has_conn,
                     if borrowed {
                         quote! { &mut *__taler_conn }
                     } else {
                         quote! { __taler_conn.detach() }
                     },
                 ),
                 _ => {
                     return Err(Error::new_spanned(
                         &arg.ty,
                         "expected PgPool, PoolConnection<Postgres>, PgConnection, or &mut PgConnection",
                     ));
                 }
             };
             if std::mem::replace(slot, true) {
                 return Err(Error::new_spanned(
                     &arg.ty,
                     "expected at most one pool and one connection",
                 ));
             }
             args.push(value);
         }
         let acquire = has_conn.then(|| quote! {
             let mut __taler_conn = __taler_pool.acquire().await
                 .unwrap_or_else(|e| panic!("{}: acquire test connection: {e}", __taler_test_name));
         });
         Ok(quote! {
             async |__taler_pool: ::sqlx::PgPool| {
                 #acquire
                 #name(#(#args),*).await
             }
         })
     };
     let runner = (|input: syn::parse::ParseStream<'_>| {
         if input.peek(syn::Ident) && input.peek2(syn::Token![=]) {
             let mut sql_dir = None;
             let mut component = None;
             while !input.is_empty() {
                 let key: syn::Ident = input.parse()?;
                 input.parse::<syn::Token![=]>()?;
                 let value: Expr = input.parse()?;
                 let slot = match key.to_string().as_str() {
                     "sql_dir" => &mut sql_dir,
                     "component" => &mut component,
                     _ => return Err(Error::new(key.span(), "expected sql_dir or component")),
                 };
                 if slot.replace(value).is_some() {
                     return Err(Error::new(key.span(), "duplicate db_test option"));
                 }
                 if !input.is_empty() {
                     input.parse::<syn::Token![,]>()?;
                 }
             }
             let sql_dir = sql_dir.ok_or_else(|| input.error("missing sql_dir"))?;
             let component = component.ok_or_else(|| input.error("missing component"))?;
             let callback = callback()?;
             return Ok(quote! {
                 ::taler_test_utils::db::run_db_test_manual(
                     ::std::path::Path::new(#sql_dir), #component, __taler_test_name, #callback
                 )
             });
         }
         let source: Expr = if input.is_empty() {
             syn::parse_quote!(crate::constants::CONFIG_SOURCE)
         } else {
             input.parse()?
         };
         if matches!(&source, Expr::Path(path) if path.path.is_ident("raw")) {
             if sig.inputs.len() != 1 {
                 return Err(Error::new_spanned(
                     sig,
                     "raw db_test requires one PgConnectOptions argument",
                 ));
             }
             Ok(quote! {
                 ::taler_test_utils::db::run_db_test_raw(__taler_test_name, #name)
             })
         } else {
             let callback = callback()?;
             Ok(quote! {
                 ::taler_test_utils::db::run_db_test(#source, __taler_test_name, #callback)
             })
         }
     })
     .parse2(attr)?;
     let output = &sig.output;
     let attrs = &input.attrs;
     let vis = &input.vis;
     let body = &input.block;
     Ok(quote! {
         #(#attrs)*
         #[test]
         #vis fn #name() #output {
             #sig #body
             let __taler_test_name = concat!(module_path!(), "::", stringify!(#name));
             #runner
         }
     })
 }