cynic-codegen 0.14.1

Codegen for cynic - a GraphQL query builder & data mapper for Rust
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
108
109
110
111
112
113
114
115
116
117

use proc_macro2::TokenStream;

use super::SelectorStruct;
use crate::{schema, Ident};

#[derive(Debug, PartialEq)]
enum RootType {
    Query,
    Mutation,
    Subscription,
}

#[derive(Debug, PartialEq)]
pub struct SchemaRoot {
    name: Ident,
    ty: RootType,
}

impl SchemaRoot {
    pub fn for_query(name: &Ident) -> Self {
        SchemaRoot {
            name: name.clone(),
            ty: RootType::Query,
        }
    }

    pub fn for_mutation(name: &Ident) -> Self {
        SchemaRoot {
            name: name.clone(),
            ty: RootType::Mutation,
        }
    }

    pub fn for_subscription(name: &Ident) -> Self {
        SchemaRoot {
            name: name.clone(),
            ty: RootType::Subscription,
        }
    }
}

impl quote::ToTokens for SchemaRoot {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        use quote::{quote, TokenStreamExt};

        let name = &self.name;

        tokens.append_all(match self.ty {
            RootType::Mutation => {
                quote! {
                    impl ::cynic::MutationRoot for #name {}
                }
            }
            RootType::Query => {
                quote! {
                    impl ::cynic::QueryRoot for #name {}
                }
            }
            RootType::Subscription => {
                quote! {
                    impl ::cynic::SubscriptionRoot for #name {}
                }
            }
        });
    }
}

pub struct RootTypes {
    query: String,
    mutation: String,
    subscription: Option<String>,
}

impl RootTypes {
    pub fn from_definitions(definitions: &[schema::Definition]) -> RootTypes {
        use schema::Definition;

        let mut rv = RootTypes::default();

        for definition in definitions {
            if let Definition::SchemaDefinition(schema) = definition {
                if let Some(query_type) = &schema.query {
                    rv.query = query_type.clone();
                }
                if let Some(mutation_type) = &schema.mutation {
                    rv.mutation = mutation_type.clone();
                }
                rv.subscription = schema.subscription.clone();
                break;
            }
        }

        rv
    }

    pub fn root_from_selector_struct(&self, selector: &SelectorStruct) -> Option<SchemaRoot> {
        if selector.graphql_name == self.query {
            Some(SchemaRoot::for_query(&selector.name))
        } else if selector.graphql_name == self.mutation {
            Some(SchemaRoot::for_mutation(&selector.name))
        } else if Some(&selector.graphql_name) == self.subscription.as_ref() {
            Some(SchemaRoot::for_subscription(&selector.name))
        } else {
            None
        }
    }
}

impl Default for RootTypes {
    fn default() -> RootTypes {
        RootTypes {
            query: "Query".to_string(),
            mutation: "Mutation".to_string(),
            subscription: None,
        }
    }
}