UNPKG

15.2 kBTypeScriptView Raw
1import { Source } from './source';
2import { TokenKindEnum } from './tokenKind';
3
4/**
5 * Contains a range of UTF-8 character offsets and token references that
6 * identify the region of the source from which the AST derived.
7 */
8export interface Location {
9 /**
10 * The character offset at which this Node begins.
11 */
12 readonly start: number;
13
14 /**
15 * The character offset at which this Node ends.
16 */
17 readonly end: number;
18
19 /**
20 * The Token at which this Node begins.
21 */
22 readonly startToken: Token;
23
24 /**
25 * The Token at which this Node ends.
26 */
27 readonly endToken: Token;
28
29 /**
30 * The Source document the AST represents.
31 */
32 readonly source: Source;
33}
34
35/**
36 * Represents a range of characters represented by a lexical token
37 * within a Source.
38 */
39export interface Token {
40 /**
41 * The kind of Token.
42 */
43 readonly kind: TokenKindEnum;
44
45 /**
46 * The character offset at which this Node begins.
47 */
48 readonly start: number;
49
50 /**
51 * The character offset at which this Node ends.
52 */
53 readonly end: number;
54
55 /**
56 * The 1-indexed line number on which this Token appears.
57 */
58 readonly line: number;
59
60 /**
61 * The 1-indexed column number at which this Token begins.
62 */
63 readonly column: number;
64
65 /**
66 * For non-punctuation tokens, represents the interpreted value of the token.
67 */
68 readonly value: string | undefined;
69
70 /**
71 * Tokens exist as nodes in a double-linked-list amongst all tokens
72 * including ignored tokens. <SOF> is always the first node and <EOF>
73 * the last.
74 */
75 readonly prev: Token | null;
76 readonly next: Token | null;
77}
78
79/**
80 * The list of all possible AST node types.
81 */
82export type ASTNode =
83 | NameNode
84 | DocumentNode
85 | OperationDefinitionNode
86 | VariableDefinitionNode
87 | VariableNode
88 | SelectionSetNode
89 | FieldNode
90 | ArgumentNode
91 | FragmentSpreadNode
92 | InlineFragmentNode
93 | FragmentDefinitionNode
94 | IntValueNode
95 | FloatValueNode
96 | StringValueNode
97 | BooleanValueNode
98 | NullValueNode
99 | EnumValueNode
100 | ListValueNode
101 | ObjectValueNode
102 | ObjectFieldNode
103 | DirectiveNode
104 | NamedTypeNode
105 | ListTypeNode
106 | NonNullTypeNode
107 | SchemaDefinitionNode
108 | OperationTypeDefinitionNode
109 | ScalarTypeDefinitionNode
110 | ObjectTypeDefinitionNode
111 | FieldDefinitionNode
112 | InputValueDefinitionNode
113 | InterfaceTypeDefinitionNode
114 | UnionTypeDefinitionNode
115 | EnumTypeDefinitionNode
116 | EnumValueDefinitionNode
117 | InputObjectTypeDefinitionNode
118 | DirectiveDefinitionNode
119 | SchemaExtensionNode
120 | ScalarTypeExtensionNode
121 | ObjectTypeExtensionNode
122 | InterfaceTypeExtensionNode
123 | UnionTypeExtensionNode
124 | EnumTypeExtensionNode
125 | InputObjectTypeExtensionNode;
126
127/**
128 * Utility type listing all nodes indexed by their kind.
129 */
130export interface ASTKindToNode {
131 Name: NameNode;
132 Document: DocumentNode;
133 OperationDefinition: OperationDefinitionNode;
134 VariableDefinition: VariableDefinitionNode;
135 Variable: VariableNode;
136 SelectionSet: SelectionSetNode;
137 Field: FieldNode;
138 Argument: ArgumentNode;
139 FragmentSpread: FragmentSpreadNode;
140 InlineFragment: InlineFragmentNode;
141 FragmentDefinition: FragmentDefinitionNode;
142 IntValue: IntValueNode;
143 FloatValue: FloatValueNode;
144 StringValue: StringValueNode;
145 BooleanValue: BooleanValueNode;
146 NullValue: NullValueNode;
147 EnumValue: EnumValueNode;
148 ListValue: ListValueNode;
149 ObjectValue: ObjectValueNode;
150 ObjectField: ObjectFieldNode;
151 Directive: DirectiveNode;
152 NamedType: NamedTypeNode;
153 ListType: ListTypeNode;
154 NonNullType: NonNullTypeNode;
155 SchemaDefinition: SchemaDefinitionNode;
156 OperationTypeDefinition: OperationTypeDefinitionNode;
157 ScalarTypeDefinition: ScalarTypeDefinitionNode;
158 ObjectTypeDefinition: ObjectTypeDefinitionNode;
159 FieldDefinition: FieldDefinitionNode;
160 InputValueDefinition: InputValueDefinitionNode;
161 InterfaceTypeDefinition: InterfaceTypeDefinitionNode;
162 UnionTypeDefinition: UnionTypeDefinitionNode;
163 EnumTypeDefinition: EnumTypeDefinitionNode;
164 EnumValueDefinition: EnumValueDefinitionNode;
165 InputObjectTypeDefinition: InputObjectTypeDefinitionNode;
166 DirectiveDefinition: DirectiveDefinitionNode;
167 SchemaExtension: SchemaExtensionNode;
168 ScalarTypeExtension: ScalarTypeExtensionNode;
169 ObjectTypeExtension: ObjectTypeExtensionNode;
170 InterfaceTypeExtension: InterfaceTypeExtensionNode;
171 UnionTypeExtension: UnionTypeExtensionNode;
172 EnumTypeExtension: EnumTypeExtensionNode;
173 InputObjectTypeExtension: InputObjectTypeExtensionNode;
174}
175
176// Name
177
178export interface NameNode {
179 readonly kind: 'Name';
180 readonly loc?: Location;
181 readonly value: string;
182}
183
184// Document
185
186export interface DocumentNode {
187 readonly kind: 'Document';
188 readonly loc?: Location;
189 readonly definitions: ReadonlyArray<DefinitionNode>;
190}
191
192export type DefinitionNode =
193 | ExecutableDefinitionNode
194 | TypeSystemDefinitionNode
195 | TypeSystemExtensionNode;
196
197export type ExecutableDefinitionNode =
198 | OperationDefinitionNode
199 | FragmentDefinitionNode;
200
201export interface OperationDefinitionNode {
202 readonly kind: 'OperationDefinition';
203 readonly loc?: Location;
204 readonly operation: OperationTypeNode;
205 readonly name?: NameNode;
206 readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;
207 readonly directives?: ReadonlyArray<DirectiveNode>;
208 readonly selectionSet: SelectionSetNode;
209}
210
211export type OperationTypeNode = 'query' | 'mutation' | 'subscription';
212
213export interface VariableDefinitionNode {
214 readonly kind: 'VariableDefinition';
215 readonly loc?: Location;
216 readonly variable: VariableNode;
217 readonly type: TypeNode;
218 readonly defaultValue?: ValueNode;
219 readonly directives?: ReadonlyArray<DirectiveNode>;
220}
221
222export interface VariableNode {
223 readonly kind: 'Variable';
224 readonly loc?: Location;
225 readonly name: NameNode;
226}
227
228export interface SelectionSetNode {
229 kind: 'SelectionSet';
230 loc?: Location;
231 selections: ReadonlyArray<SelectionNode>;
232}
233
234export type SelectionNode = FieldNode | FragmentSpreadNode | InlineFragmentNode;
235
236export interface FieldNode {
237 readonly kind: 'Field';
238 readonly loc?: Location;
239 readonly alias?: NameNode;
240 readonly name: NameNode;
241 readonly arguments?: ReadonlyArray<ArgumentNode>;
242 readonly directives?: ReadonlyArray<DirectiveNode>;
243 readonly selectionSet?: SelectionSetNode;
244}
245
246export interface ArgumentNode {
247 readonly kind: 'Argument';
248 readonly loc?: Location;
249 readonly name: NameNode;
250 readonly value: ValueNode;
251}
252
253// Fragments
254
255export interface FragmentSpreadNode {
256 readonly kind: 'FragmentSpread';
257 readonly loc?: Location;
258 readonly name: NameNode;
259 readonly directives?: ReadonlyArray<DirectiveNode>;
260}
261
262export interface InlineFragmentNode {
263 readonly kind: 'InlineFragment';
264 readonly loc?: Location;
265 readonly typeCondition?: NamedTypeNode;
266 readonly directives?: ReadonlyArray<DirectiveNode>;
267 readonly selectionSet: SelectionSetNode;
268}
269
270export interface FragmentDefinitionNode {
271 readonly kind: 'FragmentDefinition';
272 readonly loc?: Location;
273 readonly name: NameNode;
274 // Note: fragment variable definitions are experimental and may be changed
275 // or removed in the future.
276 readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;
277 readonly typeCondition: NamedTypeNode;
278 readonly directives?: ReadonlyArray<DirectiveNode>;
279 readonly selectionSet: SelectionSetNode;
280}
281
282// Values
283
284export type ValueNode =
285 | VariableNode
286 | IntValueNode
287 | FloatValueNode
288 | StringValueNode
289 | BooleanValueNode
290 | NullValueNode
291 | EnumValueNode
292 | ListValueNode
293 | ObjectValueNode;
294
295export interface IntValueNode {
296 readonly kind: 'IntValue';
297 readonly loc?: Location;
298 readonly value: string;
299}
300
301export interface FloatValueNode {
302 readonly kind: 'FloatValue';
303 readonly loc?: Location;
304 readonly value: string;
305}
306
307export interface StringValueNode {
308 readonly kind: 'StringValue';
309 readonly loc?: Location;
310 readonly value: string;
311 readonly block?: boolean;
312}
313
314export interface BooleanValueNode {
315 readonly kind: 'BooleanValue';
316 readonly loc?: Location;
317 readonly value: boolean;
318}
319
320export interface NullValueNode {
321 readonly kind: 'NullValue';
322 readonly loc?: Location;
323}
324
325export interface EnumValueNode {
326 readonly kind: 'EnumValue';
327 readonly loc?: Location;
328 readonly value: string;
329}
330
331export interface ListValueNode {
332 readonly kind: 'ListValue';
333 readonly loc?: Location;
334 readonly values: ReadonlyArray<ValueNode>;
335}
336
337export interface ObjectValueNode {
338 readonly kind: 'ObjectValue';
339 readonly loc?: Location;
340 readonly fields: ReadonlyArray<ObjectFieldNode>;
341}
342
343export interface ObjectFieldNode {
344 readonly kind: 'ObjectField';
345 readonly loc?: Location;
346 readonly name: NameNode;
347 readonly value: ValueNode;
348}
349
350// Directives
351
352export interface DirectiveNode {
353 readonly kind: 'Directive';
354 readonly loc?: Location;
355 readonly name: NameNode;
356 readonly arguments?: ReadonlyArray<ArgumentNode>;
357}
358
359// Type Reference
360
361export type TypeNode = NamedTypeNode | ListTypeNode | NonNullTypeNode;
362
363export interface NamedTypeNode {
364 readonly kind: 'NamedType';
365 readonly loc?: Location;
366 readonly name: NameNode;
367}
368
369export interface ListTypeNode {
370 readonly kind: 'ListType';
371 readonly loc?: Location;
372 readonly type: TypeNode;
373}
374
375export interface NonNullTypeNode {
376 readonly kind: 'NonNullType';
377 readonly loc?: Location;
378 readonly type: NamedTypeNode | ListTypeNode;
379}
380
381// Type System Definition
382
383export type TypeSystemDefinitionNode =
384 | SchemaDefinitionNode
385 | TypeDefinitionNode
386 | DirectiveDefinitionNode;
387
388export interface SchemaDefinitionNode {
389 readonly kind: 'SchemaDefinition';
390 readonly loc?: Location;
391 readonly directives?: ReadonlyArray<DirectiveNode>;
392 readonly operationTypes: ReadonlyArray<OperationTypeDefinitionNode>;
393}
394
395export interface OperationTypeDefinitionNode {
396 readonly kind: 'OperationTypeDefinition';
397 readonly loc?: Location;
398 readonly operation: OperationTypeNode;
399 readonly type: NamedTypeNode;
400}
401
402// Type Definition
403
404export type TypeDefinitionNode =
405 | ScalarTypeDefinitionNode
406 | ObjectTypeDefinitionNode
407 | InterfaceTypeDefinitionNode
408 | UnionTypeDefinitionNode
409 | EnumTypeDefinitionNode
410 | InputObjectTypeDefinitionNode;
411
412export interface ScalarTypeDefinitionNode {
413 readonly kind: 'ScalarTypeDefinition';
414 readonly loc?: Location;
415 readonly description?: StringValueNode;
416 readonly name: NameNode;
417 readonly directives?: ReadonlyArray<DirectiveNode>;
418}
419
420export interface ObjectTypeDefinitionNode {
421 readonly kind: 'ObjectTypeDefinition';
422 readonly loc?: Location;
423 readonly description?: StringValueNode;
424 readonly name: NameNode;
425 readonly interfaces?: ReadonlyArray<NamedTypeNode>;
426 readonly directives?: ReadonlyArray<DirectiveNode>;
427 readonly fields?: ReadonlyArray<FieldDefinitionNode>;
428}
429
430export interface FieldDefinitionNode {
431 readonly kind: 'FieldDefinition';
432 readonly loc?: Location;
433 readonly description?: StringValueNode;
434 readonly name: NameNode;
435 readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;
436 readonly type: TypeNode;
437 readonly directives?: ReadonlyArray<DirectiveNode>;
438}
439
440export interface InputValueDefinitionNode {
441 readonly kind: 'InputValueDefinition';
442 readonly loc?: Location;
443 readonly description?: StringValueNode;
444 readonly name: NameNode;
445 readonly type: TypeNode;
446 readonly defaultValue?: ValueNode;
447 readonly directives?: ReadonlyArray<DirectiveNode>;
448}
449
450export interface InterfaceTypeDefinitionNode {
451 readonly kind: 'InterfaceTypeDefinition';
452 readonly loc?: Location;
453 readonly description?: StringValueNode;
454 readonly name: NameNode;
455 readonly directives?: ReadonlyArray<DirectiveNode>;
456 readonly fields?: ReadonlyArray<FieldDefinitionNode>;
457}
458
459export interface UnionTypeDefinitionNode {
460 readonly kind: 'UnionTypeDefinition';
461 readonly loc?: Location;
462 readonly description?: StringValueNode;
463 readonly name: NameNode;
464 readonly directives?: ReadonlyArray<DirectiveNode>;
465 readonly types?: ReadonlyArray<NamedTypeNode>;
466}
467
468export interface EnumTypeDefinitionNode {
469 readonly kind: 'EnumTypeDefinition';
470 readonly loc?: Location;
471 readonly description?: StringValueNode;
472 readonly name: NameNode;
473 readonly directives?: ReadonlyArray<DirectiveNode>;
474 readonly values?: ReadonlyArray<EnumValueDefinitionNode>;
475}
476
477export interface EnumValueDefinitionNode {
478 readonly kind: 'EnumValueDefinition';
479 readonly loc?: Location;
480 readonly description?: StringValueNode;
481 readonly name: NameNode;
482 readonly directives?: ReadonlyArray<DirectiveNode>;
483}
484
485export interface InputObjectTypeDefinitionNode {
486 readonly kind: 'InputObjectTypeDefinition';
487 readonly loc?: Location;
488 readonly description?: StringValueNode;
489 readonly name: NameNode;
490 readonly directives?: ReadonlyArray<DirectiveNode>;
491 readonly fields?: ReadonlyArray<InputValueDefinitionNode>;
492}
493
494// Directive Definitions
495
496export interface DirectiveDefinitionNode {
497 readonly kind: 'DirectiveDefinition';
498 readonly loc?: Location;
499 readonly description?: StringValueNode;
500 readonly name: NameNode;
501 readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;
502 readonly repeatable: boolean;
503 readonly locations: ReadonlyArray<NameNode>;
504}
505
506// Type System Extensions
507
508export type TypeSystemExtensionNode = SchemaExtensionNode | TypeExtensionNode;
509
510export type SchemaExtensionNode = {
511 readonly kind: 'SchemaExtension';
512 readonly loc?: Location;
513 readonly directives?: ReadonlyArray<DirectiveNode>;
514 readonly operationTypes?: ReadonlyArray<OperationTypeDefinitionNode>;
515};
516
517// Type Extensions
518
519export type TypeExtensionNode =
520 | ScalarTypeExtensionNode
521 | ObjectTypeExtensionNode
522 | InterfaceTypeExtensionNode
523 | UnionTypeExtensionNode
524 | EnumTypeExtensionNode
525 | InputObjectTypeExtensionNode;
526
527export interface ScalarTypeExtensionNode {
528 readonly kind: 'ScalarTypeExtension';
529 readonly loc?: Location;
530 readonly name: NameNode;
531 readonly directives?: ReadonlyArray<DirectiveNode>;
532}
533
534export interface ObjectTypeExtensionNode {
535 readonly kind: 'ObjectTypeExtension';
536 readonly loc?: Location;
537 readonly name: NameNode;
538 readonly interfaces?: ReadonlyArray<NamedTypeNode>;
539 readonly directives?: ReadonlyArray<DirectiveNode>;
540 readonly fields?: ReadonlyArray<FieldDefinitionNode>;
541}
542
543export interface InterfaceTypeExtensionNode {
544 readonly kind: 'InterfaceTypeExtension';
545 readonly loc?: Location;
546 readonly name: NameNode;
547 readonly directives?: ReadonlyArray<DirectiveNode>;
548 readonly fields?: ReadonlyArray<FieldDefinitionNode>;
549}
550
551export interface UnionTypeExtensionNode {
552 readonly kind: 'UnionTypeExtension';
553 readonly loc?: Location;
554 readonly name: NameNode;
555 readonly directives?: ReadonlyArray<DirectiveNode>;
556 readonly types?: ReadonlyArray<NamedTypeNode>;
557}
558
559export interface EnumTypeExtensionNode {
560 readonly kind: 'EnumTypeExtension';
561 readonly loc?: Location;
562 readonly name: NameNode;
563 readonly directives?: ReadonlyArray<DirectiveNode>;
564 readonly values?: ReadonlyArray<EnumValueDefinitionNode>;
565}
566
567export interface InputObjectTypeExtensionNode {
568 readonly kind: 'InputObjectTypeExtension';
569 readonly loc?: Location;
570 readonly name: NameNode;
571 readonly directives?: ReadonlyArray<DirectiveNode>;
572 readonly fields?: ReadonlyArray<InputValueDefinitionNode>;
573}