1
2
3 package followschema
4
5 import (
6 "bytes"
7 "context"
8 "embed"
9 "errors"
10 "fmt"
11 "sync/atomic"
12
13 "github.com/99designs/gqlgen/graphql"
14 "github.com/99designs/gqlgen/graphql/introspection"
15 gqlparser "github.com/vektah/gqlparser/v2"
16 "github.com/vektah/gqlparser/v2/ast"
17 )
18
19
20 func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
21 return &executableSchema{
22 schema: cfg.Schema,
23 resolvers: cfg.Resolvers,
24 directives: cfg.Directives,
25 complexity: cfg.Complexity,
26 }
27 }
28
29 type Config struct {
30 Schema *ast.Schema
31 Resolvers ResolverRoot
32 Directives DirectiveRoot
33 Complexity ComplexityRoot
34 }
35
36 type ResolverRoot interface {
37 BackedByInterface() BackedByInterfaceResolver
38 DeferModel() DeferModelResolver
39 Errors() ErrorsResolver
40 ForcedResolver() ForcedResolverResolver
41 ModelMethods() ModelMethodsResolver
42 Mutation() MutationResolver
43 OverlappingFields() OverlappingFieldsResolver
44 Panics() PanicsResolver
45 Pet() PetResolver
46 Primitive() PrimitiveResolver
47 PrimitiveString() PrimitiveStringResolver
48 Query() QueryResolver
49 Subscription() SubscriptionResolver
50 User() UserResolver
51 WrappedMap() WrappedMapResolver
52 WrappedSlice() WrappedSliceResolver
53 FieldsOrderInput() FieldsOrderInputResolver
54 }
55
56 type DirectiveRoot struct {
57 Custom func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
58 Defer func(ctx context.Context, obj interface{}, next graphql.Resolver, ifArg *bool, label *string) (res interface{}, err error)
59 Directive1 func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
60 Directive2 func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
61 Directive3 func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
62 Length func(ctx context.Context, obj interface{}, next graphql.Resolver, min int, max *int, message *string) (res interface{}, err error)
63 Logged func(ctx context.Context, obj interface{}, next graphql.Resolver, id string) (res interface{}, err error)
64 MakeNil func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
65 MakeTypedNil func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
66 Order1 func(ctx context.Context, obj interface{}, next graphql.Resolver, location string) (res interface{}, err error)
67 Order2 func(ctx context.Context, obj interface{}, next graphql.Resolver, location string) (res interface{}, err error)
68 Range func(ctx context.Context, obj interface{}, next graphql.Resolver, min *int, max *int) (res interface{}, err error)
69 ToNull func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
70 Unimplemented func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
71 }
72
73 type ComplexityRoot struct {
74 A struct {
75 ID func(childComplexity int) int
76 }
77
78 AIt struct {
79 ID func(childComplexity int) int
80 }
81
82 AbIt struct {
83 ID func(childComplexity int) int
84 }
85
86 Autobind struct {
87 IdInt func(childComplexity int) int
88 IdStr func(childComplexity int) int
89 Int func(childComplexity int) int
90 Int32 func(childComplexity int) int
91 Int64 func(childComplexity int) int
92 }
93
94 B struct {
95 ID func(childComplexity int) int
96 }
97
98 BackedByInterface struct {
99 ID func(childComplexity int) int
100 ThisShouldBind func(childComplexity int) int
101 ThisShouldBindWithError func(childComplexity int) int
102 }
103
104 Cat struct {
105 CatBreed func(childComplexity int) int
106 Size func(childComplexity int) int
107 Species func(childComplexity int) int
108 }
109
110 CheckIssue896 struct {
111 ID func(childComplexity int) int
112 }
113
114 Circle struct {
115 Area func(childComplexity int) int
116 Coordinates func(childComplexity int) int
117 Radius func(childComplexity int) int
118 }
119
120 ConcreteNodeA struct {
121 Child func(childComplexity int) int
122 ID func(childComplexity int) int
123 Name func(childComplexity int) int
124 }
125
126 ConcreteNodeInterface struct {
127 Child func(childComplexity int) int
128 ID func(childComplexity int) int
129 }
130
131 Content_Post struct {
132 Foo func(childComplexity int) int
133 }
134
135 Content_User struct {
136 Foo func(childComplexity int) int
137 }
138
139 Coordinates struct {
140 X func(childComplexity int) int
141 Y func(childComplexity int) int
142 }
143
144 DefaultParametersMirror struct {
145 FalsyBoolean func(childComplexity int) int
146 TruthyBoolean func(childComplexity int) int
147 }
148
149 DeferModel struct {
150 ID func(childComplexity int) int
151 Name func(childComplexity int) int
152 Values func(childComplexity int) int
153 }
154
155 Dog struct {
156 DogBreed func(childComplexity int) int
157 Size func(childComplexity int) int
158 Species func(childComplexity int) int
159 }
160
161 EmbeddedCase1 struct {
162 ExportedEmbeddedPointerExportedMethod func(childComplexity int) int
163 }
164
165 EmbeddedCase2 struct {
166 UnexportedEmbeddedPointerExportedMethod func(childComplexity int) int
167 }
168
169 EmbeddedCase3 struct {
170 UnexportedEmbeddedInterfaceExportedMethod func(childComplexity int) int
171 }
172
173 EmbeddedDefaultScalar struct {
174 Value func(childComplexity int) int
175 }
176
177 EmbeddedPointer struct {
178 ID func(childComplexity int) int
179 Title func(childComplexity int) int
180 }
181
182 Error struct {
183 ErrorOnNonRequiredField func(childComplexity int) int
184 ErrorOnRequiredField func(childComplexity int) int
185 ID func(childComplexity int) int
186 NilOnRequiredField func(childComplexity int) int
187 }
188
189 Errors struct {
190 A func(childComplexity int) int
191 B func(childComplexity int) int
192 C func(childComplexity int) int
193 D func(childComplexity int) int
194 E func(childComplexity int) int
195 }
196
197 FieldsOrderPayload struct {
198 FirstFieldValue func(childComplexity int) int
199 }
200
201 ForcedResolver struct {
202 Field func(childComplexity int) int
203 }
204
205 Horse struct {
206 HorseBreed func(childComplexity int) int
207 Size func(childComplexity int) int
208 Species func(childComplexity int) int
209 }
210
211 InnerObject struct {
212 ID func(childComplexity int) int
213 }
214
215 InvalidIdentifier struct {
216 ID func(childComplexity int) int
217 }
218
219 It struct {
220 ID func(childComplexity int) int
221 }
222
223 LoopA struct {
224 B func(childComplexity int) int
225 }
226
227 LoopB struct {
228 A func(childComplexity int) int
229 }
230
231 Map struct {
232 ID func(childComplexity int) int
233 }
234
235 MapNested struct {
236 Value func(childComplexity int) int
237 }
238
239 MapStringInterfaceType struct {
240 A func(childComplexity int) int
241 B func(childComplexity int) int
242 C func(childComplexity int) int
243 Nested func(childComplexity int) int
244 }
245
246 ModelMethods struct {
247 NoContext func(childComplexity int) int
248 ResolverField func(childComplexity int) int
249 WithContext func(childComplexity int) int
250 }
251
252 Mutation struct {
253 DefaultInput func(childComplexity int, input DefaultInput) int
254 OverrideValueViaInput func(childComplexity int, input FieldsOrderInput) int
255 UpdatePtrToPtr func(childComplexity int, input UpdatePtrToPtrOuter) int
256 UpdateSomething func(childComplexity int, input SpecialInput) int
257 }
258
259 ObjectDirectives struct {
260 NullableText func(childComplexity int) int
261 Order func(childComplexity int) int
262 Text func(childComplexity int) int
263 }
264
265 ObjectDirectivesWithCustomGoModel struct {
266 NullableText func(childComplexity int) int
267 }
268
269 OuterObject struct {
270 Inner func(childComplexity int) int
271 }
272
273 OverlappingFields struct {
274 Foo func(childComplexity int) int
275 NewFoo func(childComplexity int) int
276 OldFoo func(childComplexity int) int
277 }
278
279 Panics struct {
280 ArgUnmarshal func(childComplexity int, u []MarshalPanic) int
281 FieldFuncMarshal func(childComplexity int, u []MarshalPanic) int
282 FieldScalarMarshal func(childComplexity int) int
283 }
284
285 Pet struct {
286 Friends func(childComplexity int, limit *int) int
287 ID func(childComplexity int) int
288 }
289
290 Primitive struct {
291 Squared func(childComplexity int) int
292 Value func(childComplexity int) int
293 }
294
295 PrimitiveString struct {
296 Doubled func(childComplexity int) int
297 Len func(childComplexity int) int
298 Value func(childComplexity int) int
299 }
300
301 PtrToAnyContainer struct {
302 Binding func(childComplexity int) int
303 PtrToAny func(childComplexity int) int
304 }
305
306 PtrToPtrInner struct {
307 Key func(childComplexity int) int
308 Value func(childComplexity int) int
309 }
310
311 PtrToPtrOuter struct {
312 Inner func(childComplexity int) int
313 Name func(childComplexity int) int
314 StupidInner func(childComplexity int) int
315 }
316
317 PtrToSliceContainer struct {
318 PtrToSlice func(childComplexity int) int
319 }
320
321 Query struct {
322 Animal func(childComplexity int) int
323 Autobind func(childComplexity int) int
324 Collision func(childComplexity int) int
325 DefaultParameters func(childComplexity int, falsyBoolean *bool, truthyBoolean *bool) int
326 DefaultScalar func(childComplexity int, arg string) int
327 DeferCase1 func(childComplexity int) int
328 DeferCase2 func(childComplexity int) int
329 DeprecatedField func(childComplexity int) int
330 DirectiveArg func(childComplexity int, arg string) int
331 DirectiveDouble func(childComplexity int) int
332 DirectiveField func(childComplexity int) int
333 DirectiveFieldDef func(childComplexity int, ret string) int
334 DirectiveInput func(childComplexity int, arg InputDirectives) int
335 DirectiveInputNullable func(childComplexity int, arg *InputDirectives) int
336 DirectiveInputType func(childComplexity int, arg InnerInput) int
337 DirectiveNullableArg func(childComplexity int, arg *int, arg2 *int, arg3 *string) int
338 DirectiveObject func(childComplexity int) int
339 DirectiveObjectWithCustomGoModel func(childComplexity int) int
340 DirectiveUnimplemented func(childComplexity int) int
341 Dog func(childComplexity int) int
342 EmbeddedCase1 func(childComplexity int) int
343 EmbeddedCase2 func(childComplexity int) int
344 EmbeddedCase3 func(childComplexity int) int
345 EnumInInput func(childComplexity int, input *InputWithEnumValue) int
346 ErrorBubble func(childComplexity int) int
347 ErrorBubbleList func(childComplexity int) int
348 ErrorList func(childComplexity int) int
349 Errors func(childComplexity int) int
350 Fallback func(childComplexity int, arg FallbackToStringEncoding) int
351 Infinity func(childComplexity int) int
352 InputNullableSlice func(childComplexity int, arg []string) int
353 InputOmittable func(childComplexity int, arg OmittableInput) int
354 InputSlice func(childComplexity int, arg []string) int
355 Invalid func(childComplexity int) int
356 InvalidIdentifier func(childComplexity int) int
357 Issue896a func(childComplexity int) int
358 MapInput func(childComplexity int, input map[string]interface{}) int
359 MapNestedStringInterface func(childComplexity int, in *NestedMapInput) int
360 MapStringInterface func(childComplexity int, in map[string]interface{}) int
361 ModelMethods func(childComplexity int) int
362 NestedInputs func(childComplexity int, input [][]*OuterInput) int
363 NestedOutputs func(childComplexity int) int
364 NoShape func(childComplexity int) int
365 NoShapeTypedNil func(childComplexity int) int
366 Node func(childComplexity int) int
367 NotAnInterface func(childComplexity int) int
368 NullableArg func(childComplexity int, arg *int) int
369 OptionalUnion func(childComplexity int) int
370 Overlapping func(childComplexity int) int
371 Panics func(childComplexity int) int
372 PrimitiveObject func(childComplexity int) int
373 PrimitiveStringObject func(childComplexity int) int
374 PtrToAnyContainer func(childComplexity int) int
375 PtrToSliceContainer func(childComplexity int) int
376 Recursive func(childComplexity int, input *RecursiveInputSlice) int
377 ScalarSlice func(childComplexity int) int
378 ShapeUnion func(childComplexity int) int
379 Shapes func(childComplexity int) int
380 Slices func(childComplexity int) int
381 StringFromContextFunction func(childComplexity int) int
382 StringFromContextInterface func(childComplexity int) int
383 User func(childComplexity int, id int) int
384 VOkCaseNil func(childComplexity int) int
385 VOkCaseValue func(childComplexity int) int
386 Valid func(childComplexity int) int
387 ValidType func(childComplexity int) int
388 VariadicModel func(childComplexity int) int
389 WrappedMap func(childComplexity int) int
390 WrappedScalar func(childComplexity int) int
391 WrappedSlice func(childComplexity int) int
392 WrappedStruct func(childComplexity int) int
393 }
394
395 Rectangle struct {
396 Area func(childComplexity int) int
397 Coordinates func(childComplexity int) int
398 Length func(childComplexity int) int
399 Width func(childComplexity int) int
400 }
401
402 Size struct {
403 Height func(childComplexity int) int
404 Weight func(childComplexity int) int
405 }
406
407 Slices struct {
408 Test1 func(childComplexity int) int
409 Test2 func(childComplexity int) int
410 Test3 func(childComplexity int) int
411 Test4 func(childComplexity int) int
412 }
413
414 Subscription struct {
415 DirectiveArg func(childComplexity int, arg string) int
416 DirectiveDouble func(childComplexity int) int
417 DirectiveNullableArg func(childComplexity int, arg *int, arg2 *int, arg3 *string) int
418 DirectiveUnimplemented func(childComplexity int) int
419 ErrorRequired func(childComplexity int) int
420 InitPayload func(childComplexity int) int
421 Issue896b func(childComplexity int) int
422 Updated func(childComplexity int) int
423 }
424
425 User struct {
426 Created func(childComplexity int) int
427 Friends func(childComplexity int) int
428 ID func(childComplexity int) int
429 Pets func(childComplexity int, limit *int) int
430 Updated func(childComplexity int) int
431 }
432
433 VOkCaseNil struct {
434 Value func(childComplexity int) int
435 }
436
437 VOkCaseValue struct {
438 Value func(childComplexity int) int
439 }
440
441 ValidType struct {
442 DifferentCase func(childComplexity int) int
443 DifferentCaseOld func(childComplexity int) int
444 ValidArgs func(childComplexity int, breakArg string, defaultArg string, funcArg string, interfaceArg string, selectArg string, caseArg string, deferArg string, goArg string, mapArg string, structArg string, chanArg string, elseArg string, gotoArg string, packageArg string, switchArg string, constArg string, fallthroughArg string, ifArg string, rangeArg string, typeArg string, continueArg string, forArg string, importArg string, returnArg string, varArg string, _ string) int
445 ValidInputKeywords func(childComplexity int, input *ValidInput) int
446 }
447
448 VariadicModel struct {
449 Value func(childComplexity int, rank int) int
450 }
451
452 WrappedMap struct {
453 Get func(childComplexity int, key string) int
454 }
455
456 WrappedSlice struct {
457 Get func(childComplexity int, idx int) int
458 }
459
460 WrappedStruct struct {
461 Desc func(childComplexity int) int
462 Name func(childComplexity int) int
463 }
464
465 XXIt struct {
466 ID func(childComplexity int) int
467 }
468
469 XxIt struct {
470 ID func(childComplexity int) int
471 }
472
473 AsdfIt struct {
474 ID func(childComplexity int) int
475 }
476
477 IIt struct {
478 ID func(childComplexity int) int
479 }
480 }
481
482 type executableSchema struct {
483 schema *ast.Schema
484 resolvers ResolverRoot
485 directives DirectiveRoot
486 complexity ComplexityRoot
487 }
488
489 func (e *executableSchema) Schema() *ast.Schema {
490 if e.schema != nil {
491 return e.schema
492 }
493 return parsedSchema
494 }
495
496 func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
497 ec := executionContext{nil, e, 0, 0, nil}
498 _ = ec
499 switch typeName + "." + field {
500
501 case "A.id":
502 if e.complexity.A.ID == nil {
503 break
504 }
505
506 return e.complexity.A.ID(childComplexity), true
507
508 case "AIt.id":
509 if e.complexity.AIt.ID == nil {
510 break
511 }
512
513 return e.complexity.AIt.ID(childComplexity), true
514
515 case "AbIt.id":
516 if e.complexity.AbIt.ID == nil {
517 break
518 }
519
520 return e.complexity.AbIt.ID(childComplexity), true
521
522 case "Autobind.idInt":
523 if e.complexity.Autobind.IdInt == nil {
524 break
525 }
526
527 return e.complexity.Autobind.IdInt(childComplexity), true
528
529 case "Autobind.idStr":
530 if e.complexity.Autobind.IdStr == nil {
531 break
532 }
533
534 return e.complexity.Autobind.IdStr(childComplexity), true
535
536 case "Autobind.int":
537 if e.complexity.Autobind.Int == nil {
538 break
539 }
540
541 return e.complexity.Autobind.Int(childComplexity), true
542
543 case "Autobind.int32":
544 if e.complexity.Autobind.Int32 == nil {
545 break
546 }
547
548 return e.complexity.Autobind.Int32(childComplexity), true
549
550 case "Autobind.int64":
551 if e.complexity.Autobind.Int64 == nil {
552 break
553 }
554
555 return e.complexity.Autobind.Int64(childComplexity), true
556
557 case "B.id":
558 if e.complexity.B.ID == nil {
559 break
560 }
561
562 return e.complexity.B.ID(childComplexity), true
563
564 case "BackedByInterface.id":
565 if e.complexity.BackedByInterface.ID == nil {
566 break
567 }
568
569 return e.complexity.BackedByInterface.ID(childComplexity), true
570
571 case "BackedByInterface.thisShouldBind":
572 if e.complexity.BackedByInterface.ThisShouldBind == nil {
573 break
574 }
575
576 return e.complexity.BackedByInterface.ThisShouldBind(childComplexity), true
577
578 case "BackedByInterface.thisShouldBindWithError":
579 if e.complexity.BackedByInterface.ThisShouldBindWithError == nil {
580 break
581 }
582
583 return e.complexity.BackedByInterface.ThisShouldBindWithError(childComplexity), true
584
585 case "Cat.catBreed":
586 if e.complexity.Cat.CatBreed == nil {
587 break
588 }
589
590 return e.complexity.Cat.CatBreed(childComplexity), true
591
592 case "Cat.size":
593 if e.complexity.Cat.Size == nil {
594 break
595 }
596
597 return e.complexity.Cat.Size(childComplexity), true
598
599 case "Cat.species":
600 if e.complexity.Cat.Species == nil {
601 break
602 }
603
604 return e.complexity.Cat.Species(childComplexity), true
605
606 case "CheckIssue896.id":
607 if e.complexity.CheckIssue896.ID == nil {
608 break
609 }
610
611 return e.complexity.CheckIssue896.ID(childComplexity), true
612
613 case "Circle.area":
614 if e.complexity.Circle.Area == nil {
615 break
616 }
617
618 return e.complexity.Circle.Area(childComplexity), true
619
620 case "Circle.coordinates":
621 if e.complexity.Circle.Coordinates == nil {
622 break
623 }
624
625 return e.complexity.Circle.Coordinates(childComplexity), true
626
627 case "Circle.radius":
628 if e.complexity.Circle.Radius == nil {
629 break
630 }
631
632 return e.complexity.Circle.Radius(childComplexity), true
633
634 case "ConcreteNodeA.child":
635 if e.complexity.ConcreteNodeA.Child == nil {
636 break
637 }
638
639 return e.complexity.ConcreteNodeA.Child(childComplexity), true
640
641 case "ConcreteNodeA.id":
642 if e.complexity.ConcreteNodeA.ID == nil {
643 break
644 }
645
646 return e.complexity.ConcreteNodeA.ID(childComplexity), true
647
648 case "ConcreteNodeA.name":
649 if e.complexity.ConcreteNodeA.Name == nil {
650 break
651 }
652
653 return e.complexity.ConcreteNodeA.Name(childComplexity), true
654
655 case "ConcreteNodeInterface.child":
656 if e.complexity.ConcreteNodeInterface.Child == nil {
657 break
658 }
659
660 return e.complexity.ConcreteNodeInterface.Child(childComplexity), true
661
662 case "ConcreteNodeInterface.id":
663 if e.complexity.ConcreteNodeInterface.ID == nil {
664 break
665 }
666
667 return e.complexity.ConcreteNodeInterface.ID(childComplexity), true
668
669 case "Content_Post.foo":
670 if e.complexity.Content_Post.Foo == nil {
671 break
672 }
673
674 return e.complexity.Content_Post.Foo(childComplexity), true
675
676 case "Content_User.foo":
677 if e.complexity.Content_User.Foo == nil {
678 break
679 }
680
681 return e.complexity.Content_User.Foo(childComplexity), true
682
683 case "Coordinates.x":
684 if e.complexity.Coordinates.X == nil {
685 break
686 }
687
688 return e.complexity.Coordinates.X(childComplexity), true
689
690 case "Coordinates.y":
691 if e.complexity.Coordinates.Y == nil {
692 break
693 }
694
695 return e.complexity.Coordinates.Y(childComplexity), true
696
697 case "DefaultParametersMirror.falsyBoolean":
698 if e.complexity.DefaultParametersMirror.FalsyBoolean == nil {
699 break
700 }
701
702 return e.complexity.DefaultParametersMirror.FalsyBoolean(childComplexity), true
703
704 case "DefaultParametersMirror.truthyBoolean":
705 if e.complexity.DefaultParametersMirror.TruthyBoolean == nil {
706 break
707 }
708
709 return e.complexity.DefaultParametersMirror.TruthyBoolean(childComplexity), true
710
711 case "DeferModel.id":
712 if e.complexity.DeferModel.ID == nil {
713 break
714 }
715
716 return e.complexity.DeferModel.ID(childComplexity), true
717
718 case "DeferModel.name":
719 if e.complexity.DeferModel.Name == nil {
720 break
721 }
722
723 return e.complexity.DeferModel.Name(childComplexity), true
724
725 case "DeferModel.values":
726 if e.complexity.DeferModel.Values == nil {
727 break
728 }
729
730 return e.complexity.DeferModel.Values(childComplexity), true
731
732 case "Dog.dogBreed":
733 if e.complexity.Dog.DogBreed == nil {
734 break
735 }
736
737 return e.complexity.Dog.DogBreed(childComplexity), true
738
739 case "Dog.size":
740 if e.complexity.Dog.Size == nil {
741 break
742 }
743
744 return e.complexity.Dog.Size(childComplexity), true
745
746 case "Dog.species":
747 if e.complexity.Dog.Species == nil {
748 break
749 }
750
751 return e.complexity.Dog.Species(childComplexity), true
752
753 case "EmbeddedCase1.exportedEmbeddedPointerExportedMethod":
754 if e.complexity.EmbeddedCase1.ExportedEmbeddedPointerExportedMethod == nil {
755 break
756 }
757
758 return e.complexity.EmbeddedCase1.ExportedEmbeddedPointerExportedMethod(childComplexity), true
759
760 case "EmbeddedCase2.unexportedEmbeddedPointerExportedMethod":
761 if e.complexity.EmbeddedCase2.UnexportedEmbeddedPointerExportedMethod == nil {
762 break
763 }
764
765 return e.complexity.EmbeddedCase2.UnexportedEmbeddedPointerExportedMethod(childComplexity), true
766
767 case "EmbeddedCase3.unexportedEmbeddedInterfaceExportedMethod":
768 if e.complexity.EmbeddedCase3.UnexportedEmbeddedInterfaceExportedMethod == nil {
769 break
770 }
771
772 return e.complexity.EmbeddedCase3.UnexportedEmbeddedInterfaceExportedMethod(childComplexity), true
773
774 case "EmbeddedDefaultScalar.value":
775 if e.complexity.EmbeddedDefaultScalar.Value == nil {
776 break
777 }
778
779 return e.complexity.EmbeddedDefaultScalar.Value(childComplexity), true
780
781 case "EmbeddedPointer.ID":
782 if e.complexity.EmbeddedPointer.ID == nil {
783 break
784 }
785
786 return e.complexity.EmbeddedPointer.ID(childComplexity), true
787
788 case "EmbeddedPointer.Title":
789 if e.complexity.EmbeddedPointer.Title == nil {
790 break
791 }
792
793 return e.complexity.EmbeddedPointer.Title(childComplexity), true
794
795 case "Error.errorOnNonRequiredField":
796 if e.complexity.Error.ErrorOnNonRequiredField == nil {
797 break
798 }
799
800 return e.complexity.Error.ErrorOnNonRequiredField(childComplexity), true
801
802 case "Error.errorOnRequiredField":
803 if e.complexity.Error.ErrorOnRequiredField == nil {
804 break
805 }
806
807 return e.complexity.Error.ErrorOnRequiredField(childComplexity), true
808
809 case "Error.id":
810 if e.complexity.Error.ID == nil {
811 break
812 }
813
814 return e.complexity.Error.ID(childComplexity), true
815
816 case "Error.nilOnRequiredField":
817 if e.complexity.Error.NilOnRequiredField == nil {
818 break
819 }
820
821 return e.complexity.Error.NilOnRequiredField(childComplexity), true
822
823 case "Errors.a":
824 if e.complexity.Errors.A == nil {
825 break
826 }
827
828 return e.complexity.Errors.A(childComplexity), true
829
830 case "Errors.b":
831 if e.complexity.Errors.B == nil {
832 break
833 }
834
835 return e.complexity.Errors.B(childComplexity), true
836
837 case "Errors.c":
838 if e.complexity.Errors.C == nil {
839 break
840 }
841
842 return e.complexity.Errors.C(childComplexity), true
843
844 case "Errors.d":
845 if e.complexity.Errors.D == nil {
846 break
847 }
848
849 return e.complexity.Errors.D(childComplexity), true
850
851 case "Errors.e":
852 if e.complexity.Errors.E == nil {
853 break
854 }
855
856 return e.complexity.Errors.E(childComplexity), true
857
858 case "FieldsOrderPayload.firstFieldValue":
859 if e.complexity.FieldsOrderPayload.FirstFieldValue == nil {
860 break
861 }
862
863 return e.complexity.FieldsOrderPayload.FirstFieldValue(childComplexity), true
864
865 case "ForcedResolver.field":
866 if e.complexity.ForcedResolver.Field == nil {
867 break
868 }
869
870 return e.complexity.ForcedResolver.Field(childComplexity), true
871
872 case "Horse.horseBreed":
873 if e.complexity.Horse.HorseBreed == nil {
874 break
875 }
876
877 return e.complexity.Horse.HorseBreed(childComplexity), true
878
879 case "Horse.size":
880 if e.complexity.Horse.Size == nil {
881 break
882 }
883
884 return e.complexity.Horse.Size(childComplexity), true
885
886 case "Horse.species":
887 if e.complexity.Horse.Species == nil {
888 break
889 }
890
891 return e.complexity.Horse.Species(childComplexity), true
892
893 case "InnerObject.id":
894 if e.complexity.InnerObject.ID == nil {
895 break
896 }
897
898 return e.complexity.InnerObject.ID(childComplexity), true
899
900 case "InvalidIdentifier.id":
901 if e.complexity.InvalidIdentifier.ID == nil {
902 break
903 }
904
905 return e.complexity.InvalidIdentifier.ID(childComplexity), true
906
907 case "It.id":
908 if e.complexity.It.ID == nil {
909 break
910 }
911
912 return e.complexity.It.ID(childComplexity), true
913
914 case "LoopA.b":
915 if e.complexity.LoopA.B == nil {
916 break
917 }
918
919 return e.complexity.LoopA.B(childComplexity), true
920
921 case "LoopB.a":
922 if e.complexity.LoopB.A == nil {
923 break
924 }
925
926 return e.complexity.LoopB.A(childComplexity), true
927
928 case "Map.id":
929 if e.complexity.Map.ID == nil {
930 break
931 }
932
933 return e.complexity.Map.ID(childComplexity), true
934
935 case "MapNested.value":
936 if e.complexity.MapNested.Value == nil {
937 break
938 }
939
940 return e.complexity.MapNested.Value(childComplexity), true
941
942 case "MapStringInterfaceType.a":
943 if e.complexity.MapStringInterfaceType.A == nil {
944 break
945 }
946
947 return e.complexity.MapStringInterfaceType.A(childComplexity), true
948
949 case "MapStringInterfaceType.b":
950 if e.complexity.MapStringInterfaceType.B == nil {
951 break
952 }
953
954 return e.complexity.MapStringInterfaceType.B(childComplexity), true
955
956 case "MapStringInterfaceType.c":
957 if e.complexity.MapStringInterfaceType.C == nil {
958 break
959 }
960
961 return e.complexity.MapStringInterfaceType.C(childComplexity), true
962
963 case "MapStringInterfaceType.nested":
964 if e.complexity.MapStringInterfaceType.Nested == nil {
965 break
966 }
967
968 return e.complexity.MapStringInterfaceType.Nested(childComplexity), true
969
970 case "ModelMethods.noContext":
971 if e.complexity.ModelMethods.NoContext == nil {
972 break
973 }
974
975 return e.complexity.ModelMethods.NoContext(childComplexity), true
976
977 case "ModelMethods.resolverField":
978 if e.complexity.ModelMethods.ResolverField == nil {
979 break
980 }
981
982 return e.complexity.ModelMethods.ResolverField(childComplexity), true
983
984 case "ModelMethods.withContext":
985 if e.complexity.ModelMethods.WithContext == nil {
986 break
987 }
988
989 return e.complexity.ModelMethods.WithContext(childComplexity), true
990
991 case "Mutation.defaultInput":
992 if e.complexity.Mutation.DefaultInput == nil {
993 break
994 }
995
996 args, err := ec.field_Mutation_defaultInput_args(context.TODO(), rawArgs)
997 if err != nil {
998 return 0, false
999 }
1000
1001 return e.complexity.Mutation.DefaultInput(childComplexity, args["input"].(DefaultInput)), true
1002
1003 case "Mutation.overrideValueViaInput":
1004 if e.complexity.Mutation.OverrideValueViaInput == nil {
1005 break
1006 }
1007
1008 args, err := ec.field_Mutation_overrideValueViaInput_args(context.TODO(), rawArgs)
1009 if err != nil {
1010 return 0, false
1011 }
1012
1013 return e.complexity.Mutation.OverrideValueViaInput(childComplexity, args["input"].(FieldsOrderInput)), true
1014
1015 case "Mutation.updatePtrToPtr":
1016 if e.complexity.Mutation.UpdatePtrToPtr == nil {
1017 break
1018 }
1019
1020 args, err := ec.field_Mutation_updatePtrToPtr_args(context.TODO(), rawArgs)
1021 if err != nil {
1022 return 0, false
1023 }
1024
1025 return e.complexity.Mutation.UpdatePtrToPtr(childComplexity, args["input"].(UpdatePtrToPtrOuter)), true
1026
1027 case "Mutation.updateSomething":
1028 if e.complexity.Mutation.UpdateSomething == nil {
1029 break
1030 }
1031
1032 args, err := ec.field_Mutation_updateSomething_args(context.TODO(), rawArgs)
1033 if err != nil {
1034 return 0, false
1035 }
1036
1037 return e.complexity.Mutation.UpdateSomething(childComplexity, args["input"].(SpecialInput)), true
1038
1039 case "ObjectDirectives.nullableText":
1040 if e.complexity.ObjectDirectives.NullableText == nil {
1041 break
1042 }
1043
1044 return e.complexity.ObjectDirectives.NullableText(childComplexity), true
1045
1046 case "ObjectDirectives.order":
1047 if e.complexity.ObjectDirectives.Order == nil {
1048 break
1049 }
1050
1051 return e.complexity.ObjectDirectives.Order(childComplexity), true
1052
1053 case "ObjectDirectives.text":
1054 if e.complexity.ObjectDirectives.Text == nil {
1055 break
1056 }
1057
1058 return e.complexity.ObjectDirectives.Text(childComplexity), true
1059
1060 case "ObjectDirectivesWithCustomGoModel.nullableText":
1061 if e.complexity.ObjectDirectivesWithCustomGoModel.NullableText == nil {
1062 break
1063 }
1064
1065 return e.complexity.ObjectDirectivesWithCustomGoModel.NullableText(childComplexity), true
1066
1067 case "OuterObject.inner":
1068 if e.complexity.OuterObject.Inner == nil {
1069 break
1070 }
1071
1072 return e.complexity.OuterObject.Inner(childComplexity), true
1073
1074 case "OverlappingFields.oneFoo", "OverlappingFields.twoFoo":
1075 if e.complexity.OverlappingFields.Foo == nil {
1076 break
1077 }
1078
1079 return e.complexity.OverlappingFields.Foo(childComplexity), true
1080
1081 case "OverlappingFields.newFoo", "OverlappingFields.new_foo":
1082 if e.complexity.OverlappingFields.NewFoo == nil {
1083 break
1084 }
1085
1086 return e.complexity.OverlappingFields.NewFoo(childComplexity), true
1087
1088 case "OverlappingFields.oldFoo":
1089 if e.complexity.OverlappingFields.OldFoo == nil {
1090 break
1091 }
1092
1093 return e.complexity.OverlappingFields.OldFoo(childComplexity), true
1094
1095 case "Panics.argUnmarshal":
1096 if e.complexity.Panics.ArgUnmarshal == nil {
1097 break
1098 }
1099
1100 args, err := ec.field_Panics_argUnmarshal_args(context.TODO(), rawArgs)
1101 if err != nil {
1102 return 0, false
1103 }
1104
1105 return e.complexity.Panics.ArgUnmarshal(childComplexity, args["u"].([]MarshalPanic)), true
1106
1107 case "Panics.fieldFuncMarshal":
1108 if e.complexity.Panics.FieldFuncMarshal == nil {
1109 break
1110 }
1111
1112 args, err := ec.field_Panics_fieldFuncMarshal_args(context.TODO(), rawArgs)
1113 if err != nil {
1114 return 0, false
1115 }
1116
1117 return e.complexity.Panics.FieldFuncMarshal(childComplexity, args["u"].([]MarshalPanic)), true
1118
1119 case "Panics.fieldScalarMarshal":
1120 if e.complexity.Panics.FieldScalarMarshal == nil {
1121 break
1122 }
1123
1124 return e.complexity.Panics.FieldScalarMarshal(childComplexity), true
1125
1126 case "Pet.friends":
1127 if e.complexity.Pet.Friends == nil {
1128 break
1129 }
1130
1131 args, err := ec.field_Pet_friends_args(context.TODO(), rawArgs)
1132 if err != nil {
1133 return 0, false
1134 }
1135
1136 return e.complexity.Pet.Friends(childComplexity, args["limit"].(*int)), true
1137
1138 case "Pet.id":
1139 if e.complexity.Pet.ID == nil {
1140 break
1141 }
1142
1143 return e.complexity.Pet.ID(childComplexity), true
1144
1145 case "Primitive.squared":
1146 if e.complexity.Primitive.Squared == nil {
1147 break
1148 }
1149
1150 return e.complexity.Primitive.Squared(childComplexity), true
1151
1152 case "Primitive.value":
1153 if e.complexity.Primitive.Value == nil {
1154 break
1155 }
1156
1157 return e.complexity.Primitive.Value(childComplexity), true
1158
1159 case "PrimitiveString.doubled":
1160 if e.complexity.PrimitiveString.Doubled == nil {
1161 break
1162 }
1163
1164 return e.complexity.PrimitiveString.Doubled(childComplexity), true
1165
1166 case "PrimitiveString.len":
1167 if e.complexity.PrimitiveString.Len == nil {
1168 break
1169 }
1170
1171 return e.complexity.PrimitiveString.Len(childComplexity), true
1172
1173 case "PrimitiveString.value":
1174 if e.complexity.PrimitiveString.Value == nil {
1175 break
1176 }
1177
1178 return e.complexity.PrimitiveString.Value(childComplexity), true
1179
1180 case "PtrToAnyContainer.binding":
1181 if e.complexity.PtrToAnyContainer.Binding == nil {
1182 break
1183 }
1184
1185 return e.complexity.PtrToAnyContainer.Binding(childComplexity), true
1186
1187 case "PtrToAnyContainer.ptrToAny":
1188 if e.complexity.PtrToAnyContainer.PtrToAny == nil {
1189 break
1190 }
1191
1192 return e.complexity.PtrToAnyContainer.PtrToAny(childComplexity), true
1193
1194 case "PtrToPtrInner.key":
1195 if e.complexity.PtrToPtrInner.Key == nil {
1196 break
1197 }
1198
1199 return e.complexity.PtrToPtrInner.Key(childComplexity), true
1200
1201 case "PtrToPtrInner.value":
1202 if e.complexity.PtrToPtrInner.Value == nil {
1203 break
1204 }
1205
1206 return e.complexity.PtrToPtrInner.Value(childComplexity), true
1207
1208 case "PtrToPtrOuter.inner":
1209 if e.complexity.PtrToPtrOuter.Inner == nil {
1210 break
1211 }
1212
1213 return e.complexity.PtrToPtrOuter.Inner(childComplexity), true
1214
1215 case "PtrToPtrOuter.name":
1216 if e.complexity.PtrToPtrOuter.Name == nil {
1217 break
1218 }
1219
1220 return e.complexity.PtrToPtrOuter.Name(childComplexity), true
1221
1222 case "PtrToPtrOuter.stupidInner":
1223 if e.complexity.PtrToPtrOuter.StupidInner == nil {
1224 break
1225 }
1226
1227 return e.complexity.PtrToPtrOuter.StupidInner(childComplexity), true
1228
1229 case "PtrToSliceContainer.ptrToSlice":
1230 if e.complexity.PtrToSliceContainer.PtrToSlice == nil {
1231 break
1232 }
1233
1234 return e.complexity.PtrToSliceContainer.PtrToSlice(childComplexity), true
1235
1236 case "Query.animal":
1237 if e.complexity.Query.Animal == nil {
1238 break
1239 }
1240
1241 return e.complexity.Query.Animal(childComplexity), true
1242
1243 case "Query.autobind":
1244 if e.complexity.Query.Autobind == nil {
1245 break
1246 }
1247
1248 return e.complexity.Query.Autobind(childComplexity), true
1249
1250 case "Query.collision":
1251 if e.complexity.Query.Collision == nil {
1252 break
1253 }
1254
1255 return e.complexity.Query.Collision(childComplexity), true
1256
1257 case "Query.defaultParameters":
1258 if e.complexity.Query.DefaultParameters == nil {
1259 break
1260 }
1261
1262 args, err := ec.field_Query_defaultParameters_args(context.TODO(), rawArgs)
1263 if err != nil {
1264 return 0, false
1265 }
1266
1267 return e.complexity.Query.DefaultParameters(childComplexity, args["falsyBoolean"].(*bool), args["truthyBoolean"].(*bool)), true
1268
1269 case "Query.defaultScalar":
1270 if e.complexity.Query.DefaultScalar == nil {
1271 break
1272 }
1273
1274 args, err := ec.field_Query_defaultScalar_args(context.TODO(), rawArgs)
1275 if err != nil {
1276 return 0, false
1277 }
1278
1279 return e.complexity.Query.DefaultScalar(childComplexity, args["arg"].(string)), true
1280
1281 case "Query.deferCase1":
1282 if e.complexity.Query.DeferCase1 == nil {
1283 break
1284 }
1285
1286 return e.complexity.Query.DeferCase1(childComplexity), true
1287
1288 case "Query.deferCase2":
1289 if e.complexity.Query.DeferCase2 == nil {
1290 break
1291 }
1292
1293 return e.complexity.Query.DeferCase2(childComplexity), true
1294
1295 case "Query.deprecatedField":
1296 if e.complexity.Query.DeprecatedField == nil {
1297 break
1298 }
1299
1300 return e.complexity.Query.DeprecatedField(childComplexity), true
1301
1302 case "Query.directiveArg":
1303 if e.complexity.Query.DirectiveArg == nil {
1304 break
1305 }
1306
1307 args, err := ec.field_Query_directiveArg_args(context.TODO(), rawArgs)
1308 if err != nil {
1309 return 0, false
1310 }
1311
1312 return e.complexity.Query.DirectiveArg(childComplexity, args["arg"].(string)), true
1313
1314 case "Query.directiveDouble":
1315 if e.complexity.Query.DirectiveDouble == nil {
1316 break
1317 }
1318
1319 return e.complexity.Query.DirectiveDouble(childComplexity), true
1320
1321 case "Query.directiveField":
1322 if e.complexity.Query.DirectiveField == nil {
1323 break
1324 }
1325
1326 return e.complexity.Query.DirectiveField(childComplexity), true
1327
1328 case "Query.directiveFieldDef":
1329 if e.complexity.Query.DirectiveFieldDef == nil {
1330 break
1331 }
1332
1333 args, err := ec.field_Query_directiveFieldDef_args(context.TODO(), rawArgs)
1334 if err != nil {
1335 return 0, false
1336 }
1337
1338 return e.complexity.Query.DirectiveFieldDef(childComplexity, args["ret"].(string)), true
1339
1340 case "Query.directiveInput":
1341 if e.complexity.Query.DirectiveInput == nil {
1342 break
1343 }
1344
1345 args, err := ec.field_Query_directiveInput_args(context.TODO(), rawArgs)
1346 if err != nil {
1347 return 0, false
1348 }
1349
1350 return e.complexity.Query.DirectiveInput(childComplexity, args["arg"].(InputDirectives)), true
1351
1352 case "Query.directiveInputNullable":
1353 if e.complexity.Query.DirectiveInputNullable == nil {
1354 break
1355 }
1356
1357 args, err := ec.field_Query_directiveInputNullable_args(context.TODO(), rawArgs)
1358 if err != nil {
1359 return 0, false
1360 }
1361
1362 return e.complexity.Query.DirectiveInputNullable(childComplexity, args["arg"].(*InputDirectives)), true
1363
1364 case "Query.directiveInputType":
1365 if e.complexity.Query.DirectiveInputType == nil {
1366 break
1367 }
1368
1369 args, err := ec.field_Query_directiveInputType_args(context.TODO(), rawArgs)
1370 if err != nil {
1371 return 0, false
1372 }
1373
1374 return e.complexity.Query.DirectiveInputType(childComplexity, args["arg"].(InnerInput)), true
1375
1376 case "Query.directiveNullableArg":
1377 if e.complexity.Query.DirectiveNullableArg == nil {
1378 break
1379 }
1380
1381 args, err := ec.field_Query_directiveNullableArg_args(context.TODO(), rawArgs)
1382 if err != nil {
1383 return 0, false
1384 }
1385
1386 return e.complexity.Query.DirectiveNullableArg(childComplexity, args["arg"].(*int), args["arg2"].(*int), args["arg3"].(*string)), true
1387
1388 case "Query.directiveObject":
1389 if e.complexity.Query.DirectiveObject == nil {
1390 break
1391 }
1392
1393 return e.complexity.Query.DirectiveObject(childComplexity), true
1394
1395 case "Query.directiveObjectWithCustomGoModel":
1396 if e.complexity.Query.DirectiveObjectWithCustomGoModel == nil {
1397 break
1398 }
1399
1400 return e.complexity.Query.DirectiveObjectWithCustomGoModel(childComplexity), true
1401
1402 case "Query.directiveUnimplemented":
1403 if e.complexity.Query.DirectiveUnimplemented == nil {
1404 break
1405 }
1406
1407 return e.complexity.Query.DirectiveUnimplemented(childComplexity), true
1408
1409 case "Query.dog":
1410 if e.complexity.Query.Dog == nil {
1411 break
1412 }
1413
1414 return e.complexity.Query.Dog(childComplexity), true
1415
1416 case "Query.embeddedCase1":
1417 if e.complexity.Query.EmbeddedCase1 == nil {
1418 break
1419 }
1420
1421 return e.complexity.Query.EmbeddedCase1(childComplexity), true
1422
1423 case "Query.embeddedCase2":
1424 if e.complexity.Query.EmbeddedCase2 == nil {
1425 break
1426 }
1427
1428 return e.complexity.Query.EmbeddedCase2(childComplexity), true
1429
1430 case "Query.embeddedCase3":
1431 if e.complexity.Query.EmbeddedCase3 == nil {
1432 break
1433 }
1434
1435 return e.complexity.Query.EmbeddedCase3(childComplexity), true
1436
1437 case "Query.enumInInput":
1438 if e.complexity.Query.EnumInInput == nil {
1439 break
1440 }
1441
1442 args, err := ec.field_Query_enumInInput_args(context.TODO(), rawArgs)
1443 if err != nil {
1444 return 0, false
1445 }
1446
1447 return e.complexity.Query.EnumInInput(childComplexity, args["input"].(*InputWithEnumValue)), true
1448
1449 case "Query.errorBubble":
1450 if e.complexity.Query.ErrorBubble == nil {
1451 break
1452 }
1453
1454 return e.complexity.Query.ErrorBubble(childComplexity), true
1455
1456 case "Query.errorBubbleList":
1457 if e.complexity.Query.ErrorBubbleList == nil {
1458 break
1459 }
1460
1461 return e.complexity.Query.ErrorBubbleList(childComplexity), true
1462
1463 case "Query.errorList":
1464 if e.complexity.Query.ErrorList == nil {
1465 break
1466 }
1467
1468 return e.complexity.Query.ErrorList(childComplexity), true
1469
1470 case "Query.errors":
1471 if e.complexity.Query.Errors == nil {
1472 break
1473 }
1474
1475 return e.complexity.Query.Errors(childComplexity), true
1476
1477 case "Query.fallback":
1478 if e.complexity.Query.Fallback == nil {
1479 break
1480 }
1481
1482 args, err := ec.field_Query_fallback_args(context.TODO(), rawArgs)
1483 if err != nil {
1484 return 0, false
1485 }
1486
1487 return e.complexity.Query.Fallback(childComplexity, args["arg"].(FallbackToStringEncoding)), true
1488
1489 case "Query.infinity":
1490 if e.complexity.Query.Infinity == nil {
1491 break
1492 }
1493
1494 return e.complexity.Query.Infinity(childComplexity), true
1495
1496 case "Query.inputNullableSlice":
1497 if e.complexity.Query.InputNullableSlice == nil {
1498 break
1499 }
1500
1501 args, err := ec.field_Query_inputNullableSlice_args(context.TODO(), rawArgs)
1502 if err != nil {
1503 return 0, false
1504 }
1505
1506 return e.complexity.Query.InputNullableSlice(childComplexity, args["arg"].([]string)), true
1507
1508 case "Query.inputOmittable":
1509 if e.complexity.Query.InputOmittable == nil {
1510 break
1511 }
1512
1513 args, err := ec.field_Query_inputOmittable_args(context.TODO(), rawArgs)
1514 if err != nil {
1515 return 0, false
1516 }
1517
1518 return e.complexity.Query.InputOmittable(childComplexity, args["arg"].(OmittableInput)), true
1519
1520 case "Query.inputSlice":
1521 if e.complexity.Query.InputSlice == nil {
1522 break
1523 }
1524
1525 args, err := ec.field_Query_inputSlice_args(context.TODO(), rawArgs)
1526 if err != nil {
1527 return 0, false
1528 }
1529
1530 return e.complexity.Query.InputSlice(childComplexity, args["arg"].([]string)), true
1531
1532 case "Query.invalid":
1533 if e.complexity.Query.Invalid == nil {
1534 break
1535 }
1536
1537 return e.complexity.Query.Invalid(childComplexity), true
1538
1539 case "Query.invalidIdentifier":
1540 if e.complexity.Query.InvalidIdentifier == nil {
1541 break
1542 }
1543
1544 return e.complexity.Query.InvalidIdentifier(childComplexity), true
1545
1546 case "Query.issue896a":
1547 if e.complexity.Query.Issue896a == nil {
1548 break
1549 }
1550
1551 return e.complexity.Query.Issue896a(childComplexity), true
1552
1553 case "Query.mapInput":
1554 if e.complexity.Query.MapInput == nil {
1555 break
1556 }
1557
1558 args, err := ec.field_Query_mapInput_args(context.TODO(), rawArgs)
1559 if err != nil {
1560 return 0, false
1561 }
1562
1563 return e.complexity.Query.MapInput(childComplexity, args["input"].(map[string]interface{})), true
1564
1565 case "Query.mapNestedStringInterface":
1566 if e.complexity.Query.MapNestedStringInterface == nil {
1567 break
1568 }
1569
1570 args, err := ec.field_Query_mapNestedStringInterface_args(context.TODO(), rawArgs)
1571 if err != nil {
1572 return 0, false
1573 }
1574
1575 return e.complexity.Query.MapNestedStringInterface(childComplexity, args["in"].(*NestedMapInput)), true
1576
1577 case "Query.mapStringInterface":
1578 if e.complexity.Query.MapStringInterface == nil {
1579 break
1580 }
1581
1582 args, err := ec.field_Query_mapStringInterface_args(context.TODO(), rawArgs)
1583 if err != nil {
1584 return 0, false
1585 }
1586
1587 return e.complexity.Query.MapStringInterface(childComplexity, args["in"].(map[string]interface{})), true
1588
1589 case "Query.modelMethods":
1590 if e.complexity.Query.ModelMethods == nil {
1591 break
1592 }
1593
1594 return e.complexity.Query.ModelMethods(childComplexity), true
1595
1596 case "Query.nestedInputs":
1597 if e.complexity.Query.NestedInputs == nil {
1598 break
1599 }
1600
1601 args, err := ec.field_Query_nestedInputs_args(context.TODO(), rawArgs)
1602 if err != nil {
1603 return 0, false
1604 }
1605
1606 return e.complexity.Query.NestedInputs(childComplexity, args["input"].([][]*OuterInput)), true
1607
1608 case "Query.nestedOutputs":
1609 if e.complexity.Query.NestedOutputs == nil {
1610 break
1611 }
1612
1613 return e.complexity.Query.NestedOutputs(childComplexity), true
1614
1615 case "Query.noShape":
1616 if e.complexity.Query.NoShape == nil {
1617 break
1618 }
1619
1620 return e.complexity.Query.NoShape(childComplexity), true
1621
1622 case "Query.noShapeTypedNil":
1623 if e.complexity.Query.NoShapeTypedNil == nil {
1624 break
1625 }
1626
1627 return e.complexity.Query.NoShapeTypedNil(childComplexity), true
1628
1629 case "Query.node":
1630 if e.complexity.Query.Node == nil {
1631 break
1632 }
1633
1634 return e.complexity.Query.Node(childComplexity), true
1635
1636 case "Query.notAnInterface":
1637 if e.complexity.Query.NotAnInterface == nil {
1638 break
1639 }
1640
1641 return e.complexity.Query.NotAnInterface(childComplexity), true
1642
1643 case "Query.nullableArg":
1644 if e.complexity.Query.NullableArg == nil {
1645 break
1646 }
1647
1648 args, err := ec.field_Query_nullableArg_args(context.TODO(), rawArgs)
1649 if err != nil {
1650 return 0, false
1651 }
1652
1653 return e.complexity.Query.NullableArg(childComplexity, args["arg"].(*int)), true
1654
1655 case "Query.optionalUnion":
1656 if e.complexity.Query.OptionalUnion == nil {
1657 break
1658 }
1659
1660 return e.complexity.Query.OptionalUnion(childComplexity), true
1661
1662 case "Query.overlapping":
1663 if e.complexity.Query.Overlapping == nil {
1664 break
1665 }
1666
1667 return e.complexity.Query.Overlapping(childComplexity), true
1668
1669 case "Query.panics":
1670 if e.complexity.Query.Panics == nil {
1671 break
1672 }
1673
1674 return e.complexity.Query.Panics(childComplexity), true
1675
1676 case "Query.primitiveObject":
1677 if e.complexity.Query.PrimitiveObject == nil {
1678 break
1679 }
1680
1681 return e.complexity.Query.PrimitiveObject(childComplexity), true
1682
1683 case "Query.primitiveStringObject":
1684 if e.complexity.Query.PrimitiveStringObject == nil {
1685 break
1686 }
1687
1688 return e.complexity.Query.PrimitiveStringObject(childComplexity), true
1689
1690 case "Query.ptrToAnyContainer":
1691 if e.complexity.Query.PtrToAnyContainer == nil {
1692 break
1693 }
1694
1695 return e.complexity.Query.PtrToAnyContainer(childComplexity), true
1696
1697 case "Query.ptrToSliceContainer":
1698 if e.complexity.Query.PtrToSliceContainer == nil {
1699 break
1700 }
1701
1702 return e.complexity.Query.PtrToSliceContainer(childComplexity), true
1703
1704 case "Query.recursive":
1705 if e.complexity.Query.Recursive == nil {
1706 break
1707 }
1708
1709 args, err := ec.field_Query_recursive_args(context.TODO(), rawArgs)
1710 if err != nil {
1711 return 0, false
1712 }
1713
1714 return e.complexity.Query.Recursive(childComplexity, args["input"].(*RecursiveInputSlice)), true
1715
1716 case "Query.scalarSlice":
1717 if e.complexity.Query.ScalarSlice == nil {
1718 break
1719 }
1720
1721 return e.complexity.Query.ScalarSlice(childComplexity), true
1722
1723 case "Query.shapeUnion":
1724 if e.complexity.Query.ShapeUnion == nil {
1725 break
1726 }
1727
1728 return e.complexity.Query.ShapeUnion(childComplexity), true
1729
1730 case "Query.shapes":
1731 if e.complexity.Query.Shapes == nil {
1732 break
1733 }
1734
1735 return e.complexity.Query.Shapes(childComplexity), true
1736
1737 case "Query.slices":
1738 if e.complexity.Query.Slices == nil {
1739 break
1740 }
1741
1742 return e.complexity.Query.Slices(childComplexity), true
1743
1744 case "Query.stringFromContextFunction":
1745 if e.complexity.Query.StringFromContextFunction == nil {
1746 break
1747 }
1748
1749 return e.complexity.Query.StringFromContextFunction(childComplexity), true
1750
1751 case "Query.stringFromContextInterface":
1752 if e.complexity.Query.StringFromContextInterface == nil {
1753 break
1754 }
1755
1756 return e.complexity.Query.StringFromContextInterface(childComplexity), true
1757
1758 case "Query.user":
1759 if e.complexity.Query.User == nil {
1760 break
1761 }
1762
1763 args, err := ec.field_Query_user_args(context.TODO(), rawArgs)
1764 if err != nil {
1765 return 0, false
1766 }
1767
1768 return e.complexity.Query.User(childComplexity, args["id"].(int)), true
1769
1770 case "Query.vOkCaseNil":
1771 if e.complexity.Query.VOkCaseNil == nil {
1772 break
1773 }
1774
1775 return e.complexity.Query.VOkCaseNil(childComplexity), true
1776
1777 case "Query.vOkCaseValue":
1778 if e.complexity.Query.VOkCaseValue == nil {
1779 break
1780 }
1781
1782 return e.complexity.Query.VOkCaseValue(childComplexity), true
1783
1784 case "Query.valid":
1785 if e.complexity.Query.Valid == nil {
1786 break
1787 }
1788
1789 return e.complexity.Query.Valid(childComplexity), true
1790
1791 case "Query.validType":
1792 if e.complexity.Query.ValidType == nil {
1793 break
1794 }
1795
1796 return e.complexity.Query.ValidType(childComplexity), true
1797
1798 case "Query.variadicModel":
1799 if e.complexity.Query.VariadicModel == nil {
1800 break
1801 }
1802
1803 return e.complexity.Query.VariadicModel(childComplexity), true
1804
1805 case "Query.wrappedMap":
1806 if e.complexity.Query.WrappedMap == nil {
1807 break
1808 }
1809
1810 return e.complexity.Query.WrappedMap(childComplexity), true
1811
1812 case "Query.wrappedScalar":
1813 if e.complexity.Query.WrappedScalar == nil {
1814 break
1815 }
1816
1817 return e.complexity.Query.WrappedScalar(childComplexity), true
1818
1819 case "Query.wrappedSlice":
1820 if e.complexity.Query.WrappedSlice == nil {
1821 break
1822 }
1823
1824 return e.complexity.Query.WrappedSlice(childComplexity), true
1825
1826 case "Query.wrappedStruct":
1827 if e.complexity.Query.WrappedStruct == nil {
1828 break
1829 }
1830
1831 return e.complexity.Query.WrappedStruct(childComplexity), true
1832
1833 case "Rectangle.area":
1834 if e.complexity.Rectangle.Area == nil {
1835 break
1836 }
1837
1838 return e.complexity.Rectangle.Area(childComplexity), true
1839
1840 case "Rectangle.coordinates":
1841 if e.complexity.Rectangle.Coordinates == nil {
1842 break
1843 }
1844
1845 return e.complexity.Rectangle.Coordinates(childComplexity), true
1846
1847 case "Rectangle.length":
1848 if e.complexity.Rectangle.Length == nil {
1849 break
1850 }
1851
1852 return e.complexity.Rectangle.Length(childComplexity), true
1853
1854 case "Rectangle.width":
1855 if e.complexity.Rectangle.Width == nil {
1856 break
1857 }
1858
1859 return e.complexity.Rectangle.Width(childComplexity), true
1860
1861 case "Size.height":
1862 if e.complexity.Size.Height == nil {
1863 break
1864 }
1865
1866 return e.complexity.Size.Height(childComplexity), true
1867
1868 case "Size.weight":
1869 if e.complexity.Size.Weight == nil {
1870 break
1871 }
1872
1873 return e.complexity.Size.Weight(childComplexity), true
1874
1875 case "Slices.test1":
1876 if e.complexity.Slices.Test1 == nil {
1877 break
1878 }
1879
1880 return e.complexity.Slices.Test1(childComplexity), true
1881
1882 case "Slices.test2":
1883 if e.complexity.Slices.Test2 == nil {
1884 break
1885 }
1886
1887 return e.complexity.Slices.Test2(childComplexity), true
1888
1889 case "Slices.test3":
1890 if e.complexity.Slices.Test3 == nil {
1891 break
1892 }
1893
1894 return e.complexity.Slices.Test3(childComplexity), true
1895
1896 case "Slices.test4":
1897 if e.complexity.Slices.Test4 == nil {
1898 break
1899 }
1900
1901 return e.complexity.Slices.Test4(childComplexity), true
1902
1903 case "Subscription.directiveArg":
1904 if e.complexity.Subscription.DirectiveArg == nil {
1905 break
1906 }
1907
1908 args, err := ec.field_Subscription_directiveArg_args(context.TODO(), rawArgs)
1909 if err != nil {
1910 return 0, false
1911 }
1912
1913 return e.complexity.Subscription.DirectiveArg(childComplexity, args["arg"].(string)), true
1914
1915 case "Subscription.directiveDouble":
1916 if e.complexity.Subscription.DirectiveDouble == nil {
1917 break
1918 }
1919
1920 return e.complexity.Subscription.DirectiveDouble(childComplexity), true
1921
1922 case "Subscription.directiveNullableArg":
1923 if e.complexity.Subscription.DirectiveNullableArg == nil {
1924 break
1925 }
1926
1927 args, err := ec.field_Subscription_directiveNullableArg_args(context.TODO(), rawArgs)
1928 if err != nil {
1929 return 0, false
1930 }
1931
1932 return e.complexity.Subscription.DirectiveNullableArg(childComplexity, args["arg"].(*int), args["arg2"].(*int), args["arg3"].(*string)), true
1933
1934 case "Subscription.directiveUnimplemented":
1935 if e.complexity.Subscription.DirectiveUnimplemented == nil {
1936 break
1937 }
1938
1939 return e.complexity.Subscription.DirectiveUnimplemented(childComplexity), true
1940
1941 case "Subscription.errorRequired":
1942 if e.complexity.Subscription.ErrorRequired == nil {
1943 break
1944 }
1945
1946 return e.complexity.Subscription.ErrorRequired(childComplexity), true
1947
1948 case "Subscription.initPayload":
1949 if e.complexity.Subscription.InitPayload == nil {
1950 break
1951 }
1952
1953 return e.complexity.Subscription.InitPayload(childComplexity), true
1954
1955 case "Subscription.issue896b":
1956 if e.complexity.Subscription.Issue896b == nil {
1957 break
1958 }
1959
1960 return e.complexity.Subscription.Issue896b(childComplexity), true
1961
1962 case "Subscription.updated":
1963 if e.complexity.Subscription.Updated == nil {
1964 break
1965 }
1966
1967 return e.complexity.Subscription.Updated(childComplexity), true
1968
1969 case "User.created":
1970 if e.complexity.User.Created == nil {
1971 break
1972 }
1973
1974 return e.complexity.User.Created(childComplexity), true
1975
1976 case "User.friends":
1977 if e.complexity.User.Friends == nil {
1978 break
1979 }
1980
1981 return e.complexity.User.Friends(childComplexity), true
1982
1983 case "User.id":
1984 if e.complexity.User.ID == nil {
1985 break
1986 }
1987
1988 return e.complexity.User.ID(childComplexity), true
1989
1990 case "User.pets":
1991 if e.complexity.User.Pets == nil {
1992 break
1993 }
1994
1995 args, err := ec.field_User_pets_args(context.TODO(), rawArgs)
1996 if err != nil {
1997 return 0, false
1998 }
1999
2000 return e.complexity.User.Pets(childComplexity, args["limit"].(*int)), true
2001
2002 case "User.updated":
2003 if e.complexity.User.Updated == nil {
2004 break
2005 }
2006
2007 return e.complexity.User.Updated(childComplexity), true
2008
2009 case "VOkCaseNil.value":
2010 if e.complexity.VOkCaseNil.Value == nil {
2011 break
2012 }
2013
2014 return e.complexity.VOkCaseNil.Value(childComplexity), true
2015
2016 case "VOkCaseValue.value":
2017 if e.complexity.VOkCaseValue.Value == nil {
2018 break
2019 }
2020
2021 return e.complexity.VOkCaseValue.Value(childComplexity), true
2022
2023 case "ValidType.differentCase":
2024 if e.complexity.ValidType.DifferentCase == nil {
2025 break
2026 }
2027
2028 return e.complexity.ValidType.DifferentCase(childComplexity), true
2029
2030 case "ValidType.different_case":
2031 if e.complexity.ValidType.DifferentCaseOld == nil {
2032 break
2033 }
2034
2035 return e.complexity.ValidType.DifferentCaseOld(childComplexity), true
2036
2037 case "ValidType.validArgs":
2038 if e.complexity.ValidType.ValidArgs == nil {
2039 break
2040 }
2041
2042 args, err := ec.field_ValidType_validArgs_args(context.TODO(), rawArgs)
2043 if err != nil {
2044 return 0, false
2045 }
2046
2047 return e.complexity.ValidType.ValidArgs(childComplexity, args["break"].(string), args["default"].(string), args["func"].(string), args["interface"].(string), args["select"].(string), args["case"].(string), args["defer"].(string), args["go"].(string), args["map"].(string), args["struct"].(string), args["chan"].(string), args["else"].(string), args["goto"].(string), args["package"].(string), args["switch"].(string), args["const"].(string), args["fallthrough"].(string), args["if"].(string), args["range"].(string), args["type"].(string), args["continue"].(string), args["for"].(string), args["import"].(string), args["return"].(string), args["var"].(string), args["_"].(string)), true
2048
2049 case "ValidType.validInputKeywords":
2050 if e.complexity.ValidType.ValidInputKeywords == nil {
2051 break
2052 }
2053
2054 args, err := ec.field_ValidType_validInputKeywords_args(context.TODO(), rawArgs)
2055 if err != nil {
2056 return 0, false
2057 }
2058
2059 return e.complexity.ValidType.ValidInputKeywords(childComplexity, args["input"].(*ValidInput)), true
2060
2061 case "VariadicModel.value":
2062 if e.complexity.VariadicModel.Value == nil {
2063 break
2064 }
2065
2066 args, err := ec.field_VariadicModel_value_args(context.TODO(), rawArgs)
2067 if err != nil {
2068 return 0, false
2069 }
2070
2071 return e.complexity.VariadicModel.Value(childComplexity, args["rank"].(int)), true
2072
2073 case "WrappedMap.get":
2074 if e.complexity.WrappedMap.Get == nil {
2075 break
2076 }
2077
2078 args, err := ec.field_WrappedMap_get_args(context.TODO(), rawArgs)
2079 if err != nil {
2080 return 0, false
2081 }
2082
2083 return e.complexity.WrappedMap.Get(childComplexity, args["key"].(string)), true
2084
2085 case "WrappedSlice.get":
2086 if e.complexity.WrappedSlice.Get == nil {
2087 break
2088 }
2089
2090 args, err := ec.field_WrappedSlice_get_args(context.TODO(), rawArgs)
2091 if err != nil {
2092 return 0, false
2093 }
2094
2095 return e.complexity.WrappedSlice.Get(childComplexity, args["idx"].(int)), true
2096
2097 case "WrappedStruct.desc":
2098 if e.complexity.WrappedStruct.Desc == nil {
2099 break
2100 }
2101
2102 return e.complexity.WrappedStruct.Desc(childComplexity), true
2103
2104 case "WrappedStruct.name":
2105 if e.complexity.WrappedStruct.Name == nil {
2106 break
2107 }
2108
2109 return e.complexity.WrappedStruct.Name(childComplexity), true
2110
2111 case "XXIt.id":
2112 if e.complexity.XXIt.ID == nil {
2113 break
2114 }
2115
2116 return e.complexity.XXIt.ID(childComplexity), true
2117
2118 case "XxIt.id":
2119 if e.complexity.XxIt.ID == nil {
2120 break
2121 }
2122
2123 return e.complexity.XxIt.ID(childComplexity), true
2124
2125 case "asdfIt.id":
2126 if e.complexity.AsdfIt.ID == nil {
2127 break
2128 }
2129
2130 return e.complexity.AsdfIt.ID(childComplexity), true
2131
2132 case "iIt.id":
2133 if e.complexity.IIt.ID == nil {
2134 break
2135 }
2136
2137 return e.complexity.IIt.ID(childComplexity), true
2138
2139 }
2140 return 0, false
2141 }
2142
2143 func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
2144 rc := graphql.GetOperationContext(ctx)
2145 ec := executionContext{rc, e, 0, 0, make(chan graphql.DeferredResult)}
2146 inputUnmarshalMap := graphql.BuildUnmarshalerMap(
2147 ec.unmarshalInputChanges,
2148 ec.unmarshalInputDefaultInput,
2149 ec.unmarshalInputFieldsOrderInput,
2150 ec.unmarshalInputInnerDirectives,
2151 ec.unmarshalInputInnerInput,
2152 ec.unmarshalInputInputDirectives,
2153 ec.unmarshalInputInputWithEnumValue,
2154 ec.unmarshalInputMapNestedInput,
2155 ec.unmarshalInputMapStringInterfaceInput,
2156 ec.unmarshalInputNestedInput,
2157 ec.unmarshalInputNestedMapInput,
2158 ec.unmarshalInputOmittableInput,
2159 ec.unmarshalInputOuterInput,
2160 ec.unmarshalInputRecursiveInputSlice,
2161 ec.unmarshalInputSpecialInput,
2162 ec.unmarshalInputUpdatePtrToPtrInner,
2163 ec.unmarshalInputUpdatePtrToPtrOuter,
2164 ec.unmarshalInputValidInput,
2165 )
2166 first := true
2167
2168 switch rc.Operation.Operation {
2169 case ast.Query:
2170 return func(ctx context.Context) *graphql.Response {
2171 var response graphql.Response
2172 var data graphql.Marshaler
2173 if first {
2174 first = false
2175 ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
2176 data = ec._Query(ctx, rc.Operation.SelectionSet)
2177 } else {
2178 if atomic.LoadInt32(&ec.pendingDeferred) > 0 {
2179 result := <-ec.deferredResults
2180 atomic.AddInt32(&ec.pendingDeferred, -1)
2181 data = result.Result
2182 response.Path = result.Path
2183 response.Label = result.Label
2184 response.Errors = result.Errors
2185 } else {
2186 return nil
2187 }
2188 }
2189 var buf bytes.Buffer
2190 data.MarshalGQL(&buf)
2191 response.Data = buf.Bytes()
2192 if atomic.LoadInt32(&ec.deferred) > 0 {
2193 hasNext := atomic.LoadInt32(&ec.pendingDeferred) > 0
2194 response.HasNext = &hasNext
2195 }
2196
2197 return &response
2198 }
2199 case ast.Mutation:
2200 return func(ctx context.Context) *graphql.Response {
2201 if !first {
2202 return nil
2203 }
2204 first = false
2205 ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
2206 data := ec._Mutation(ctx, rc.Operation.SelectionSet)
2207 var buf bytes.Buffer
2208 data.MarshalGQL(&buf)
2209
2210 return &graphql.Response{
2211 Data: buf.Bytes(),
2212 }
2213 }
2214 case ast.Subscription:
2215 next := ec._Subscription(ctx, rc.Operation.SelectionSet)
2216
2217 var buf bytes.Buffer
2218 return func(ctx context.Context) *graphql.Response {
2219 buf.Reset()
2220 data := next(ctx)
2221
2222 if data == nil {
2223 return nil
2224 }
2225 data.MarshalGQL(&buf)
2226
2227 return &graphql.Response{
2228 Data: buf.Bytes(),
2229 }
2230 }
2231
2232 default:
2233 return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
2234 }
2235 }
2236
2237 type executionContext struct {
2238 *graphql.OperationContext
2239 *executableSchema
2240 deferred int32
2241 pendingDeferred int32
2242 deferredResults chan graphql.DeferredResult
2243 }
2244
2245 func (ec *executionContext) processDeferredGroup(dg graphql.DeferredGroup) {
2246 atomic.AddInt32(&ec.pendingDeferred, 1)
2247 go func() {
2248 ctx := graphql.WithFreshResponseContext(dg.Context)
2249 dg.FieldSet.Dispatch(ctx)
2250 ds := graphql.DeferredResult{
2251 Path: dg.Path,
2252 Label: dg.Label,
2253 Result: dg.FieldSet,
2254 Errors: graphql.GetErrors(ctx),
2255 }
2256
2257 if dg.FieldSet.Invalids > 0 {
2258 ds.Result = graphql.Null
2259 }
2260 ec.deferredResults <- ds
2261 }()
2262 }
2263
2264 func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
2265 if ec.DisableIntrospection {
2266 return nil, errors.New("introspection disabled")
2267 }
2268 return introspection.WrapSchema(ec.Schema()), nil
2269 }
2270
2271 func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
2272 if ec.DisableIntrospection {
2273 return nil, errors.New("introspection disabled")
2274 }
2275 return introspection.WrapTypeFromDef(ec.Schema(), ec.Schema().Types[name]), nil
2276 }
2277
2278
2279 var sourcesFS embed.FS
2280
2281 func sourceData(filename string) string {
2282 data, err := sourcesFS.ReadFile(filename)
2283 if err != nil {
2284 panic(fmt.Sprintf("codegen problem: %s not available", filename))
2285 }
2286 return string(data)
2287 }
2288
2289 var sources = []*ast.Source{
2290 {Name: "builtinscalar.graphql", Input: sourceData("builtinscalar.graphql"), BuiltIn: false},
2291 {Name: "complexity.graphql", Input: sourceData("complexity.graphql"), BuiltIn: false},
2292 {Name: "defaults.graphql", Input: sourceData("defaults.graphql"), BuiltIn: false},
2293 {Name: "defer.graphql", Input: sourceData("defer.graphql"), BuiltIn: false},
2294 {Name: "directive.graphql", Input: sourceData("directive.graphql"), BuiltIn: false},
2295 {Name: "embedded.graphql", Input: sourceData("embedded.graphql"), BuiltIn: false},
2296 {Name: "enum.graphql", Input: sourceData("enum.graphql"), BuiltIn: false},
2297 {Name: "fields_order.graphql", Input: sourceData("fields_order.graphql"), BuiltIn: false},
2298 {Name: "interfaces.graphql", Input: sourceData("interfaces.graphql"), BuiltIn: false},
2299 {Name: "issue896.graphql", Input: sourceData("issue896.graphql"), BuiltIn: false},
2300 {Name: "loops.graphql", Input: sourceData("loops.graphql"), BuiltIn: false},
2301 {Name: "maps.graphql", Input: sourceData("maps.graphql"), BuiltIn: false},
2302 {Name: "mutation_with_custom_scalar.graphql", Input: sourceData("mutation_with_custom_scalar.graphql"), BuiltIn: false},
2303 {Name: "nulls.graphql", Input: sourceData("nulls.graphql"), BuiltIn: false},
2304 {Name: "panics.graphql", Input: sourceData("panics.graphql"), BuiltIn: false},
2305 {Name: "primitive_objects.graphql", Input: sourceData("primitive_objects.graphql"), BuiltIn: false},
2306 {Name: "ptr_to_any.graphql", Input: sourceData("ptr_to_any.graphql"), BuiltIn: false},
2307 {Name: "ptr_to_ptr_input.graphql", Input: sourceData("ptr_to_ptr_input.graphql"), BuiltIn: false},
2308 {Name: "ptr_to_slice.graphql", Input: sourceData("ptr_to_slice.graphql"), BuiltIn: false},
2309 {Name: "scalar_context.graphql", Input: sourceData("scalar_context.graphql"), BuiltIn: false},
2310 {Name: "scalar_default.graphql", Input: sourceData("scalar_default.graphql"), BuiltIn: false},
2311 {Name: "schema.graphql", Input: sourceData("schema.graphql"), BuiltIn: false},
2312 {Name: "slices.graphql", Input: sourceData("slices.graphql"), BuiltIn: false},
2313 {Name: "typefallback.graphql", Input: sourceData("typefallback.graphql"), BuiltIn: false},
2314 {Name: "useptr.graphql", Input: sourceData("useptr.graphql"), BuiltIn: false},
2315 {Name: "v-ok.graphql", Input: sourceData("v-ok.graphql"), BuiltIn: false},
2316 {Name: "validtypes.graphql", Input: sourceData("validtypes.graphql"), BuiltIn: false},
2317 {Name: "variadic.graphql", Input: sourceData("variadic.graphql"), BuiltIn: false},
2318 {Name: "weird_type_cases.graphql", Input: sourceData("weird_type_cases.graphql"), BuiltIn: false},
2319 {Name: "wrapped_type.graphql", Input: sourceData("wrapped_type.graphql"), BuiltIn: false},
2320 }
2321 var parsedSchema = gqlparser.MustLoadSchema(sources...)
2322
View as plain text