graphql-query 1.0.1

Stupendously fast and easy GraphQL Query Language handling.
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141


use bumpalo::{collections::Vec, Bump};
use hashbrown::{hash_map::DefaultHashBuilder, HashMap};

use crate::{ast::DefaultIn, schema::{SchemaEnum, SchemaScalar}};

#[derive(Debug, Clone, Copy)]
pub(super) struct SchemaDefinition<'a> {
    pub(super) query_root_type_name: Option<&'a str>,
    pub(super) mutation_root_type_name: Option<&'a str>,
    pub(super) subscription_root_type_name: Option<&'a str>,
}

/// https://github.com/graphql/graphql-spec/blob/main/spec/Section%203%20--%20Type%20System.md#types
#[derive(Debug, Clone)]
pub(super) enum TypeDefinition<'a> {
    ObjectTypeDefinition(SchemaObjectPlaceholder<'a>),
    InputObjectTypeDefinition(SchemaInputObjectPlaceholder<'a>),
    EnumTypeDefinition(SchemaEnum<'a>),
    ScalarTypeDefinition(SchemaScalar<'a>),
    InterfaceTypeDefinition(SchemaInterfacePlaceholder<'a>),
    UnionTypeDefinition(SchemaUnionPlaceholder<'a>),
}

// https://github.com/graphql/graphql-spec/blob/main/spec/Section%203%20--%20Type%20System.md#directives
// #[derive(Debug, Clone)]
// pub(super) enum DirectiveDefinition<'a> {
//     DirectiveDefinition(&'a str),
// }

impl<'a> TypeDefinition<'a> {
    pub(crate) fn name(&self) -> &'a str {
        match self {
            TypeDefinition::ObjectTypeDefinition(obj) => obj.name,
            TypeDefinition::InputObjectTypeDefinition(obj) => obj.name,
            TypeDefinition::EnumTypeDefinition(e) => e.name,
            TypeDefinition::ScalarTypeDefinition(s) => s.name,
            TypeDefinition::InterfaceTypeDefinition(i) => i.name,
            TypeDefinition::UnionTypeDefinition(u) => u.name,
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub(super) struct SchemaObjectPlaceholder<'a> {
    pub name: &'a str,
    pub fields: FieldDefinitions<'a>,
    pub(crate) interfaces: Vec<'a, &'a str>,
}

#[derive(Debug, Clone, PartialEq)]
pub(super) struct SchemaInputObjectPlaceholder<'a> {
    pub name: &'a str,
    pub fields: InputFieldDefinitions<'a>,
}

#[derive(Debug, Clone, PartialEq)]
pub(super) struct SchemaInterfacePlaceholder<'a> {
    pub name: &'a str,
    pub fields: FieldDefinitions<'a>,
    pub(crate) interfaces: Vec<'a, &'a str>,
    pub(crate) possible_types: Vec<'a, &'a str>,
    pub(crate) possible_interfaces: Vec<'a, &'a str>,
}

impl<'a> SchemaInterfacePlaceholder<'a> {
    pub fn add_possible_type(&mut self, possible_type: &'a str) {
        self.possible_types.push(possible_type);
    }

    pub fn add_possible_interface(&mut self, possible_type: &'a str) {
        self.possible_interfaces.push(possible_type);
    }
}

#[derive(Debug, Clone, PartialEq)]
pub(super) struct SchemaUnionPlaceholder<'a> {
    pub name: &'a str,
    pub(crate) types: Vec<'a, &'a str>,
}

/// A sequence of schema fields enclosed by braces, as found on object types, interfaces, etc.
#[derive(Debug, Clone, PartialEq)]
pub(super) struct FieldDefinitions<'a> {
    pub fields: HashMap<&'a str, SchemaFieldPlaceholder<'a>, DefaultHashBuilder, &'a Bump>,
}

impl<'a> DefaultIn<'a> for FieldDefinitions<'a> {
  fn default_in(bump: &'a Bump) -> Self {
      Self {
          fields: HashMap::new_in(bump),
      }
  }
}

/// A sequence of schema fields enclosed by braces, as found on object types, interfaces, etc.
#[derive(Debug, Clone, PartialEq)]
pub(super) struct InputFieldDefinitions<'a> {
    pub fields: HashMap<&'a str, SchemaInputFieldPlaceholder<'a>, DefaultHashBuilder, &'a Bump>,
}

impl<'a> DefaultIn<'a> for InputFieldDefinitions<'a> {
  fn default_in(bump: &'a Bump) -> Self {
      Self {
          fields: HashMap::new_in(bump),
      }
  }
}

#[derive(Debug, Clone, PartialEq)]
pub(super) struct ArgumentList<'a> {
    pub arguments: HashMap<&'a str, SchemaInputFieldPlaceholder<'a>, DefaultHashBuilder, &'a Bump>,
}

impl<'a> DefaultIn<'a> for ArgumentList<'a> {
    fn default_in(bump: &'a Bump) -> Self {
        Self {
            arguments: HashMap::new_in(bump),
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub(super) struct SchemaFieldPlaceholder<'a> {
    pub name: &'a str,
    pub arguments: ArgumentList<'a>,
    pub output_type: &'a TypeWrapper<'a>,
}

#[derive(Debug, Clone, PartialEq)]
pub(super) struct SchemaInputFieldPlaceholder<'a> {
    pub name: &'a str,
    pub input_type: &'a TypeWrapper<'a>,
}

#[derive(Debug, Clone, PartialEq)]
pub(super) enum TypeWrapper<'a> {
    NonNull(&'a TypeWrapper<'a>),
    List(&'a TypeWrapper<'a>),
    Named(&'a str),
}