cynic_codegen/scalar_derive/
mod.rs

1use proc_macro2::TokenStream;
2
3pub(crate) mod input;
4
5#[cfg(test)]
6mod tests;
7
8pub use input::ScalarDeriveInput;
9use quote::quote_spanned;
10
11use crate::{generics_for_serde, schema::markers::TypeMarkerIdent};
12
13pub fn scalar_derive(ast: &syn::DeriveInput) -> Result<TokenStream, syn::Error> {
14    use darling::FromDeriveInput;
15
16    match ScalarDeriveInput::from_derive_input(ast) {
17        Ok(input) => scalar_derive_impl(input).or_else(|e| Ok(e.to_compile_error())),
18        Err(e) => Ok(e.write_errors()),
19    }
20}
21
22pub fn scalar_derive_impl(input: ScalarDeriveInput) -> Result<TokenStream, syn::Error> {
23    use quote::quote;
24
25    let schema_module = input.schema_module();
26
27    // We're assuming that Darling has already validated this as a newtype enum,
28    // so we can get away with panicking here.
29    let field = input
30        .data
31        .take_struct()
32        .expect("Expected enum")
33        .into_iter()
34        .next()
35        .expect("Expected enum with one variant");
36
37    let ident = input.ident;
38    let inner_type = field.ty;
39
40    let scalar_name;
41    let scalar_span;
42    match input.graphql_type {
43        Some(graphql_type) => {
44            scalar_span = graphql_type.span();
45            scalar_name = graphql_type.to_string();
46        }
47        None => {
48            scalar_span = ident.span();
49            scalar_name = ident.to_string();
50        }
51    }
52
53    let graphql_type_name = proc_macro2::Literal::string(&scalar_name);
54    let marker_ident = TypeMarkerIdent::with_graphql_name(&scalar_name).to_path(&schema_module);
55    let marker_ident = quote_spanned! { scalar_span => #marker_ident };
56
57    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
58    let generics_with_de = generics_for_serde::with_de_and_deserialize_bounds(&input.generics);
59    let (impl_generics_with_de, _, where_clause_with_de) = generics_with_de.split_for_impl();
60    let generics_with_ser = generics_for_serde::with_serialize_bounds(&input.generics);
61    let (impl_generics_with_ser, _, where_clause_with_ser) = generics_with_ser.split_for_impl();
62
63    Ok(quote! {
64        #[automatically_derived]
65        impl #impl_generics_with_ser cynic::serde::Serialize for #ident #ty_generics #where_clause_with_ser {
66            fn serialize<__S>(&self, serializer: __S) -> Result<__S::Ok, __S::Error>
67            where
68                __S: cynic::serde::Serializer,
69            {
70                <#inner_type as cynic::serde::Serialize>::serialize(&self.0, serializer)
71            }
72        }
73
74        #[automatically_derived]
75        impl #impl_generics_with_de cynic::serde::Deserialize<'de> for #ident #ty_generics #where_clause_with_de {
76            fn deserialize<__D>(deserializer: __D) -> Result<Self, __D::Error>
77            where
78                __D: cynic::serde::Deserializer<'de>,
79            {
80                <#inner_type as cynic::serde::Deserialize<'de>>::deserialize(deserializer).map(Self)
81            }
82        }
83
84        #[automatically_derived]
85        impl #impl_generics cynic::schema::IsScalar<#marker_ident> for #ident #ty_generics #where_clause {
86            type SchemaType = #marker_ident;
87        }
88
89        #[automatically_derived]
90        impl #impl_generics #schema_module::variable::Variable for #ident #ty_generics #where_clause {
91            const TYPE: cynic::variables::VariableType = cynic::variables::VariableType::Named(#graphql_type_name);
92        }
93
94        cynic::impl_coercions!(#ident #ty_generics [#impl_generics] [#where_clause], #marker_ident);
95    })
96}
cynic_codegen/scalar_derive/mod.rs

cynic_codegen/scalar_derive/
mod.rs
