oxirs_gql/
ast.rs

1//! GraphQL Abstract Syntax Tree (AST) definitions
2//!
3//! This module contains the AST node types for representing GraphQL documents.
4
5use serde::{Deserialize, Serialize};
6use std::collections::HashMap;
7
8/// A GraphQL document containing executable definitions
9#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10pub struct Document {
11    pub definitions: Vec<Definition>,
12}
13
14/// Top-level GraphQL definition
15#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
16pub enum Definition {
17    Operation(OperationDefinition),
18    Fragment(FragmentDefinition),
19    Schema(SchemaDefinition),
20    Type(TypeDefinition),
21    Directive(DirectiveDefinition),
22    SchemaExtension(SchemaExtension),
23    TypeExtension(TypeExtension),
24}
25
26/// GraphQL operation definition (query, mutation, subscription)
27#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
28pub struct OperationDefinition {
29    pub operation_type: OperationType,
30    pub name: Option<String>,
31    pub variable_definitions: Vec<VariableDefinition>,
32    pub directives: Vec<Directive>,
33    pub selection_set: SelectionSet,
34}
35
36/// GraphQL operation type
37#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
38pub enum OperationType {
39    Query,
40    Mutation,
41    Subscription,
42}
43
44/// Variable definition in operation
45#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
46pub struct VariableDefinition {
47    pub variable: Variable,
48    pub type_: Type,
49    pub default_value: Option<Value>,
50    pub directives: Vec<Directive>,
51}
52
53/// Variable reference
54#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
55pub struct Variable {
56    pub name: String,
57}
58
59/// Selection set containing fields
60#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
61pub struct SelectionSet {
62    pub selections: Vec<Selection>,
63}
64
65/// Field or fragment selection
66#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
67pub enum Selection {
68    Field(Field),
69    InlineFragment(InlineFragment),
70    FragmentSpread(FragmentSpread),
71}
72
73/// Field selection with arguments
74#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
75pub struct Field {
76    pub alias: Option<String>,
77    pub name: String,
78    pub arguments: Vec<Argument>,
79    pub directives: Vec<Directive>,
80    pub selection_set: Option<SelectionSet>,
81}
82
83/// Field argument
84#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
85pub struct Argument {
86    pub name: String,
87    pub value: Value,
88}
89
90/// Fragment definition
91#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
92pub struct FragmentDefinition {
93    pub name: String,
94    pub type_condition: String,
95    pub directives: Vec<Directive>,
96    pub selection_set: SelectionSet,
97}
98
99/// Fragment spread
100#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
101pub struct FragmentSpread {
102    pub fragment_name: String,
103    pub directives: Vec<Directive>,
104}
105
106/// Inline fragment
107#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
108pub struct InlineFragment {
109    pub type_condition: Option<String>,
110    pub directives: Vec<Directive>,
111    pub selection_set: SelectionSet,
112}
113
114/// GraphQL value
115#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
116pub enum Value {
117    Variable(Variable),
118    IntValue(i64),
119    FloatValue(f64),
120    StringValue(String),
121    BooleanValue(bool),
122    NullValue,
123    EnumValue(String),
124    ListValue(Vec<Value>),
125    ObjectValue(HashMap<String, Value>),
126}
127
128/// GraphQL type reference
129#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
130pub enum Type {
131    NamedType(String),
132    ListType(Box<Type>),
133    NonNullType(Box<Type>),
134}
135
136impl Type {
137    pub fn name(&self) -> String {
138        match self {
139            Type::NamedType(name) => name.clone(),
140            Type::ListType(inner) => {
141                let name = inner.name();
142                format!("[{name}]")
143            }
144            Type::NonNullType(inner) => {
145                let name = inner.name();
146                format!("{name}!")
147            }
148        }
149    }
150}
151
152/// Directive application
153#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
154pub struct Directive {
155    pub name: String,
156    pub arguments: Vec<Argument>,
157}
158
159/// Schema definition
160#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
161pub struct SchemaDefinition {
162    pub description: Option<String>,
163    pub directives: Vec<Directive>,
164    pub root_operation_types: Vec<RootOperationTypeDefinition>,
165}
166
167/// Root operation type definition
168#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
169pub struct RootOperationTypeDefinition {
170    pub operation_type: OperationType,
171    pub named_type: String,
172}
173
174/// Type definition
175#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
176pub enum TypeDefinition {
177    Scalar(ScalarTypeDefinition),
178    Object(ObjectTypeDefinition),
179    Interface(InterfaceTypeDefinition),
180    Union(UnionTypeDefinition),
181    Enum(EnumTypeDefinition),
182    InputObject(InputObjectTypeDefinition),
183}
184
185/// Scalar type definition
186#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
187pub struct ScalarTypeDefinition {
188    pub description: Option<String>,
189    pub name: String,
190    pub directives: Vec<Directive>,
191}
192
193/// Object type definition
194#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
195pub struct ObjectTypeDefinition {
196    pub description: Option<String>,
197    pub name: String,
198    pub implements_interfaces: Vec<String>,
199    pub directives: Vec<Directive>,
200    pub fields: Vec<FieldDefinition>,
201}
202
203/// Field definition
204#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
205pub struct FieldDefinition {
206    pub description: Option<String>,
207    pub name: String,
208    pub arguments: Vec<InputValueDefinition>,
209    pub type_: Type,
210    pub directives: Vec<Directive>,
211}
212
213/// Input value definition
214#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
215pub struct InputValueDefinition {
216    pub description: Option<String>,
217    pub name: String,
218    pub type_: Type,
219    pub default_value: Option<Value>,
220    pub directives: Vec<Directive>,
221}
222
223/// Interface type definition
224#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
225pub struct InterfaceTypeDefinition {
226    pub description: Option<String>,
227    pub name: String,
228    pub implements_interfaces: Vec<String>,
229    pub directives: Vec<Directive>,
230    pub fields: Vec<FieldDefinition>,
231}
232
233/// Union type definition
234#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
235pub struct UnionTypeDefinition {
236    pub description: Option<String>,
237    pub name: String,
238    pub directives: Vec<Directive>,
239    pub types: Vec<String>,
240}
241
242/// Enum type definition
243#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
244pub struct EnumTypeDefinition {
245    pub description: Option<String>,
246    pub name: String,
247    pub directives: Vec<Directive>,
248    pub values: Vec<EnumValueDefinition>,
249}
250
251/// Enum value definition
252#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
253pub struct EnumValueDefinition {
254    pub description: Option<String>,
255    pub value: String,
256    pub directives: Vec<Directive>,
257}
258
259/// Input object type definition
260#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
261pub struct InputObjectTypeDefinition {
262    pub description: Option<String>,
263    pub name: String,
264    pub directives: Vec<Directive>,
265    pub fields: Vec<InputValueDefinition>,
266}
267
268/// Directive definition
269#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
270pub struct DirectiveDefinition {
271    pub description: Option<String>,
272    pub name: String,
273    pub arguments: Vec<InputValueDefinition>,
274    pub repeatable: bool,
275    pub locations: Vec<DirectiveLocation>,
276}
277
278/// Directive location
279#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
280pub enum DirectiveLocation {
281    Query,
282    Mutation,
283    Subscription,
284    Field,
285    FragmentDefinition,
286    FragmentSpread,
287    InlineFragment,
288    VariableDefinition,
289    Schema,
290    Scalar,
291    Object,
292    FieldDefinition,
293    ArgumentDefinition,
294    Interface,
295    Union,
296    Enum,
297    EnumValue,
298    InputObject,
299    InputFieldDefinition,
300}
301
302/// Schema extension
303#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
304pub struct SchemaExtension {
305    pub directives: Vec<Directive>,
306    pub root_operation_types: Vec<RootOperationTypeDefinition>,
307}
308
309/// Type extension
310#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
311pub enum TypeExtension {
312    Scalar(ScalarTypeExtension),
313    Object(ObjectTypeExtension),
314    Interface(InterfaceTypeExtension),
315    Union(UnionTypeExtension),
316    Enum(EnumTypeExtension),
317    InputObject(InputObjectTypeExtension),
318}
319
320/// Scalar type extension
321#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
322pub struct ScalarTypeExtension {
323    pub name: String,
324    pub directives: Vec<Directive>,
325}
326
327/// Object type extension
328#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
329pub struct ObjectTypeExtension {
330    pub name: String,
331    pub implements_interfaces: Vec<String>,
332    pub directives: Vec<Directive>,
333    pub fields: Vec<FieldDefinition>,
334}
335
336/// Interface type extension
337#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
338pub struct InterfaceTypeExtension {
339    pub name: String,
340    pub implements_interfaces: Vec<String>,
341    pub directives: Vec<Directive>,
342    pub fields: Vec<FieldDefinition>,
343}
344
345/// Union type extension
346#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
347pub struct UnionTypeExtension {
348    pub name: String,
349    pub directives: Vec<Directive>,
350    pub types: Vec<String>,
351}
352
353/// Enum type extension
354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
355pub struct EnumTypeExtension {
356    pub name: String,
357    pub directives: Vec<Directive>,
358    pub values: Vec<EnumValueDefinition>,
359}
360
361/// Input object type extension
362#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
363pub struct InputObjectTypeExtension {
364    pub name: String,
365    pub directives: Vec<Directive>,
366    pub fields: Vec<InputValueDefinition>,
367}
oxirs_gql/ast.rs

oxirs_gql/
ast.rs
