DeriveRelatedEntity use async-graphql re-exported by seaography (#2469)

* DeriveRelatedEntity use `async-graphql` re-exported by `seaography`

* Optionally compile related_entity

* Update mod.rs

* private

---------

Co-authored-by: Chris Tsang <chris.2y3@outlook.com>

sea-orm-macros/Cargo.toml

@@ -23,6 +23,7 @@ syn = { version = "2", default-features = false, features = ["parsing", "proc-ma
 quote = { version = "1", default-features = false }
 heck = { version = "0.4", default-features = false }
 proc-macro2 = { version = "1", default-features = false }
+proc-macro-crate = { version = "3.2.0", optional = true }
 unicode-ident = { version = "1" }
 
 [dev-dependencies]
@@ -34,4 +35,4 @@ default = ["derive"]
 postgres-array = []
 derive = ["bae"]
 strum = []
-seaography = []
+seaography = ["proc-macro-crate"]

sea-orm-macros/src/derives/attributes.rs

@@ -38,6 +38,7 @@ pub mod field_attr {
     }
 }
 
+#[cfg(feature = "seaography")]
 pub mod related_attr {
     use bae::FromAttributes;
 

sea-orm-macros/src/derives/related_entity.rs

@@ -1,22 +1,25 @@
-use heck::ToLowerCamelCase;
+#[cfg(feature = "seaography")]
-use proc_macro2::TokenStream;
+mod private {
-use quote::{quote, quote_spanned};
+    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;
+    use crate::derives::attributes::related_attr;
 
-enum Error {
+    enum Error {
         InputNotEnum,
         InvalidEntityPath,
         Syn(syn::Error),
-}
+    }
 
-struct DeriveRelatedEntity {
+    struct DeriveRelatedEntity {
         entity_ident: TokenStream,
         ident: syn::Ident,
         variants: syn::punctuated::Punctuated<syn::Variant, syn::token::Comma>,
-}
+    }
 
-impl DeriveRelatedEntity {
+    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)?
@@ -82,9 +85,21 @@ impl DeriveRelatedEntity {
                 })
                 .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::dynamic::Field {
+                    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 {
@@ -106,10 +121,10 @@ impl DeriveRelatedEntity {
                 _ => Err(syn::Error::new_spanned(lit, "attribute must be a string")),
             }
         }
-}
+    }
 
-/// Method to derive a Related enumeration
+    /// Method to derive a Related enumeration
-pub fn expand_derive_related_entity(input: syn::DeriveInput) -> syn::Result<TokenStream> {
+    pub fn expand_derive_related_entity(input: syn::DeriveInput) -> syn::Result<TokenStream> {
         let ident_span = input.ident.span();
 
         match DeriveRelatedEntity::new(input) {
@@ -122,4 +137,16 @@ pub fn expand_derive_related_entity(input: syn::DeriveInput) -> syn::Result<Toke
             }),
             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::*;

sea-orm-macros/src/lib.rs

@@ -675,13 +675,9 @@ pub fn derive_relation(input: TokenStream) -> TokenStream {
 #[proc_macro_derive(DeriveRelatedEntity, attributes(sea_orm))]
 pub fn derive_related_entity(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
-    if cfg!(feature = "seaography") {
     derives::expand_derive_related_entity(input)
         .unwrap_or_else(Error::into_compile_error)
         .into()
-    } else {
-        TokenStream::new()
-    }
 }
 
 /// The DeriveMigrationName derive macro will implement `sea_orm_migration::MigrationName` for a migration.