dynamic-graphql-derive 0.10.2

Dynamic GraphQL schema macro
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use proc_macro2::TokenStream;
use quote::quote;

use crate::utils::common::CommonInterfaceAttrs;
use crate::utils::common::CommonObject;
use crate::utils::crate_name::get_crate_name;
use crate::utils::error::IntoTokenStream;
use crate::utils::interface_attr::InterfaceImplAttr;

pub fn get_register_interface_code(
    obj: &impl CommonInterfaceAttrs,
) -> darling::Result<TokenStream> {
    let mut paths = Vec::new();
    obj.get_marks().iter().for_each(|mark| {
        paths.push(mark.path.clone());
    });
    obj.get_impls().iter().for_each(|impl_attr| {
        paths.push(impl_attr.path.clone());
    });
    let codes: Vec<_> = paths
        .iter()
        .map(|path| {
            quote! {
                let registry = registry.register::<dyn #path>();
            }
        })
        .collect();
    Ok(quote! {
        #(#codes)*
    })
}

pub fn get_interface_mark_code(obj: &impl CommonInterfaceAttrs) -> darling::Result<TokenStream> {
    let crate_name = get_crate_name();
    let implements: Vec<TokenStream> = obj
        .get_marks()
        .iter()
        .map(|interface| {
            let path = &interface.path;
            quote! {
                let object = object.implement(<dyn #path as #crate_name::internal::Interface>::get_interface_type_name());
            }
        })
        .collect();
    Ok(quote! {
        #(#implements)*
    })
}

pub fn get_add_implement_code(
    object: &impl CommonObject,
    implement: &[InterfaceImplAttr],
) -> darling::Result<TokenStream> {
    if implement.is_empty() {
        return Ok(quote! {});
    }
    let crate_name = get_crate_name();
    let object_type = object.get_type()?;

    let (_, ty_generics, _) = object.get_generics()?.split_for_impl();

    let implements: Vec<TokenStream> = implement
        .iter()
        .map(|interface| {
            let path = &interface.path;
            let ty = quote!(#crate_name::Instance<dyn #path, #object_type #ty_generics>);
            Ok(quote! {
                let registry = registry.register::<#ty>();
            })
        })
        .map(|x| x.into_token_stream())
        .collect();
    Ok(quote! {
        #(#implements)*
    })
}

pub fn impl_interface_mark(object: &impl CommonInterfaceAttrs) -> darling::Result<TokenStream> {
    let crate_name = get_crate_name();
    let object_ident = object.get_ident();
    let marks: Vec<_> = object
        .get_marks()
        .iter()
        .map(|interface| {
            let path = &interface.path;
            quote! {
                impl #crate_name::internal::InterfaceMark<dyn #path> for #object_ident {}
            }
        })
        .collect();

    let mark_implement: Vec<_> = object
        .get_impls()
        .iter()
        .map(|interface| {
            let path = &interface.path;
            quote! {
                impl #crate_name::internal::InterfaceMark<dyn #path> for #object_ident {}
            }
        })
        .collect();

    Ok(quote! {
        #(#marks)*
        #(#mark_implement)*
    })
}