related_entity.rs

#[cfg(feature = "seaography")]
mod private {
    use heck::ToLowerCamelCase;
    use proc_macro2::{Ident, Span, TokenStream};
    use proc_macro_crate::{crate_name, FoundCrate};
    use quote::{quote, quote_spanned};

    use crate::derives::attributes::related_attr;

    enum Error {
        InputNotEnum,
        InvalidEntityPath,
        Syn(syn::Error),
    }

    struct DeriveRelatedEntity {
        entity_ident: TokenStream,
        active_model_ident: TokenStream,
        ident: syn::Ident,
        variants: syn::punctuated::Punctuated<syn::Variant, syn::token::Comma>,
    }

    impl DeriveRelatedEntity {
        fn new(input: syn::DeriveInput) -> Result<Self, Error> {
            let sea_attr = related_attr::SeaOrm::try_from_attributes(&input.attrs)
                .map_err(Error::Syn)?
                .unwrap_or_default();

            let ident = input.ident;
            let entity_ident = match sea_attr.entity.as_ref().map(Self::parse_lit_string) {
                Some(entity_ident) => entity_ident.map_err(|_| Error::InvalidEntityPath)?,
                None => quote! { Entity },
            };
            let active_model_ident =
                match sea_attr.active_model.as_ref().map(Self::parse_lit_string) {
                    Some(active_model_ident) => {
                        active_model_ident.map_err(|_| Error::InvalidEntityPath)?
                    }
                    None => quote! { ActiveModel },
                };

            let variants = match input.data {
                syn::Data::Enum(syn::DataEnum { variants, .. }) => variants,
                _ => return Err(Error::InputNotEnum),
            };

            Ok(DeriveRelatedEntity {
                entity_ident,
                active_model_ident,
                ident,
                variants,
            })
        }

        fn expand(&self) -> syn::Result<TokenStream> {
            let ident = &self.ident;
            let entity_ident = &self.entity_ident;
            let active_model_ident = &self.active_model_ident;

            let get_relation_variant_implementations: Vec<TokenStream> = self
                .variants
                .iter()
                .map(|variant| {
                    let attr = related_attr::SeaOrm::from_attributes(&variant.attrs)?;

                    let enum_name = &variant.ident;

                    let target_entity = attr
                        .entity
                        .as_ref()
                        .map(Self::parse_lit_string)
                        .ok_or_else(|| {
                            syn::Error::new_spanned(variant, "Missing value for 'entity'")
                        })??;

                    let def = match attr.def {
                        Some(def) => Some(Self::parse_lit_string(&def).map_err(|_| {
                            syn::Error::new_spanned(variant, "Missing value for 'def'")
                        })?),
                        None => None,
                    };

                    let name = enum_name.to_string().to_lower_camel_case();

                    if let Some(def) = def {
                        Result::<_, syn::Error>::Ok(quote! {
                            Self::#enum_name => builder.get_relation::<#entity_ident, #target_entity>(#name, #def)
                        })
                    } else {
                        Result::<_, syn::Error>::Ok(quote! {
                            Self::#enum_name => via_builder.get_relation::<#entity_ident, #target_entity>(#name)
                        })
                    }

                })
                .collect::<Result<Vec<_>, _>>()?;

            let get_relation_input_variant_implementations: Vec<TokenStream> = self
                .variants
                .iter()
                .map(|variant| {
                    let attr = related_attr::SeaOrm::from_attributes(&variant.attrs)?;

                    let enum_name = &variant.ident;

                    let target_entity = attr
                        .entity
                        .as_ref()
                        .map(Self::parse_lit_string)
                        .ok_or_else(|| {
                            syn::Error::new_spanned(variant, "Missing value for 'entity'")
                        })??;

                    let def = match attr.def {
                        Some(def) => Some(Self::parse_lit_string(&def).map_err(|_| {
                            syn::Error::new_spanned(variant, "Missing value for 'def'")
                        })?),
                        None => None,
                    };

                    let name = enum_name.to_string().to_lower_camel_case();

                    if let Some(def) = def {
                        Result::<_, syn::Error>::Ok(quote! {
                            Self::#enum_name => builder.get_relation_input::<#entity_ident, #target_entity>(#name, #def)
                        })
                    } else {
                        Result::<_, syn::Error>::Ok(quote! {
                            Self::#enum_name => via_builder.get_relation_input::<#entity_ident, #target_entity>(#name)
                        })
                    }

                })
                .collect::<Result<Vec<_>, _>>()?;

            let insert_related_variant_implementations: Vec<TokenStream> = self
                .variants
                .iter()
                .map(|variant| {
                    let attr = related_attr::SeaOrm::from_attributes(&variant.attrs)?;

                    let enum_name = &variant.ident;

                    let target_entity = attr
                        .entity
                        .as_ref()
                        .map(Self::parse_lit_string)
                        .ok_or_else(|| {
                            syn::Error::new_spanned(variant, "Missing value for 'entity'")
                        })??;


                    let target_active_model = attr.active_model.as_ref().map(Self::parse_lit_string)
                        .ok_or_else(||{
                            syn::Error::new_spanned(variant, "Missing value for 'active_model'")
                        })??;

                    let def = match attr.def {
                        Some(def) => Some(Self::parse_lit_string(&def).map_err(|_| {
                            syn::Error::new_spanned(variant, "Missing value for 'def'")
                        })?),
                        None => None,
                    };

                    let name = enum_name.to_string().to_lower_camel_case();

                    if let Some(def) = def {
                        Result::<_, syn::Error>::Ok(quote! {
                            Self::#enum_name => {
                                if let Some(obj) = input_object.get(#name){
                                    let active_models =
                                        builder.insert_related::<#entity_ident, #active_model_ident, #target_entity, #target_active_model>(#def, &obj, owner)?;
                                    if let Some(active_models) = active_models {
                                        #target_entity::insert_many(active_models).exec(transaction).await?;
                                    }
                                }
                                Ok(())
                            }
                        })
                    } else {
                        Result::<_, syn::Error>::Ok(quote! {
                            Self::#enum_name => {
                                if let Some(obj) = input_object.get(#name) {
                                    let active_models =
                                        via_builder.insert_related::<#entity_ident, #active_model_ident, #target_entity, #target_active_model>(&obj, owner)?;
                                    if let Some(active_models) = active_models {
                                        #target_entity::insert_many(active_models).exec(transaction).await?;
                                    }
                                }
                                Ok(())
                            }
                        })
                    }

                })
                .collect::<Result<Vec<_>, _>>()?;

