gurafi-macros 0.1.0

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

use std::collections::HashSet;

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

pub fn expand(input: DeriveInput) -> syn::Result<TokenStream> {
    if !input.generics.params.is_empty() {
        return Err(syn::Error::new_spanned(
            &input.generics,
            "`#[derive(ErrorUnion)]` does not support generic types. Use a concrete error enum \
             and, if needed, make the generated error payload a concrete object model.",
        ));
    }
    let Data::Enum(data) = &input.data else {
        return Err(syn::Error::new_spanned(
            &input.ident,
            "`#[derive(ErrorUnion)]` can only be used on an enum whose variants each hold one \
             error payload object.",
        ));
    };
    if data.variants.is_empty() {
        return Err(syn::Error::new_spanned(
            &input.ident,
            "an error union must have at least one variant, so the result union has an error \
             member besides its success payload",
        ));
    }

    let ident = &input.ident;
    let mut seen = HashSet::new();
    let mut variants = Vec::new();
    for variant in &data.variants {
        let payload = match &variant.fields {
            Fields::Unnamed(fields) if fields.unnamed.len() == 1 => &fields.unnamed[0].ty,
            Fields::Unnamed(_) => {
                return Err(syn::Error::new_spanned(
                    &variant.fields,
                    "every `#[derive(ErrorUnion)]` variant must hold exactly one error payload \
                     object, for example `NotFound(NotFoundError)`; tuple variants with zero or \
                     several fields are not supported",
                ));
            }
            Fields::Named(_) => {
                return Err(syn::Error::new_spanned(
                    &variant.fields,
                    "`#[derive(ErrorUnion)]` does not support struct variants. Use a newtype \
                     variant holding one error payload object, for example \
                     `NotFound(NotFoundError)`",
                ));
            }
            Fields::Unit => {
                return Err(syn::Error::new_spanned(
                    &variant.fields,
                    "every `#[derive(ErrorUnion)]` variant must hold an error payload object; \
                     unit variants have no GraphQL object type to use as a union member",
                ));
            }
        };
        let key = payload.to_token_stream().to_string();
        if !seen.insert(key) {
            return Err(syn::Error::new_spanned(
                payload,
                "the same error payload type appears in more than one variant; a GraphQL union \
                 cannot include the same object type twice",
            ));
        }
        variants.push((variant.ident.clone(), payload.clone()));
    }

    let members = variants
        .iter()
        .map(|(_, payload)| quote!(<#payload as ::gurafi::ObjectModel>::NAME));
    let converters = variants.iter().map(
        |(variant, _)| quote!(Self::#variant(value) => ::gurafi::IntoValue::into_value(value)),
    );

    Ok(quote! {
        const _: () = {
            #[automatically_derived]
            impl ::gurafi::ErrorUnionModel for #ident {
                fn members() -> &'static [&'static str] {
                    &[#(#members),*]
                }

                fn into_value(
                    self,
                ) -> ::core::result::Result<
                    ::gurafi::gql::Value,
                    ::gurafi::gql::GraphQLError,
                > {
                    match self {
                        #(#converters),*
                    }
                }
            }
        };
    })
}

#[cfg(test)]
mod tests {
    use syn::parse_quote;

    use super::expand;

    fn message(input: syn::DeriveInput) -> String {
        expand(input)
            .expect_err("macro should reject the input")
            .to_string()
    }

    #[test]
    fn generic_enums_are_rejected() {
        let message = message(parse_quote! {
            enum CreateUserError<T> {
                NotFound(T),
            }
        });
        assert!(
            message.contains("does not support generic types"),
            "{message}"
        );
    }

    #[test]
    fn structs_are_rejected() {
        let message = message(parse_quote! {
            struct CreateUserError;
        });
        assert!(message.contains("only be used on an enum"), "{message}");
    }

    #[test]
    fn unit_variants_are_rejected() {
        let message = message(parse_quote! {
            enum CreateUserError {
                NotFound,
            }
        });
        assert!(message.contains("unit variants"), "{message}");
    }

    #[test]
    fn struct_variants_are_rejected() {
        let message = message(parse_quote! {
            enum CreateUserError {
                NotFound { message: String },
            }
        });
        assert!(message.contains("struct variants"), "{message}");
    }

    #[test]
    fn tuple_variants_must_hold_one_field() {
        let message = message(parse_quote! {
            enum CreateUserError {
                NotFound(String, String),
            }
        });
        assert!(message.contains("exactly one error payload"), "{message}");
    }

    #[test]
    fn duplicate_payloads_are_rejected() {
        let message = message(parse_quote! {
            enum CreateUserError {
                NotFound(NotFoundError),
                AlsoNotFound(NotFoundError),
            }
        });
        assert!(message.contains("same error payload type"), "{message}");
    }

    #[test]
    fn an_empty_enum_is_rejected() {
        let message = message(parse_quote! {
            enum CreateUserError {}
        });
        assert!(message.contains("at least one variant"), "{message}");
    }
}