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

use std::collections::HashMap;

use crate::{schema, FieldType, Ident, TypeIndex};

pub struct Schema {
    pub objects: HashMap<Ident, Object>,
}

impl From<schema::Document> for Schema {
    fn from(document: schema::Document) -> Self {
        use schema::{Definition, TypeDefinition};

        let type_index = TypeIndex::for_schema(&document);

        let mut objects = HashMap::new();

        for definition in &document.definitions {
            match definition {
                Definition::TypeDefinition(TypeDefinition::Object(object)) => {
                    let object = Object::from_object(object, &type_index);
                    objects.insert(object.name.clone(), object);
                }
                Definition::TypeDefinition(TypeDefinition::Interface(iface)) => {
                    let object = Object::from_interface(iface, &type_index);
                    objects.insert(object.name.clone(), object);
                }
                _ => {}
            }
        }

        Schema { objects }
    }
}

pub struct Object {
    pub selector_struct: Ident,
    pub fields: HashMap<Ident, Field>,
    pub name: Ident,
}

impl Object {
    fn from_interface(iface: &schema::InterfaceType, scalar_names: &TypeIndex) -> Object {
        Object {
            selector_struct: Ident::for_type(&iface.name),
            fields: iface
                .fields
                .iter()
                .map(|f| Field::from_field(f, scalar_names))
                .map(|f| (f.name.clone(), f))
                .collect(),
            name: Ident::for_type(&iface.name),
        }
    }

    fn from_object(obj: &schema::ObjectType, scalar_names: &TypeIndex) -> Object {
        Object {
            selector_struct: Ident::for_type(&obj.name),
            fields: obj
                .fields
                .iter()
                .map(|f| Field::from_field(f, scalar_names))
                .map(|f| (f.name.clone(), f))
                .collect(),
            name: Ident::for_type(&obj.name),
        }
    }
}

#[derive(Debug)]
pub struct Field {
    pub arguments: Vec<Argument>,
    pub name: Ident,
    pub field_type: FieldType,
}

impl Field {
    fn from_field(field: &schema::Field, type_index: &TypeIndex) -> Field {
        Field {
            name: Ident::for_field(&field.name),
            field_type: FieldType::from_schema_type(&field.field_type, type_index),
            arguments: field
                .arguments
                .iter()
                .map(|a| Argument::from_input_value(a, type_index))
                .collect(),
        }
    }
}

#[derive(Debug)]
pub struct Argument {
    pub name: Ident,
    pub required: bool,
}

impl Argument {
    fn from_input_value(value: &schema::InputValue, type_index: &TypeIndex) -> Argument {
        let argument_type = FieldType::from_schema_type(&value.value_type, type_index);
        Argument {
            name: Ident::for_field(&value.name),
            required: !argument_type.is_nullable(),
        }
    }
}