            // Get the path of the `async-graphql` on the application's Cargo.toml
            let async_graphql_crate = match crate_name("async-graphql") {
                // if found, use application's `async-graphql`
                Ok(FoundCrate::Name(name)) => {
                    let ident = Ident::new(&name, Span::call_site());
                    quote! { #ident }
                }
                Ok(FoundCrate::Itself) => quote! { async_graphql },
                // if not, then use the `async-graphql` re-exported by `seaography`
                Err(_) => quote! { seaography::async_graphql },
            };

            Ok(quote! {
                impl seaography::RelationBuilder for #ident {
                    fn get_relation(&self, context: & 'static seaography::BuilderContext) -> #async_graphql_crate::dynamic::Field {
                        let builder = seaography::EntityObjectRelationBuilder { context };
                        let via_builder = seaography::EntityObjectViaRelationBuilder { context };
                        match self {
                            #(#get_relation_variant_implementations,)*
                            _ => panic!("No relations for this entity"),
                        }
                    }

                    fn get_relation_input(
                        &self,
                        context: &'static seaography::BuilderContext,
                    ) -> #async_graphql_crate::dynamic::InputValue {
                        let builder = seaography::EntityObjectRelationBuilder { context };
                        let via_builder = seaography::EntityObjectViaRelationBuilder { context };
                        match self {
                            #(#get_relation_input_variant_implementations,)*
                            _ => panic!("No relations for this entity"),
                        }
                    }

                    async fn insert_related(
                        &self,
                        context: &'static seaography::BuilderContext,
                        input_object: &#async_graphql_crate::dynamic::ObjectAccessor<'_>,
                        transaction: &sea_orm::DatabaseTransaction,
                        owner: bool,
                    ) ->  #async_graphql_crate::Result<()> {
                        let builder = seaography::EntityObjectRelationBuilder { context };
                        let via_builder = seaography::EntityObjectViaRelationBuilder { context };
                        match self {
                            #(#insert_related_variant_implementations,)*
                            _ => panic!("No relations for this entity"),
                        }

                    }

                }
            })
        }

        fn parse_lit_string(lit: &syn::Lit) -> syn::Result<TokenStream> {
            match lit {
                syn::Lit::Str(lit_str) => lit_str
                    .value()
                    .parse()
                    .map_err(|_| syn::Error::new_spanned(lit, "attribute not valid")),
                _ => Err(syn::Error::new_spanned(lit, "attribute must be a string")),
            }
        }
    }

    /// Method to derive a Related enumeration
    pub fn expand_derive_related_entity(input: syn::DeriveInput) -> syn::Result<TokenStream> {
        let ident_span = input.ident.span();

        match DeriveRelatedEntity::new(input) {
            Ok(model) => model.expand(),
            Err(Error::InputNotEnum) => Ok(quote_spanned! {
                ident_span => compile_error!("you can only derive DeriveRelation on enums");
            }),
            Err(Error::InvalidEntityPath) => Ok(quote_spanned! {
                ident_span => compile_error!("invalid attribute value for 'entity'");
            }),
            Err(Error::Syn(err)) => Err(err),
        }
    }
}

#[cfg(not(feature = "seaography"))]
mod private {
    use proc_macro2::TokenStream;

    pub fn expand_derive_related_entity(_: syn::DeriveInput) -> syn::Result<TokenStream> {
        Ok(TokenStream::new())
    }
}

pub use private::*;