gurafi-macros 0.1.0

Procedural macros for gurafi
Documentation
//! `#[derive(Union)]`.

use std::collections::HashSet;

use proc_macro2::TokenStream;
use quote::{ToTokens, quote};
use syn::{Data, DeriveInput, Fields, LitStr};

use crate::util::validate_type_name;

pub fn expand(input: DeriveInput) -> syn::Result<TokenStream> {
    if !input.generics.params.is_empty() {
        return Err(syn::Error::new_spanned(
            &input.generics,
            "`#[derive(Union)]` does not support generic types",
        ));
    }
    let Data::Enum(data) = &input.data else {
        return Err(syn::Error::new_spanned(
            &input.ident,
            "`#[derive(Union)]` can only be used on enums, one unit-like variant per member",
        ));
    };
    if data.variants.is_empty() {
        return Err(syn::Error::new_spanned(
            &input.ident,
            "a GraphQL union must have at least one member",
        ));
    }

    let attrs = crate::attr::parse_type_attrs(&input.attrs)?;
    crate::attr::reject_input_only(&attrs, &input.ident)?;
    let ident = &input.ident;
    let graphql_type_name = attrs
        .name
        .as_ref()
        .map_or_else(|| ident.to_string(), LitStr::value);
    let type_name_literal = attrs
        .name
        .clone()
        .unwrap_or_else(|| LitStr::new(&graphql_type_name, ident.span()));
    validate_type_name(&graphql_type_name, type_name_literal.span())?;

    let mut seen = HashSet::new();
    let mut variants = Vec::new();
    for variant in &data.variants {
        let Fields::Unnamed(fields) = &variant.fields else {
            return Err(syn::Error::new_spanned(
                &variant.fields,
                "every `#[derive(Union)]` variant must hold exactly one object model, for \
                 example `User(User)`",
            ));
        };
        if fields.unnamed.len() != 1 {
            return Err(syn::Error::new_spanned(
                &variant.fields,
                "every `#[derive(Union)]` variant must hold exactly one object model",
            ));
        }
        let member = &fields.unnamed[0].ty;
        let key = member.to_token_stream().to_string();
        if !seen.insert(key) {
            return Err(syn::Error::new_spanned(
                member,
                "the same object type appears in more than one union variant",
            ));
        }
        variants.push((variant.ident.clone(), member.clone()));
    }

    let description = match &attrs.description {
        Some(description) => quote!(Some(#description)),
        None => quote!(None),
    };

    let into_value_arms = variants.iter().map(
        |(variant, _)| quote!(Self::#variant(value) => ::gurafi::IntoValue::into_value(value)),
    );
    let member_registrations = variants
        .iter()
        .map(|(_, member)| quote!(<#member as ::gurafi::OutputType>::register_output(registry);));

    Ok(quote! {
        const _: () = {
            #[automatically_derived]
            impl ::gurafi::UnionModel for #ident {
                const NAME: &'static str = #type_name_literal;

                fn description() -> ::core::option::Option<&'static str> {
                    #description
                }
            }

            #[automatically_derived]
            impl ::gurafi::OutputType for #ident {
                fn output_type() -> ::gurafi::gql::TypeRef {
                    ::gurafi::gql::TypeRef::named(<Self as ::gurafi::UnionModel>::NAME)
                }

                fn register_output(registry: &mut ::gurafi::TypeRegistry) {
                    registry.reference_union(<Self as ::gurafi::UnionModel>::NAME);
                    #(#member_registrations)*
                }
            }

            #[automatically_derived]
            impl ::gurafi::IntoValue for #ident {
                fn into_value(
                    self,
                ) -> ::core::result::Result<
                    ::gurafi::gql::Value,
                    ::gurafi::gql::GraphQLError,
                > {
                    match self {
                        #(#into_value_arms),*
                    }
                }
            }
        };
    })
}