oak-graphql 0.0.11

GraphQL query language parser with support for modern GraphQL specifications and schema definitions.
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
142
143
144
145
146
147

#![doc = include_str!("readme.md")]
use oak_core::Range;

type SourceSpan = Range<usize>;

/// GraphQL root node.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct GraphQLRoot {
    /// The document node.
    pub document: Document,
}

impl GraphQLRoot {
    /// Creates a new GraphQL root.
    pub fn new(document: Document) -> Self {
        Self { document }
    }
}

/// GraphQL document.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Document {
    /// List of definitions.
    pub definitions: Vec<Definition>,
    /// Source span.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: SourceSpan,
}

impl Document {
    /// Creates a new document with the given span.
    pub fn new(span: SourceSpan) -> Self {
        Self { definitions: Vec::new(), span }
    }

    /// Adds a definition to the document.
    pub fn with_definition(mut self, definition: Definition) -> Self {
        self.definitions.push(definition);
        self
    }
}

/// GraphQL definition.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Definition {
    /// An operation definition.
    Operation(OperationDefinition),
    /// A fragment definition.
    Fragment(FragmentDefinition),
    /// A schema definition.
    Schema(SchemaDefinition),
    /// A type definition.
    Type(TypeDefinition),
}

/// GraphQL operation definition.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct OperationDefinition {
    /// The type of operation.
    pub operation_type: OperationType,
    /// Optional name of the operation.
    pub name: Option<String>,
    /// Source span.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: SourceSpan,
}

impl OperationDefinition {
    /// Creates a new operation definition.
    pub fn new(operation_type: OperationType, span: SourceSpan) -> Self {
        Self { operation_type, name: None, span }
    }

    /// Sets the name of the operation.
    pub fn with_name(mut self, name: impl Into<String>) -> Self {
        self.name = Some(name.into());
        self
    }
}

/// GraphQL operation type.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum OperationType {
    /// A query operation.
    Query,
    /// A mutation operation.
    Mutation,
    /// A subscription operation.
    Subscription,
}

/// GraphQL fragment definition.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct FragmentDefinition {
    /// Name of the fragment.
    pub name: String,
    /// Source span.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: SourceSpan,
}

impl FragmentDefinition {
    /// Creates a new fragment definition.
    pub fn new(name: impl Into<String>, span: SourceSpan) -> Self {
        Self { name: name.into(), span }
    }
}

/// GraphQL schema definition.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SchemaDefinition {
    /// Source span.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: SourceSpan,
}

impl SchemaDefinition {
    /// Creates a new schema definition.
    pub fn new(span: SourceSpan) -> Self {
        Self { span }
    }
}

/// GraphQL type definition.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TypeDefinition {
    /// Name of the type.
    pub name: String,
    /// Source span.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: SourceSpan,
}

impl TypeDefinition {
    /// Creates a new type definition.
    pub fn new(name: impl Into<String>, span: SourceSpan) -> Self {
        Self { name: name.into(), span }
    }
}