Mirror: The spec-compliant minimum of client-side GraphQL.
feat: Extend local AST types with graphql’s types (#10)
* Build AST types that are always extending graphql’s types
* Replace entire type when possible
* Apply lint
* Add optional graphql peer dependency
authored by
Phil Pluckthun
and committed by
GitHub
85de461d
cf62ab97
+532
-343
+9
-1
package.json
+9
-1
package.json
···
7
7
"main": "./dist/graphql.web",
8
8
"module": "./dist/graphql.web.mjs",
9
9
"types": "./dist/graphql.web.d.ts",
10
+
"sideEffects": false,
10
11
"files": [
11
12
"LICENSE",
12
13
"README.md",
···
21
22
},
22
23
"./package.json": "./package.json"
23
24
},
24
-
"sideEffects": false,
25
+
"peerDependencies": {
26
+
"graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
27
+
},
28
+
"peerDependenciesMeta": {
29
+
"graphql": {
30
+
"optional": true
31
+
}
32
+
},
25
33
"public": true,
26
34
"keywords": [
27
35
"graphql",
+11
-1
scripts/rollup.config.mjs
+11
-1
scripts/rollup.config.mjs
···
150
150
output: {
151
151
dir: './dist',
152
152
entryFileNames: '[name].d.ts',
153
-
format: 'es'
153
+
format: 'es',
154
+
plugins: [
155
+
{
156
+
renderChunk(code, chunk) {
157
+
if (chunk.fileName.endsWith('d.ts')) {
158
+
const gqlImportRe = /(import\s+(?:[*\s{}\w\d]+)\s*from\s*'graphql';?)/g;
159
+
return code.replace(gqlImportRe, x => '/*!@ts-ignore*/\n' + x);
160
+
}
161
+
},
162
+
},
163
+
],
154
164
},
155
165
};
156
166
+283
-182
src/ast.ts
+283
-182
src/ast.ts
···
1
+
import type * as GraphQL from 'graphql';
2
+
1
3
import type { Kind, OperationTypeNode } from './kind';
2
-
import type { Location } from './types';
4
+
import type { Or, Location } from './types';
3
5
4
6
import type {
5
7
TypeSystemDefinitionNode,
···
25
27
InputObjectTypeExtensionNode,
26
28
} from './schemaAst';
27
29
28
-
export type ASTNode =
30
+
export type ASTNode = Or<
31
+
GraphQL.ASTNode,
29
32
| NameNode
30
33
| DocumentNode
31
34
| OperationDefinitionNode
···
68
71
| InterfaceTypeExtensionNode
69
72
| UnionTypeExtensionNode
70
73
| EnumTypeExtensionNode
71
-
| InputObjectTypeExtensionNode;
74
+
| InputObjectTypeExtensionNode
75
+
>;
72
76
73
-
export interface NameNode {
74
-
readonly kind: Kind.NAME;
75
-
readonly value: string;
76
-
readonly loc?: Location;
77
-
}
77
+
export type NameNode = Or<
78
+
GraphQL.NameNode,
79
+
{
80
+
readonly kind: Kind.NAME;
81
+
readonly value: string;
82
+
readonly loc?: Location;
83
+
}
84
+
>;
78
85
79
-
export interface DocumentNode {
80
-
readonly kind: Kind.DOCUMENT;
81
-
readonly definitions: ReadonlyArray<DefinitionNode>;
82
-
readonly loc?: Location;
83
-
}
86
+
export type DocumentNode = Or<
87
+
GraphQL.DocumentNode,
88
+
{
89
+
readonly kind: Kind.DOCUMENT;
90
+
readonly definitions: ReadonlyArray<DefinitionNode>;
91
+
readonly loc?: Location;
92
+
}
93
+
>;
84
94
85
-
export type DefinitionNode =
86
-
| ExecutableDefinitionNode
87
-
| TypeSystemDefinitionNode
88
-
| TypeSystemExtensionNode;
95
+
export type DefinitionNode = Or<
96
+
GraphQL.DefinitionNode,
97
+
ExecutableDefinitionNode | TypeSystemDefinitionNode | TypeSystemExtensionNode
98
+
>;
89
99
90
-
export type ExecutableDefinitionNode = OperationDefinitionNode | FragmentDefinitionNode;
100
+
export type ExecutableDefinitionNode = Or<
101
+
GraphQL.ExecutableDefinitionNode,
102
+
OperationDefinitionNode | FragmentDefinitionNode
103
+
>;
91
104
92
-
export interface OperationDefinitionNode {
93
-
readonly kind: Kind.OPERATION_DEFINITION;
94
-
readonly operation: OperationTypeNode;
95
-
readonly name?: NameNode;
96
-
readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;
97
-
readonly directives?: ReadonlyArray<DirectiveNode>;
98
-
readonly selectionSet: SelectionSetNode;
99
-
readonly loc?: Location;
100
-
}
105
+
export type OperationDefinitionNode = Or<
106
+
GraphQL.OperationDefinitionNode,
107
+
{
108
+
readonly kind: Kind.OPERATION_DEFINITION;
109
+
readonly operation: OperationTypeNode;
110
+
readonly name?: NameNode;
111
+
readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;
112
+
readonly directives?: ReadonlyArray<DirectiveNode>;
113
+
readonly selectionSet: SelectionSetNode;
114
+
readonly loc?: Location;
115
+
}
116
+
>;
101
117
102
-
export interface VariableDefinitionNode {
103
-
readonly kind: Kind.VARIABLE_DEFINITION;
104
-
readonly variable: VariableNode;
105
-
readonly type: TypeNode;
106
-
readonly defaultValue?: ConstValueNode;
107
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
108
-
readonly loc?: Location;
109
-
}
118
+
export type VariableDefinitionNode = Or<
119
+
GraphQL.VariableDefinitionNode,
120
+
{
121
+
readonly kind: Kind.VARIABLE_DEFINITION;
122
+
readonly variable: VariableNode;
123
+
readonly type: TypeNode;
124
+
readonly defaultValue?: ConstValueNode;
125
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
126
+
readonly loc?: Location;
127
+
}
128
+
>;
110
129
111
-
export interface VariableNode {
112
-
readonly kind: Kind.VARIABLE;
113
-
readonly name: NameNode;
114
-
readonly loc?: Location;
115
-
}
130
+
export type VariableNode = Or<
131
+
GraphQL.VariableNode,
132
+
{
133
+
readonly kind: Kind.VARIABLE;
134
+
readonly name: NameNode;
135
+
readonly loc?: Location;
136
+
}
137
+
>;
116
138
117
-
export interface SelectionSetNode {
118
-
readonly kind: Kind.SELECTION_SET;
119
-
readonly selections: ReadonlyArray<SelectionNode>;
120
-
readonly loc?: Location;
121
-
}
139
+
export type SelectionSetNode = Or<
140
+
GraphQL.SelectionSetNode,
141
+
{
142
+
readonly kind: Kind.SELECTION_SET;
143
+
readonly selections: ReadonlyArray<SelectionNode>;
144
+
readonly loc?: Location;
145
+
}
146
+
>;
122
147
123
-
export declare type SelectionNode = FieldNode | FragmentSpreadNode | InlineFragmentNode;
148
+
export declare type SelectionNode = Or<
149
+
GraphQL.SelectionNode,
150
+
FieldNode | FragmentSpreadNode | InlineFragmentNode
151
+
>;
124
152
125
-
export interface FieldNode {
126
-
readonly kind: Kind.FIELD;
127
-
readonly alias?: NameNode;
128
-
readonly name: NameNode;
129
-
readonly arguments?: ReadonlyArray<ArgumentNode>;
130
-
readonly directives?: ReadonlyArray<DirectiveNode>;
131
-
readonly selectionSet?: SelectionSetNode;
132
-
readonly loc?: Location;
133
-
}
153
+
export type FieldNode = Or<
154
+
GraphQL.FieldNode,
155
+
{
156
+
readonly kind: Kind.FIELD;
157
+
readonly alias?: NameNode;
158
+
readonly name: NameNode;
159
+
readonly arguments?: ReadonlyArray<ArgumentNode>;
160
+
readonly directives?: ReadonlyArray<DirectiveNode>;
161
+
readonly selectionSet?: SelectionSetNode;
162
+
readonly loc?: Location;
163
+
}
164
+
>;
134
165
135
-
export interface ArgumentNode {
136
-
readonly kind: Kind.ARGUMENT;
137
-
readonly name: NameNode;
138
-
readonly value: ValueNode;
139
-
readonly loc?: Location;
140
-
}
166
+
export type ArgumentNode = Or<
167
+
GraphQL.ArgumentNode,
168
+
{
169
+
readonly kind: Kind.ARGUMENT;
170
+
readonly name: NameNode;
171
+
readonly value: ValueNode;
172
+
readonly loc?: Location;
173
+
}
174
+
>;
141
175
142
-
export interface ConstArgumentNode {
143
-
readonly kind: Kind.ARGUMENT;
144
-
readonly name: NameNode;
145
-
readonly value: ConstValueNode;
146
-
readonly loc?: Location;
147
-
}
176
+
export type ConstArgumentNode = Or<
177
+
GraphQL.ConstArgumentNode,
178
+
{
179
+
readonly kind: Kind.ARGUMENT;
180
+
readonly name: NameNode;
181
+
readonly value: ConstValueNode;
182
+
readonly loc?: Location;
183
+
}
184
+
>;
148
185
149
-
export interface FragmentSpreadNode {
150
-
readonly kind: Kind.FRAGMENT_SPREAD;
151
-
readonly name: NameNode;
152
-
readonly directives?: ReadonlyArray<DirectiveNode>;
153
-
readonly loc?: Location;
154
-
}
186
+
export type FragmentSpreadNode = Or<
187
+
GraphQL.FragmentSpreadNode,
188
+
{
189
+
readonly kind: Kind.FRAGMENT_SPREAD;
190
+
readonly name: NameNode;
191
+
readonly directives?: ReadonlyArray<DirectiveNode>;
192
+
readonly loc?: Location;
193
+
}
194
+
>;
155
195
156
-
export interface InlineFragmentNode {
157
-
readonly kind: Kind.INLINE_FRAGMENT;
158
-
readonly typeCondition?: NamedTypeNode;
159
-
readonly directives?: ReadonlyArray<DirectiveNode>;
160
-
readonly selectionSet: SelectionSetNode;
161
-
readonly loc?: Location;
162
-
}
196
+
export type InlineFragmentNode = Or<
197
+
GraphQL.InlineFragmentNode,
198
+
{
199
+
readonly kind: Kind.INLINE_FRAGMENT;
200
+
readonly typeCondition?: NamedTypeNode;
201
+
readonly directives?: ReadonlyArray<DirectiveNode>;
202
+
readonly selectionSet: SelectionSetNode;
203
+
readonly loc?: Location;
204
+
}
205
+
>;
163
206
164
-
export interface FragmentDefinitionNode {
165
-
readonly kind: Kind.FRAGMENT_DEFINITION;
166
-
readonly name: NameNode;
167
-
readonly typeCondition: NamedTypeNode;
168
-
readonly directives?: ReadonlyArray<DirectiveNode>;
169
-
readonly selectionSet: SelectionSetNode;
170
-
readonly loc?: Location;
171
-
}
207
+
export type FragmentDefinitionNode = Or<
208
+
GraphQL.FragmentDefinitionNode,
209
+
{
210
+
readonly kind: Kind.FRAGMENT_DEFINITION;
211
+
readonly name: NameNode;
212
+
readonly typeCondition: NamedTypeNode;
213
+
readonly directives?: ReadonlyArray<DirectiveNode>;
214
+
readonly selectionSet: SelectionSetNode;
215
+
readonly loc?: Location;
216
+
}
217
+
>;
172
218
173
-
export type ValueNode =
219
+
export type ValueNode = Or<
220
+
GraphQL.ValueNode,
174
221
| VariableNode
175
222
| IntValueNode
176
223
| FloatValueNode
···
179
226
| NullValueNode
180
227
| EnumValueNode
181
228
| ListValueNode
182
-
| ObjectValueNode;
229
+
| ObjectValueNode
230
+
>;
183
231
184
-
export type ConstValueNode =
232
+
export type ConstValueNode = Or<
233
+
GraphQL.ConstValueNode,
185
234
| IntValueNode
186
235
| FloatValueNode
187
236
| StringValueNode
···
189
238
| NullValueNode
190
239
| EnumValueNode
191
240
| ConstListValueNode
192
-
| ConstObjectValueNode;
241
+
| ConstObjectValueNode
242
+
>;
193
243
194
-
export interface IntValueNode {
195
-
readonly kind: Kind.INT;
196
-
readonly value: string;
197
-
readonly loc?: Location;
198
-
}
244
+
export type IntValueNode = Or<
245
+
GraphQL.IntValueNode,
246
+
{
247
+
readonly kind: Kind.INT;
248
+
readonly value: string;
249
+
readonly loc?: Location;
250
+
}
251
+
>;
199
252
200
-
export interface FloatValueNode {
201
-
readonly kind: Kind.FLOAT;
202
-
readonly value: string;
203
-
readonly loc?: Location;
204
-
}
253
+
export type FloatValueNode = Or<
254
+
GraphQL.FloatValueNode,
255
+
{
256
+
readonly kind: Kind.FLOAT;
257
+
readonly value: string;
258
+
readonly loc?: Location;
259
+
}
260
+
>;
205
261
206
-
export interface StringValueNode {
207
-
readonly kind: Kind.STRING;
208
-
readonly value: string;
209
-
readonly block?: boolean;
210
-
readonly loc?: Location;
211
-
}
262
+
export type StringValueNode = Or<
263
+
GraphQL.FloatValueNode,
264
+
{
265
+
readonly kind: Kind.STRING;
266
+
readonly value: string;
267
+
readonly block?: boolean;
268
+
readonly loc?: Location;
269
+
}
270
+
>;
212
271
213
-
export interface BooleanValueNode {
214
-
readonly kind: Kind.BOOLEAN;
215
-
readonly value: boolean;
216
-
readonly loc?: Location;
217
-
}
272
+
export type BooleanValueNode = Or<
273
+
GraphQL.BooleanValueNode,
274
+
{
275
+
readonly kind: Kind.BOOLEAN;
276
+
readonly value: boolean;
277
+
readonly loc?: Location;
278
+
}
279
+
>;
218
280
219
-
export interface NullValueNode {
220
-
readonly kind: Kind.NULL;
221
-
readonly loc?: Location;
222
-
}
281
+
export type NullValueNode = Or<
282
+
GraphQL.NullValueNode,
283
+
{
284
+
readonly kind: Kind.NULL;
285
+
readonly loc?: Location;
286
+
}
287
+
>;
223
288
224
-
export interface EnumValueNode {
225
-
readonly kind: Kind.ENUM;
226
-
readonly value: string;
227
-
readonly loc?: Location;
228
-
}
289
+
export type EnumValueNode = Or<
290
+
GraphQL.EnumValueNode,
291
+
{
292
+
readonly kind: Kind.ENUM;
293
+
readonly value: string;
294
+
readonly loc?: Location;
295
+
}
296
+
>;
229
297
230
-
export interface ListValueNode {
231
-
readonly kind: Kind.LIST;
232
-
readonly values: ReadonlyArray<ValueNode>;
233
-
readonly loc?: Location;
234
-
}
298
+
export type ListValueNode = Or<
299
+
GraphQL.ListValueNode,
300
+
{
301
+
readonly kind: Kind.LIST;
302
+
readonly values: ReadonlyArray<ValueNode>;
303
+
readonly loc?: Location;
304
+
}
305
+
>;
235
306
236
-
export interface ConstListValueNode {
237
-
readonly kind: Kind.LIST;
238
-
readonly values: ReadonlyArray<ConstValueNode>;
239
-
readonly loc?: Location;
240
-
}
307
+
export type ConstListValueNode = Or<
308
+
GraphQL.ConstListValueNode,
309
+
{
310
+
readonly kind: Kind.LIST;
311
+
readonly values: ReadonlyArray<ConstValueNode>;
312
+
readonly loc?: Location;
313
+
}
314
+
>;
241
315
242
-
export interface ObjectValueNode {
243
-
readonly kind: Kind.OBJECT;
244
-
readonly fields: ReadonlyArray<ObjectFieldNode>;
245
-
readonly loc?: Location;
246
-
}
316
+
export type ObjectValueNode = Or<
317
+
GraphQL.ObjectValueNode,
318
+
{
319
+
readonly kind: Kind.OBJECT;
320
+
readonly fields: ReadonlyArray<ObjectFieldNode>;
321
+
readonly loc?: Location;
322
+
}
323
+
>;
247
324
248
-
export interface ConstObjectValueNode {
249
-
readonly kind: Kind.OBJECT;
250
-
readonly fields: ReadonlyArray<ConstObjectFieldNode>;
251
-
readonly loc?: Location;
252
-
}
325
+
export type ConstObjectValueNode = Or<
326
+
GraphQL.ConstObjectValueNode,
327
+
{
328
+
readonly kind: Kind.OBJECT;
329
+
readonly fields: ReadonlyArray<ConstObjectFieldNode>;
330
+
readonly loc?: Location;
331
+
}
332
+
>;
253
333
254
-
export interface ObjectFieldNode {
255
-
readonly kind: Kind.OBJECT_FIELD;
256
-
readonly name: NameNode;
257
-
readonly value: ValueNode;
258
-
readonly loc?: Location;
259
-
}
334
+
export type ObjectFieldNode = Or<
335
+
GraphQL.ObjectFieldNode,
336
+
{
337
+
readonly kind: Kind.OBJECT_FIELD;
338
+
readonly name: NameNode;
339
+
readonly value: ValueNode;
340
+
readonly loc?: Location;
341
+
}
342
+
>;
260
343
261
-
export interface ConstObjectFieldNode {
262
-
readonly kind: Kind.OBJECT_FIELD;
263
-
readonly name: NameNode;
264
-
readonly value: ConstValueNode;
265
-
readonly loc?: Location;
266
-
}
344
+
export type ConstObjectFieldNode = Or<
345
+
GraphQL.ConstObjectFieldNode,
346
+
{
347
+
readonly kind: Kind.OBJECT_FIELD;
348
+
readonly name: NameNode;
349
+
readonly value: ConstValueNode;
350
+
readonly loc?: Location;
351
+
}
352
+
>;
267
353
268
-
export interface DirectiveNode {
269
-
readonly kind: Kind.DIRECTIVE;
270
-
readonly name: NameNode;
271
-
readonly arguments?: ReadonlyArray<ArgumentNode>;
272
-
readonly loc?: Location;
273
-
}
354
+
export type DirectiveNode = Or<
355
+
GraphQL.DirectiveNode,
356
+
{
357
+
readonly kind: Kind.DIRECTIVE;
358
+
readonly name: NameNode;
359
+
readonly arguments?: ReadonlyArray<ArgumentNode>;
360
+
readonly loc?: Location;
361
+
}
362
+
>;
274
363
275
-
export interface ConstDirectiveNode {
276
-
readonly kind: Kind.DIRECTIVE;
277
-
readonly name: NameNode;
278
-
readonly arguments?: ReadonlyArray<ConstArgumentNode>;
279
-
readonly loc?: Location;
280
-
}
364
+
export type ConstDirectiveNode = Or<
365
+
GraphQL.ConstDirectiveNode,
366
+
{
367
+
readonly kind: Kind.DIRECTIVE;
368
+
readonly name: NameNode;
369
+
readonly arguments?: ReadonlyArray<ConstArgumentNode>;
370
+
readonly loc?: Location;
371
+
}
372
+
>;
281
373
282
-
export declare type TypeNode = NamedTypeNode | ListTypeNode | NonNullTypeNode;
374
+
export type TypeNode = Or<GraphQL.TypeNode, NamedTypeNode | ListTypeNode | NonNullTypeNode>;
283
375
284
-
export interface NamedTypeNode {
285
-
readonly kind: Kind.NAMED_TYPE;
286
-
readonly name: NameNode;
287
-
readonly loc?: Location;
288
-
}
376
+
export type NamedTypeNode = Or<
377
+
GraphQL.NamedTypeNode,
378
+
{
379
+
readonly kind: Kind.NAMED_TYPE;
380
+
readonly name: NameNode;
381
+
readonly loc?: Location;
382
+
}
383
+
>;
289
384
290
-
export interface ListTypeNode {
291
-
readonly kind: Kind.LIST_TYPE;
292
-
readonly type: TypeNode;
293
-
readonly loc?: Location;
294
-
}
385
+
export type ListTypeNode = Or<
386
+
GraphQL.ListTypeNode,
387
+
{
388
+
readonly kind: Kind.LIST_TYPE;
389
+
readonly type: TypeNode;
390
+
readonly loc?: Location;
391
+
}
392
+
>;
295
393
296
-
export interface NonNullTypeNode {
297
-
readonly kind: Kind.NON_NULL_TYPE;
298
-
readonly type: NamedTypeNode | ListTypeNode;
299
-
readonly loc?: Location;
300
-
}
394
+
export type NonNullTypeNode = Or<
395
+
GraphQL.NonNullTypeNode,
396
+
{
397
+
readonly kind: Kind.NON_NULL_TYPE;
398
+
readonly type: NamedTypeNode | ListTypeNode;
399
+
readonly loc?: Location;
400
+
}
401
+
>;
+1
-1
src/printer.ts
+1
-1
src/printer.ts
+226
-158
src/schemaAst.ts
+226
-158
src/schemaAst.ts
···
1
-
import type { Location } from './types';
1
+
import type * as GraphQL from 'graphql';
2
+
3
+
import type { Or, Location } from './types';
2
4
import type { Kind, OperationTypeNode } from './kind';
3
5
4
6
import type {
···
11
13
} from './ast';
12
14
13
15
/** Type System Definition */
14
-
export declare type TypeSystemDefinitionNode =
15
-
| SchemaDefinitionNode
16
-
| TypeDefinitionNode
17
-
| DirectiveDefinitionNode;
16
+
export declare type TypeSystemDefinitionNode = Or<
17
+
GraphQL.TypeSystemDefinitionNode,
18
+
SchemaDefinitionNode | TypeDefinitionNode | DirectiveDefinitionNode
19
+
>;
18
20
19
-
export interface SchemaDefinitionNode {
20
-
readonly kind: Kind.SCHEMA_DEFINITION;
21
-
readonly loc?: Location;
22
-
readonly description?: StringValueNode;
23
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
24
-
readonly operationTypes: ReadonlyArray<OperationTypeDefinitionNode>;
25
-
}
21
+
export type SchemaDefinitionNode = Or<
22
+
GraphQL.SchemaDefinitionNode,
23
+
{
24
+
readonly kind: Kind.SCHEMA_DEFINITION;
25
+
readonly loc?: Location;
26
+
readonly description?: StringValueNode;
27
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
28
+
readonly operationTypes: ReadonlyArray<OperationTypeDefinitionNode>;
29
+
}
30
+
>;
26
31
27
-
export interface OperationTypeDefinitionNode {
28
-
readonly kind: Kind.OPERATION_TYPE_DEFINITION;
29
-
readonly loc?: Location;
30
-
readonly operation: OperationTypeNode;
31
-
readonly type: NamedTypeNode;
32
-
}
32
+
export type OperationTypeDefinitionNode = Or<
33
+
GraphQL.OperationTypeDefinitionNode,
34
+
{
35
+
readonly kind: Kind.OPERATION_TYPE_DEFINITION;
36
+
readonly loc?: Location;
37
+
readonly operation: OperationTypeNode;
38
+
readonly type: NamedTypeNode;
39
+
}
40
+
>;
33
41
34
42
/** Type Definition */
35
-
export declare type TypeDefinitionNode =
43
+
export declare type TypeDefinitionNode = Or<
44
+
GraphQL.TypeDefinitionNode,
36
45
| ScalarTypeDefinitionNode
37
46
| ObjectTypeDefinitionNode
38
47
| InterfaceTypeDefinitionNode
39
48
| UnionTypeDefinitionNode
40
49
| EnumTypeDefinitionNode
41
-
| InputObjectTypeDefinitionNode;
50
+
| InputObjectTypeDefinitionNode
51
+
>;
42
52
43
-
export interface ScalarTypeDefinitionNode {
44
-
readonly kind: Kind.SCALAR_TYPE_DEFINITION;
45
-
readonly loc?: Location;
46
-
readonly description?: StringValueNode;
47
-
readonly name: NameNode;
48
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
49
-
}
53
+
export type ScalarTypeDefinitionNode = Or<
54
+
GraphQL.ScalarTypeDefinitionNode,
55
+
{
56
+
readonly kind: Kind.SCALAR_TYPE_DEFINITION;
57
+
readonly loc?: Location;
58
+
readonly description?: StringValueNode;
59
+
readonly name: NameNode;
60
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
61
+
}
62
+
>;
50
63
51
-
export interface ObjectTypeDefinitionNode {
52
-
readonly kind: Kind.OBJECT_TYPE_DEFINITION;
53
-
readonly loc?: Location;
54
-
readonly description?: StringValueNode;
55
-
readonly name: NameNode;
56
-
readonly interfaces?: ReadonlyArray<NamedTypeNode>;
57
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
58
-
readonly fields?: ReadonlyArray<FieldDefinitionNode>;
59
-
}
64
+
export type ObjectTypeDefinitionNode = Or<
65
+
GraphQL.ObjectTypeDefinitionNode,
66
+
{
67
+
readonly kind: Kind.OBJECT_TYPE_DEFINITION;
68
+
readonly loc?: Location;
69
+
readonly description?: StringValueNode;
70
+
readonly name: NameNode;
71
+
readonly interfaces?: ReadonlyArray<NamedTypeNode>;
72
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
73
+
readonly fields?: ReadonlyArray<FieldDefinitionNode>;
74
+
}
75
+
>;
60
76
61
-
export interface FieldDefinitionNode {
62
-
readonly kind: Kind.FIELD_DEFINITION;
63
-
readonly loc?: Location;
64
-
readonly description?: StringValueNode;
65
-
readonly name: NameNode;
66
-
readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;
67
-
readonly type: TypeNode;
68
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
69
-
}
77
+
export type FieldDefinitionNode = Or<
78
+
GraphQL.FieldDefinitionNode,
79
+
{
80
+
readonly kind: Kind.FIELD_DEFINITION;
81
+
readonly loc?: Location;
82
+
readonly description?: StringValueNode;
83
+
readonly name: NameNode;
84
+
readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;
85
+
readonly type: TypeNode;
86
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
87
+
}
88
+
>;
70
89
71
-
export interface InputValueDefinitionNode {
72
-
readonly kind: Kind.INPUT_VALUE_DEFINITION;
73
-
readonly loc?: Location;
74
-
readonly description?: StringValueNode;
75
-
readonly name: NameNode;
76
-
readonly type: TypeNode;
77
-
readonly defaultValue?: ConstValueNode;
78
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
79
-
}
90
+
export type InputValueDefinitionNode = Or<
91
+
GraphQL.InputValueDefinitionNode,
92
+
{
93
+
readonly kind: Kind.INPUT_VALUE_DEFINITION;
94
+
readonly loc?: Location;
95
+
readonly description?: StringValueNode;
96
+
readonly name: NameNode;
97
+
readonly type: TypeNode;
98
+
readonly defaultValue?: ConstValueNode;
99
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
100
+
}
101
+
>;
80
102
81
-
export interface InterfaceTypeDefinitionNode {
82
-
readonly kind: Kind.INTERFACE_TYPE_DEFINITION;
83
-
readonly loc?: Location;
84
-
readonly description?: StringValueNode;
85
-
readonly name: NameNode;
86
-
readonly interfaces?: ReadonlyArray<NamedTypeNode>;
87
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
88
-
readonly fields?: ReadonlyArray<FieldDefinitionNode>;
89
-
}
103
+
export type InterfaceTypeDefinitionNode = Or<
104
+
GraphQL.InterfaceTypeDefinitionNode,
105
+
{
106
+
readonly kind: Kind.INTERFACE_TYPE_DEFINITION;
107
+
readonly loc?: Location;
108
+
readonly description?: StringValueNode;
109
+
readonly name: NameNode;
110
+
readonly interfaces?: ReadonlyArray<NamedTypeNode>;
111
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
112
+
readonly fields?: ReadonlyArray<FieldDefinitionNode>;
113
+
}
114
+
>;
90
115
91
-
export interface UnionTypeDefinitionNode {
92
-
readonly kind: Kind.UNION_TYPE_DEFINITION;
93
-
readonly loc?: Location;
94
-
readonly description?: StringValueNode;
95
-
readonly name: NameNode;
96
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
97
-
readonly types?: ReadonlyArray<NamedTypeNode>;
98
-
}
116
+
export type UnionTypeDefinitionNode = Or<
117
+
GraphQL.UnionTypeDefinitionNode,
118
+
{
119
+
readonly kind: Kind.UNION_TYPE_DEFINITION;
120
+
readonly loc?: Location;
121
+
readonly description?: StringValueNode;
122
+
readonly name: NameNode;
123
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
124
+
readonly types?: ReadonlyArray<NamedTypeNode>;
125
+
}
126
+
>;
99
127
100
-
export interface EnumTypeDefinitionNode {
101
-
readonly kind: Kind.ENUM_TYPE_DEFINITION;
102
-
readonly loc?: Location;
103
-
readonly description?: StringValueNode;
104
-
readonly name: NameNode;
105
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
106
-
readonly values?: ReadonlyArray<EnumValueDefinitionNode>;
107
-
}
128
+
export type EnumTypeDefinitionNode = Or<
129
+
GraphQL.EnumTypeDefinitionNode,
130
+
{
131
+
readonly kind: Kind.ENUM_TYPE_DEFINITION;
132
+
readonly loc?: Location;
133
+
readonly description?: StringValueNode;
134
+
readonly name: NameNode;
135
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
136
+
readonly values?: ReadonlyArray<EnumValueDefinitionNode>;
137
+
}
138
+
>;
108
139
109
-
export interface EnumValueDefinitionNode {
110
-
readonly kind: Kind.ENUM_VALUE_DEFINITION;
111
-
readonly loc?: Location;
112
-
readonly description?: StringValueNode;
113
-
readonly name: NameNode;
114
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
115
-
}
140
+
export type EnumValueDefinitionNode = Or<
141
+
GraphQL.EnumValueDefinitionNode,
142
+
{
143
+
readonly kind: Kind.ENUM_VALUE_DEFINITION;
144
+
readonly loc?: Location;
145
+
readonly description?: StringValueNode;
146
+
readonly name: NameNode;
147
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
148
+
}
149
+
>;
116
150
117
-
export interface InputObjectTypeDefinitionNode {
118
-
readonly kind: Kind.INPUT_OBJECT_TYPE_DEFINITION;
119
-
readonly loc?: Location;
120
-
readonly description?: StringValueNode;
121
-
readonly name: NameNode;
122
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
123
-
readonly fields?: ReadonlyArray<InputValueDefinitionNode>;
124
-
}
125
-
/** Directive Definitions */
126
-
export interface DirectiveDefinitionNode {
127
-
readonly kind: Kind.DIRECTIVE_DEFINITION;
128
-
readonly loc?: Location;
129
-
readonly description?: StringValueNode;
130
-
readonly name: NameNode;
131
-
readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;
132
-
readonly repeatable: boolean;
133
-
readonly locations: ReadonlyArray<NameNode>;
134
-
}
135
-
/** Type System Extensions */
136
-
export declare type TypeSystemExtensionNode = SchemaExtensionNode | TypeExtensionNode;
137
-
export interface SchemaExtensionNode {
138
-
readonly kind: Kind.SCHEMA_EXTENSION;
139
-
readonly loc?: Location;
140
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
141
-
readonly operationTypes?: ReadonlyArray<OperationTypeDefinitionNode>;
142
-
}
143
-
/** Type Extensions */
144
-
export declare type TypeExtensionNode =
151
+
export type InputObjectTypeDefinitionNode = Or<
152
+
GraphQL.InputObjectTypeDefinitionNode,
153
+
{
154
+
readonly kind: Kind.INPUT_OBJECT_TYPE_DEFINITION;
155
+
readonly loc?: Location;
156
+
readonly description?: StringValueNode;
157
+
readonly name: NameNode;
158
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
159
+
readonly fields?: ReadonlyArray<InputValueDefinitionNode>;
160
+
}
161
+
>;
162
+
163
+
export type DirectiveDefinitionNode = Or<
164
+
GraphQL.DirectiveDefinitionNode,
165
+
{
166
+
readonly kind: Kind.DIRECTIVE_DEFINITION;
167
+
readonly loc?: Location;
168
+
readonly description?: StringValueNode;
169
+
readonly name: NameNode;
170
+
readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;
171
+
readonly repeatable: boolean;
172
+
readonly locations: ReadonlyArray<NameNode>;
173
+
}
174
+
>;
175
+
176
+
export type TypeSystemExtensionNode = Or<
177
+
GraphQL.TypeSystemExtensionNode,
178
+
SchemaExtensionNode | TypeExtensionNode
179
+
>;
180
+
181
+
export type SchemaExtensionNode = Or<
182
+
GraphQL.SchemaExtensionNode,
183
+
{
184
+
readonly kind: Kind.SCHEMA_EXTENSION;
185
+
readonly loc?: Location;
186
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
187
+
readonly operationTypes?: ReadonlyArray<OperationTypeDefinitionNode>;
188
+
}
189
+
>;
190
+
191
+
export declare type TypeExtensionNode = Or<
192
+
GraphQL.TypeExtensionNode,
145
193
| ScalarTypeExtensionNode
146
194
| ObjectTypeExtensionNode
147
195
| InterfaceTypeExtensionNode
148
196
| UnionTypeExtensionNode
149
197
| EnumTypeExtensionNode
150
-
| InputObjectTypeExtensionNode;
151
-
export interface ScalarTypeExtensionNode {
152
-
readonly kind: Kind.SCALAR_TYPE_EXTENSION;
153
-
readonly loc?: Location;
154
-
readonly name: NameNode;
155
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
156
-
}
198
+
| InputObjectTypeExtensionNode
199
+
>;
157
200
158
-
export interface ObjectTypeExtensionNode {
159
-
readonly kind: Kind.OBJECT_TYPE_EXTENSION;
160
-
readonly loc?: Location;
161
-
readonly name: NameNode;
162
-
readonly interfaces?: ReadonlyArray<NamedTypeNode>;
163
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
164
-
readonly fields?: ReadonlyArray<FieldDefinitionNode>;
165
-
}
201
+
export type ScalarTypeExtensionNode = Or<
202
+
GraphQL.ScalarTypeExtensionNode,
203
+
{
204
+
readonly kind: Kind.SCALAR_TYPE_EXTENSION;
205
+
readonly loc?: Location;
206
+
readonly name: NameNode;
207
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
208
+
}
209
+
>;
166
210
167
-
export interface InterfaceTypeExtensionNode {
168
-
readonly kind: Kind.INTERFACE_TYPE_EXTENSION;
169
-
readonly loc?: Location;
170
-
readonly name: NameNode;
171
-
readonly interfaces?: ReadonlyArray<NamedTypeNode>;
172
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
173
-
readonly fields?: ReadonlyArray<FieldDefinitionNode>;
174
-
}
211
+
export type ObjectTypeExtensionNode = Or<
212
+
GraphQL.ObjectTypeExtensionNode,
213
+
{
214
+
readonly kind: Kind.OBJECT_TYPE_EXTENSION;
215
+
readonly loc?: Location;
216
+
readonly name: NameNode;
217
+
readonly interfaces?: ReadonlyArray<NamedTypeNode>;
218
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
219
+
readonly fields?: ReadonlyArray<FieldDefinitionNode>;
220
+
}
221
+
>;
175
222
176
-
export interface UnionTypeExtensionNode {
177
-
readonly kind: Kind.UNION_TYPE_EXTENSION;
178
-
readonly loc?: Location;
179
-
readonly name: NameNode;
180
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
181
-
readonly types?: ReadonlyArray<NamedTypeNode>;
182
-
}
223
+
export type InterfaceTypeExtensionNode = Or<
224
+
GraphQL.InterfaceTypeExtensionNode,
225
+
{
226
+
readonly kind: Kind.INTERFACE_TYPE_EXTENSION;
227
+
readonly loc?: Location;
228
+
readonly name: NameNode;
229
+
readonly interfaces?: ReadonlyArray<NamedTypeNode>;
230
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
231
+
readonly fields?: ReadonlyArray<FieldDefinitionNode>;
232
+
}
233
+
>;
183
234
184
-
export interface EnumTypeExtensionNode {
185
-
readonly kind: Kind.ENUM_TYPE_EXTENSION;
186
-
readonly loc?: Location;
187
-
readonly name: NameNode;
188
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
189
-
readonly values?: ReadonlyArray<EnumValueDefinitionNode>;
190
-
}
235
+
export type UnionTypeExtensionNode = Or<
236
+
GraphQL.UnionTypeExtensionNode,
237
+
{
238
+
readonly kind: Kind.UNION_TYPE_EXTENSION;
239
+
readonly loc?: Location;
240
+
readonly name: NameNode;
241
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
242
+
readonly types?: ReadonlyArray<NamedTypeNode>;
243
+
}
244
+
>;
191
245
192
-
export interface InputObjectTypeExtensionNode {
193
-
readonly kind: Kind.INPUT_OBJECT_TYPE_EXTENSION;
194
-
readonly loc?: Location;
195
-
readonly name: NameNode;
196
-
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
197
-
readonly fields?: ReadonlyArray<InputValueDefinitionNode>;
198
-
}
246
+
export type EnumTypeExtensionNode = Or<
247
+
GraphQL.EnumTypeExtensionNode,
248
+
{
249
+
readonly kind: Kind.ENUM_TYPE_EXTENSION;
250
+
readonly loc?: Location;
251
+
readonly name: NameNode;
252
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
253
+
readonly values?: ReadonlyArray<EnumValueDefinitionNode>;
254
+
}
255
+
>;
256
+
257
+
export type InputObjectTypeExtensionNode = Or<
258
+
GraphQL.InputObjectTypeExtensionNode,
259
+
{
260
+
readonly kind: Kind.INPUT_OBJECT_TYPE_EXTENSION;
261
+
readonly loc?: Location;
262
+
readonly name: NameNode;
263
+
readonly directives?: ReadonlyArray<ConstDirectiveNode>;
264
+
readonly fields?: ReadonlyArray<InputValueDefinitionNode>;
265
+
}
266
+
>;