1
2
3 package singlefile
4
5 import (
6 "bytes"
7 "context"
8 "embed"
9 "errors"
10 "fmt"
11 "io"
12 "strconv"
13 "sync"
14 "sync/atomic"
15 "time"
16
17 introspection1 "github.com/99designs/gqlgen/codegen/testserver/singlefile/introspection"
18 invalid_packagename "github.com/99designs/gqlgen/codegen/testserver/singlefile/invalid-packagename"
19 "github.com/99designs/gqlgen/codegen/testserver/singlefile/otherpkg"
20 "github.com/99designs/gqlgen/graphql"
21 "github.com/99designs/gqlgen/graphql/introspection"
22 gqlparser "github.com/vektah/gqlparser/v2"
23 "github.com/vektah/gqlparser/v2/ast"
24 )
25
26
27
28
29 func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
30 return &executableSchema{
31 schema: cfg.Schema,
32 resolvers: cfg.Resolvers,
33 directives: cfg.Directives,
34 complexity: cfg.Complexity,
35 }
36 }
37
38 type Config struct {
39 Schema *ast.Schema
40 Resolvers ResolverRoot
41 Directives DirectiveRoot
42 Complexity ComplexityRoot
43 }
44
45 type ResolverRoot interface {
46 BackedByInterface() BackedByInterfaceResolver
47 DeferModel() DeferModelResolver
48 Errors() ErrorsResolver
49 ForcedResolver() ForcedResolverResolver
50 ModelMethods() ModelMethodsResolver
51 Mutation() MutationResolver
52 OverlappingFields() OverlappingFieldsResolver
53 Panics() PanicsResolver
54 Pet() PetResolver
55 Primitive() PrimitiveResolver
56 PrimitiveString() PrimitiveStringResolver
57 Query() QueryResolver
58 Subscription() SubscriptionResolver
59 User() UserResolver
60 WrappedMap() WrappedMapResolver
61 WrappedSlice() WrappedSliceResolver
62 FieldsOrderInput() FieldsOrderInputResolver
63 }
64
65 type DirectiveRoot struct {
66 Custom func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
67 Defer func(ctx context.Context, obj interface{}, next graphql.Resolver, ifArg *bool, label *string) (res interface{}, err error)
68 Directive1 func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
69 Directive2 func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
70 Directive3 func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
71 Length func(ctx context.Context, obj interface{}, next graphql.Resolver, min int, max *int, message *string) (res interface{}, err error)
72 Logged func(ctx context.Context, obj interface{}, next graphql.Resolver, id string) (res interface{}, err error)
73 MakeNil func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
74 MakeTypedNil func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
75 Order1 func(ctx context.Context, obj interface{}, next graphql.Resolver, location string) (res interface{}, err error)
76 Order2 func(ctx context.Context, obj interface{}, next graphql.Resolver, location string) (res interface{}, err error)
77 Range func(ctx context.Context, obj interface{}, next graphql.Resolver, min *int, max *int) (res interface{}, err error)
78 ToNull func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
79 Unimplemented func(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error)
80 }
81
82 type ComplexityRoot struct {
83 A struct {
84 ID func(childComplexity int) int
85 }
86
87 AIt struct {
88 ID func(childComplexity int) int
89 }
90
91 AbIt struct {
92 ID func(childComplexity int) int
93 }
94
95 Autobind struct {
96 IdInt func(childComplexity int) int
97 IdStr func(childComplexity int) int
98 Int func(childComplexity int) int
99 Int32 func(childComplexity int) int
100 Int64 func(childComplexity int) int
101 }
102
103 B struct {
104 ID func(childComplexity int) int
105 }
106
107 BackedByInterface struct {
108 ID func(childComplexity int) int
109 ThisShouldBind func(childComplexity int) int
110 ThisShouldBindWithError func(childComplexity int) int
111 }
112
113 Cat struct {
114 CatBreed func(childComplexity int) int
115 Size func(childComplexity int) int
116 Species func(childComplexity int) int
117 }
118
119 CheckIssue896 struct {
120 ID func(childComplexity int) int
121 }
122
123 Circle struct {
124 Area func(childComplexity int) int
125 Coordinates func(childComplexity int) int
126 Radius func(childComplexity int) int
127 }
128
129 ConcreteNodeA struct {
130 Child func(childComplexity int) int
131 ID func(childComplexity int) int
132 Name func(childComplexity int) int
133 }
134
135 ConcreteNodeInterface struct {
136 Child func(childComplexity int) int
137 ID func(childComplexity int) int
138 }
139
140 Content_Post struct {
141 Foo func(childComplexity int) int
142 }
143
144 Content_User struct {
145 Foo func(childComplexity int) int
146 }
147
148 Coordinates struct {
149 X func(childComplexity int) int
150 Y func(childComplexity int) int
151 }
152
153 DefaultParametersMirror struct {
154 FalsyBoolean func(childComplexity int) int
155 TruthyBoolean func(childComplexity int) int
156 }
157
158 DeferModel struct {
159 ID func(childComplexity int) int
160 Name func(childComplexity int) int
161 Values func(childComplexity int) int
162 }
163
164 Dog struct {
165 DogBreed func(childComplexity int) int
166 Size func(childComplexity int) int
167 Species func(childComplexity int) int
168 }
169
170 EmbeddedCase1 struct {
171 ExportedEmbeddedPointerExportedMethod func(childComplexity int) int
172 }
173
174 EmbeddedCase2 struct {
175 UnexportedEmbeddedPointerExportedMethod func(childComplexity int) int
176 }
177
178 EmbeddedCase3 struct {
179 UnexportedEmbeddedInterfaceExportedMethod func(childComplexity int) int
180 }
181
182 EmbeddedDefaultScalar struct {
183 Value func(childComplexity int) int
184 }
185
186 EmbeddedPointer struct {
187 ID func(childComplexity int) int
188 Title func(childComplexity int) int
189 }
190
191 Error struct {
192 ErrorOnNonRequiredField func(childComplexity int) int
193 ErrorOnRequiredField func(childComplexity int) int
194 ID func(childComplexity int) int
195 NilOnRequiredField func(childComplexity int) int
196 }
197
198 Errors struct {
199 A func(childComplexity int) int
200 B func(childComplexity int) int
201 C func(childComplexity int) int
202 D func(childComplexity int) int
203 E func(childComplexity int) int
204 }
205
206 FieldsOrderPayload struct {
207 FirstFieldValue func(childComplexity int) int
208 }
209
210 ForcedResolver struct {
211 Field func(childComplexity int) int
212 }
213
214 Horse struct {
215 HorseBreed func(childComplexity int) int
216 Size func(childComplexity int) int
217 Species func(childComplexity int) int
218 }
219
220 InnerObject struct {
221 ID func(childComplexity int) int
222 }
223
224 InvalidIdentifier struct {
225 ID func(childComplexity int) int
226 }
227
228 It struct {
229 ID func(childComplexity int) int
230 }
231
232 LoopA struct {
233 B func(childComplexity int) int
234 }
235
236 LoopB struct {
237 A func(childComplexity int) int
238 }
239
240 Map struct {
241 ID func(childComplexity int) int
242 }
243
244 MapNested struct {
245 Value func(childComplexity int) int
246 }
247
248 MapStringInterfaceType struct {
249 A func(childComplexity int) int
250 B func(childComplexity int) int
251 C func(childComplexity int) int
252 Nested func(childComplexity int) int
253 }
254
255 ModelMethods struct {
256 NoContext func(childComplexity int) int
257 ResolverField func(childComplexity int) int
258 WithContext func(childComplexity int) int
259 }
260
261 Mutation struct {
262 DefaultInput func(childComplexity int, input DefaultInput) int
263 OverrideValueViaInput func(childComplexity int, input FieldsOrderInput) int
264 UpdatePtrToPtr func(childComplexity int, input UpdatePtrToPtrOuter) int
265 UpdateSomething func(childComplexity int, input SpecialInput) int
266 }
267
268 ObjectDirectives struct {
269 NullableText func(childComplexity int) int
270 Order func(childComplexity int) int
271 Text func(childComplexity int) int
272 }
273
274 ObjectDirectivesWithCustomGoModel struct {
275 NullableText func(childComplexity int) int
276 }
277
278 OuterObject struct {
279 Inner func(childComplexity int) int
280 }
281
282 OverlappingFields struct {
283 Foo func(childComplexity int) int
284 NewFoo func(childComplexity int) int
285 OldFoo func(childComplexity int) int
286 }
287
288 Panics struct {
289 ArgUnmarshal func(childComplexity int, u []MarshalPanic) int
290 FieldFuncMarshal func(childComplexity int, u []MarshalPanic) int
291 FieldScalarMarshal func(childComplexity int) int
292 }
293
294 Pet struct {
295 Friends func(childComplexity int, limit *int) int
296 ID func(childComplexity int) int
297 }
298
299 Primitive struct {
300 Squared func(childComplexity int) int
301 Value func(childComplexity int) int
302 }
303
304 PrimitiveString struct {
305 Doubled func(childComplexity int) int
306 Len func(childComplexity int) int
307 Value func(childComplexity int) int
308 }
309
310 PtrToAnyContainer struct {
311 Binding func(childComplexity int) int
312 PtrToAny func(childComplexity int) int
313 }
314
315 PtrToPtrInner struct {
316 Key func(childComplexity int) int
317 Value func(childComplexity int) int
318 }
319
320 PtrToPtrOuter struct {
321 Inner func(childComplexity int) int
322 Name func(childComplexity int) int
323 StupidInner func(childComplexity int) int
324 }
325
326 PtrToSliceContainer struct {
327 PtrToSlice func(childComplexity int) int
328 }
329
330 Query struct {
331 Animal func(childComplexity int) int
332 Autobind func(childComplexity int) int
333 Collision func(childComplexity int) int
334 DefaultParameters func(childComplexity int, falsyBoolean *bool, truthyBoolean *bool) int
335 DefaultScalar func(childComplexity int, arg string) int
336 DeferCase1 func(childComplexity int) int
337 DeferCase2 func(childComplexity int) int
338 DeprecatedField func(childComplexity int) int
339 DirectiveArg func(childComplexity int, arg string) int
340 DirectiveDouble func(childComplexity int) int
341 DirectiveField func(childComplexity int) int
342 DirectiveFieldDef func(childComplexity int, ret string) int
343 DirectiveInput func(childComplexity int, arg InputDirectives) int
344 DirectiveInputNullable func(childComplexity int, arg *InputDirectives) int
345 DirectiveInputType func(childComplexity int, arg InnerInput) int
346 DirectiveNullableArg func(childComplexity int, arg *int, arg2 *int, arg3 *string) int
347 DirectiveObject func(childComplexity int) int
348 DirectiveObjectWithCustomGoModel func(childComplexity int) int
349 DirectiveUnimplemented func(childComplexity int) int
350 Dog func(childComplexity int) int
351 EmbeddedCase1 func(childComplexity int) int
352 EmbeddedCase2 func(childComplexity int) int
353 EmbeddedCase3 func(childComplexity int) int
354 EnumInInput func(childComplexity int, input *InputWithEnumValue) int
355 ErrorBubble func(childComplexity int) int
356 ErrorBubbleList func(childComplexity int) int
357 ErrorList func(childComplexity int) int
358 Errors func(childComplexity int) int
359 Fallback func(childComplexity int, arg FallbackToStringEncoding) int
360 Infinity func(childComplexity int) int
361 InputNullableSlice func(childComplexity int, arg []string) int
362 InputOmittable func(childComplexity int, arg OmittableInput) int
363 InputSlice func(childComplexity int, arg []string) int
364 Invalid func(childComplexity int) int
365 InvalidIdentifier func(childComplexity int) int
366 Issue896a func(childComplexity int) int
367 MapInput func(childComplexity int, input map[string]interface{}) int
368 MapNestedStringInterface func(childComplexity int, in *NestedMapInput) int
369 MapStringInterface func(childComplexity int, in map[string]interface{}) int
370 ModelMethods func(childComplexity int) int
371 NestedInputs func(childComplexity int, input [][]*OuterInput) int
372 NestedOutputs func(childComplexity int) int
373 NoShape func(childComplexity int) int
374 NoShapeTypedNil func(childComplexity int) int
375 Node func(childComplexity int) int
376 NotAnInterface func(childComplexity int) int
377 NullableArg func(childComplexity int, arg *int) int
378 OptionalUnion func(childComplexity int) int
379 Overlapping func(childComplexity int) int
380 Panics func(childComplexity int) int
381 PrimitiveObject func(childComplexity int) int
382 PrimitiveStringObject func(childComplexity int) int
383 PtrToAnyContainer func(childComplexity int) int
384 PtrToSliceContainer func(childComplexity int) int
385 Recursive func(childComplexity int, input *RecursiveInputSlice) int
386 ScalarSlice func(childComplexity int) int
387 ShapeUnion func(childComplexity int) int
388 Shapes func(childComplexity int) int
389 Slices func(childComplexity int) int
390 StringFromContextFunction func(childComplexity int) int
391 StringFromContextInterface func(childComplexity int) int
392 User func(childComplexity int, id int) int
393 VOkCaseNil func(childComplexity int) int
394 VOkCaseValue func(childComplexity int) int
395 Valid func(childComplexity int) int
396 ValidType func(childComplexity int) int
397 VariadicModel func(childComplexity int) int
398 WrappedMap func(childComplexity int) int
399 WrappedScalar func(childComplexity int) int
400 WrappedSlice func(childComplexity int) int
401 WrappedStruct func(childComplexity int) int
402 }
403
404 Rectangle struct {
405 Area func(childComplexity int) int
406 Coordinates func(childComplexity int) int
407 Length func(childComplexity int) int
408 Width func(childComplexity int) int
409 }
410
411 Size struct {
412 Height func(childComplexity int) int
413 Weight func(childComplexity int) int
414 }
415
416 Slices struct {
417 Test1 func(childComplexity int) int
418 Test2 func(childComplexity int) int
419 Test3 func(childComplexity int) int
420 Test4 func(childComplexity int) int
421 }
422
423 Subscription struct {
424 DirectiveArg func(childComplexity int, arg string) int
425 DirectiveDouble func(childComplexity int) int
426 DirectiveNullableArg func(childComplexity int, arg *int, arg2 *int, arg3 *string) int
427 DirectiveUnimplemented func(childComplexity int) int
428 ErrorRequired func(childComplexity int) int
429 InitPayload func(childComplexity int) int
430 Issue896b func(childComplexity int) int
431 Updated func(childComplexity int) int
432 }
433
434 User struct {
435 Created func(childComplexity int) int
436 Friends func(childComplexity int) int
437 ID func(childComplexity int) int
438 Pets func(childComplexity int, limit *int) int
439 Updated func(childComplexity int) int
440 }
441
442 VOkCaseNil struct {
443 Value func(childComplexity int) int
444 }
445
446 VOkCaseValue struct {
447 Value func(childComplexity int) int
448 }
449
450 ValidType struct {
451 DifferentCase func(childComplexity int) int
452 DifferentCaseOld func(childComplexity int) int
453 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
454 ValidInputKeywords func(childComplexity int, input *ValidInput) int
455 }
456
457 VariadicModel struct {
458 Value func(childComplexity int, rank int) int
459 }
460
461 WrappedMap struct {
462 Get func(childComplexity int, key string) int
463 }
464
465 WrappedSlice struct {
466 Get func(childComplexity int, idx int) int
467 }
468
469 WrappedStruct struct {
470 Desc func(childComplexity int) int
471 Name func(childComplexity int) int
472 }
473
474 XXIt struct {
475 ID func(childComplexity int) int
476 }
477
478 XxIt struct {
479 ID func(childComplexity int) int
480 }
481
482 AsdfIt struct {
483 ID func(childComplexity int) int
484 }
485
486 IIt struct {
487 ID func(childComplexity int) int
488 }
489 }
490
491 type BackedByInterfaceResolver interface {
492 ID(ctx context.Context, obj BackedByInterface) (string, error)
493 }
494 type DeferModelResolver interface {
495 Values(ctx context.Context, obj *DeferModel) ([]string, error)
496 }
497 type ErrorsResolver interface {
498 A(ctx context.Context, obj *Errors) (*Error, error)
499 B(ctx context.Context, obj *Errors) (*Error, error)
500 C(ctx context.Context, obj *Errors) (*Error, error)
501 D(ctx context.Context, obj *Errors) (*Error, error)
502 E(ctx context.Context, obj *Errors) (*Error, error)
503 }
504 type ForcedResolverResolver interface {
505 Field(ctx context.Context, obj *ForcedResolver) (*Circle, error)
506 }
507 type ModelMethodsResolver interface {
508 ResolverField(ctx context.Context, obj *ModelMethods) (bool, error)
509 }
510 type MutationResolver interface {
511 DefaultInput(ctx context.Context, input DefaultInput) (*DefaultParametersMirror, error)
512 OverrideValueViaInput(ctx context.Context, input FieldsOrderInput) (*FieldsOrderPayload, error)
513 UpdateSomething(ctx context.Context, input SpecialInput) (string, error)
514 UpdatePtrToPtr(ctx context.Context, input UpdatePtrToPtrOuter) (*PtrToPtrOuter, error)
515 }
516 type OverlappingFieldsResolver interface {
517 OldFoo(ctx context.Context, obj *OverlappingFields) (int, error)
518 }
519 type PanicsResolver interface {
520 FieldScalarMarshal(ctx context.Context, obj *Panics) ([]MarshalPanic, error)
521
522 ArgUnmarshal(ctx context.Context, obj *Panics, u []MarshalPanic) (bool, error)
523 }
524 type PetResolver interface {
525 Friends(ctx context.Context, obj *Pet, limit *int) ([]*Pet, error)
526 }
527 type PrimitiveResolver interface {
528 Value(ctx context.Context, obj *Primitive) (int, error)
529 }
530 type PrimitiveStringResolver interface {
531 Value(ctx context.Context, obj *PrimitiveString) (string, error)
532
533 Len(ctx context.Context, obj *PrimitiveString) (int, error)
534 }
535 type QueryResolver interface {
536 InvalidIdentifier(ctx context.Context) (*invalid_packagename.InvalidIdentifier, error)
537 Collision(ctx context.Context) (*introspection1.It, error)
538 MapInput(ctx context.Context, input map[string]interface{}) (*bool, error)
539 Recursive(ctx context.Context, input *RecursiveInputSlice) (*bool, error)
540 NestedInputs(ctx context.Context, input [][]*OuterInput) (*bool, error)
541 NestedOutputs(ctx context.Context) ([][]*OuterObject, error)
542 ModelMethods(ctx context.Context) (*ModelMethods, error)
543 User(ctx context.Context, id int) (*User, error)
544 NullableArg(ctx context.Context, arg *int) (*string, error)
545 InputSlice(ctx context.Context, arg []string) (bool, error)
546 InputNullableSlice(ctx context.Context, arg []string) (bool, error)
547 InputOmittable(ctx context.Context, arg OmittableInput) (string, error)
548 ShapeUnion(ctx context.Context) (ShapeUnion, error)
549 Autobind(ctx context.Context) (*Autobind, error)
550 DeprecatedField(ctx context.Context) (string, error)
551 Overlapping(ctx context.Context) (*OverlappingFields, error)
552 DefaultParameters(ctx context.Context, falsyBoolean *bool, truthyBoolean *bool) (*DefaultParametersMirror, error)
553 DeferCase1(ctx context.Context) (*DeferModel, error)
554 DeferCase2(ctx context.Context) ([]*DeferModel, error)
555 DirectiveArg(ctx context.Context, arg string) (*string, error)
556 DirectiveNullableArg(ctx context.Context, arg *int, arg2 *int, arg3 *string) (*string, error)
557 DirectiveInputNullable(ctx context.Context, arg *InputDirectives) (*string, error)
558 DirectiveInput(ctx context.Context, arg InputDirectives) (*string, error)
559 DirectiveInputType(ctx context.Context, arg InnerInput) (*string, error)
560 DirectiveObject(ctx context.Context) (*ObjectDirectives, error)
561 DirectiveObjectWithCustomGoModel(ctx context.Context) (*ObjectDirectivesWithCustomGoModel, error)
562 DirectiveFieldDef(ctx context.Context, ret string) (string, error)
563 DirectiveField(ctx context.Context) (*string, error)
564 DirectiveDouble(ctx context.Context) (*string, error)
565 DirectiveUnimplemented(ctx context.Context) (*string, error)
566 EmbeddedCase1(ctx context.Context) (*EmbeddedCase1, error)
567 EmbeddedCase2(ctx context.Context) (*EmbeddedCase2, error)
568 EmbeddedCase3(ctx context.Context) (*EmbeddedCase3, error)
569 EnumInInput(ctx context.Context, input *InputWithEnumValue) (EnumTest, error)
570 Shapes(ctx context.Context) ([]Shape, error)
571 NoShape(ctx context.Context) (Shape, error)
572 Node(ctx context.Context) (Node, error)
573 NoShapeTypedNil(ctx context.Context) (Shape, error)
574 Animal(ctx context.Context) (Animal, error)
575 NotAnInterface(ctx context.Context) (BackedByInterface, error)
576 Dog(ctx context.Context) (*Dog, error)
577 Issue896a(ctx context.Context) ([]*CheckIssue896, error)
578 MapStringInterface(ctx context.Context, in map[string]interface{}) (map[string]interface{}, error)
579 MapNestedStringInterface(ctx context.Context, in *NestedMapInput) (map[string]interface{}, error)
580 ErrorBubble(ctx context.Context) (*Error, error)
581 ErrorBubbleList(ctx context.Context) ([]*Error, error)
582 ErrorList(ctx context.Context) ([]*Error, error)
583 Errors(ctx context.Context) (*Errors, error)
584 Valid(ctx context.Context) (string, error)
585 Invalid(ctx context.Context) (string, error)
586 Panics(ctx context.Context) (*Panics, error)
587 PrimitiveObject(ctx context.Context) ([]Primitive, error)
588 PrimitiveStringObject(ctx context.Context) ([]PrimitiveString, error)
589 PtrToAnyContainer(ctx context.Context) (*PtrToAnyContainer, error)
590 PtrToSliceContainer(ctx context.Context) (*PtrToSliceContainer, error)
591 Infinity(ctx context.Context) (float64, error)
592 StringFromContextInterface(ctx context.Context) (*StringFromContextInterface, error)
593 StringFromContextFunction(ctx context.Context) (string, error)
594 DefaultScalar(ctx context.Context, arg string) (string, error)
595 Slices(ctx context.Context) (*Slices, error)
596 ScalarSlice(ctx context.Context) ([]byte, error)
597 Fallback(ctx context.Context, arg FallbackToStringEncoding) (FallbackToStringEncoding, error)
598 OptionalUnion(ctx context.Context) (TestUnion, error)
599 VOkCaseValue(ctx context.Context) (*VOkCaseValue, error)
600 VOkCaseNil(ctx context.Context) (*VOkCaseNil, error)
601 ValidType(ctx context.Context) (*ValidType, error)
602 VariadicModel(ctx context.Context) (*VariadicModel, error)
603 WrappedStruct(ctx context.Context) (*WrappedStruct, error)
604 WrappedScalar(ctx context.Context) (otherpkg.Scalar, error)
605 WrappedMap(ctx context.Context) (WrappedMap, error)
606 WrappedSlice(ctx context.Context) (WrappedSlice, error)
607 }
608 type SubscriptionResolver interface {
609 Updated(ctx context.Context) (<-chan string, error)
610 InitPayload(ctx context.Context) (<-chan string, error)
611 DirectiveArg(ctx context.Context, arg string) (<-chan *string, error)
612 DirectiveNullableArg(ctx context.Context, arg *int, arg2 *int, arg3 *string) (<-chan *string, error)
613 DirectiveDouble(ctx context.Context) (<-chan *string, error)
614 DirectiveUnimplemented(ctx context.Context) (<-chan *string, error)
615 Issue896b(ctx context.Context) (<-chan []*CheckIssue896, error)
616 ErrorRequired(ctx context.Context) (<-chan *Error, error)
617 }
618 type UserResolver interface {
619 Friends(ctx context.Context, obj *User) ([]*User, error)
620
621 Pets(ctx context.Context, obj *User, limit *int) ([]*Pet, error)
622 }
623 type WrappedMapResolver interface {
624 Get(ctx context.Context, obj WrappedMap, key string) (string, error)
625 }
626 type WrappedSliceResolver interface {
627 Get(ctx context.Context, obj WrappedSlice, idx int) (string, error)
628 }
629
630 type FieldsOrderInputResolver interface {
631 OverrideFirstField(ctx context.Context, obj *FieldsOrderInput, data *string) error
632 }
633
634 type executableSchema struct {
635 schema *ast.Schema
636 resolvers ResolverRoot
637 directives DirectiveRoot
638 complexity ComplexityRoot
639 }
640
641 func (e *executableSchema) Schema() *ast.Schema {
642 if e.schema != nil {
643 return e.schema
644 }
645 return parsedSchema
646 }
647
648 func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
649 ec := executionContext{nil, e, 0, 0, nil}
650 _ = ec
651 switch typeName + "." + field {
652
653 case "A.id":
654 if e.complexity.A.ID == nil {
655 break
656 }
657
658 return e.complexity.A.ID(childComplexity), true
659
660 case "AIt.id":
661 if e.complexity.AIt.ID == nil {
662 break
663 }
664
665 return e.complexity.AIt.ID(childComplexity), true
666
667 case "AbIt.id":
668 if e.complexity.AbIt.ID == nil {
669 break
670 }
671
672 return e.complexity.AbIt.ID(childComplexity), true
673
674 case "Autobind.idInt":
675 if e.complexity.Autobind.IdInt == nil {
676 break
677 }
678
679 return e.complexity.Autobind.IdInt(childComplexity), true
680
681 case "Autobind.idStr":
682 if e.complexity.Autobind.IdStr == nil {
683 break
684 }
685
686 return e.complexity.Autobind.IdStr(childComplexity), true
687
688 case "Autobind.int":
689 if e.complexity.Autobind.Int == nil {
690 break
691 }
692
693 return e.complexity.Autobind.Int(childComplexity), true
694
695 case "Autobind.int32":
696 if e.complexity.Autobind.Int32 == nil {
697 break
698 }
699
700 return e.complexity.Autobind.Int32(childComplexity), true
701
702 case "Autobind.int64":
703 if e.complexity.Autobind.Int64 == nil {
704 break
705 }
706
707 return e.complexity.Autobind.Int64(childComplexity), true
708
709 case "B.id":
710 if e.complexity.B.ID == nil {
711 break
712 }
713
714 return e.complexity.B.ID(childComplexity), true
715
716 case "BackedByInterface.id":
717 if e.complexity.BackedByInterface.ID == nil {
718 break
719 }
720
721 return e.complexity.BackedByInterface.ID(childComplexity), true
722
723 case "BackedByInterface.thisShouldBind":
724 if e.complexity.BackedByInterface.ThisShouldBind == nil {
725 break
726 }
727
728 return e.complexity.BackedByInterface.ThisShouldBind(childComplexity), true
729
730 case "BackedByInterface.thisShouldBindWithError":
731 if e.complexity.BackedByInterface.ThisShouldBindWithError == nil {
732 break
733 }
734
735 return e.complexity.BackedByInterface.ThisShouldBindWithError(childComplexity), true
736
737 case "Cat.catBreed":
738 if e.complexity.Cat.CatBreed == nil {
739 break
740 }
741
742 return e.complexity.Cat.CatBreed(childComplexity), true
743
744 case "Cat.size":
745 if e.complexity.Cat.Size == nil {
746 break
747 }
748
749 return e.complexity.Cat.Size(childComplexity), true
750
751 case "Cat.species":
752 if e.complexity.Cat.Species == nil {
753 break
754 }
755
756 return e.complexity.Cat.Species(childComplexity), true
757
758 case "CheckIssue896.id":
759 if e.complexity.CheckIssue896.ID == nil {
760 break
761 }
762
763 return e.complexity.CheckIssue896.ID(childComplexity), true
764
765 case "Circle.area":
766 if e.complexity.Circle.Area == nil {
767 break
768 }
769
770 return e.complexity.Circle.Area(childComplexity), true
771
772 case "Circle.coordinates":
773 if e.complexity.Circle.Coordinates == nil {
774 break
775 }
776
777 return e.complexity.Circle.Coordinates(childComplexity), true
778
779 case "Circle.radius":
780 if e.complexity.Circle.Radius == nil {
781 break
782 }
783
784 return e.complexity.Circle.Radius(childComplexity), true
785
786 case "ConcreteNodeA.child":
787 if e.complexity.ConcreteNodeA.Child == nil {
788 break
789 }
790
791 return e.complexity.ConcreteNodeA.Child(childComplexity), true
792
793 case "ConcreteNodeA.id":
794 if e.complexity.ConcreteNodeA.ID == nil {
795 break
796 }
797
798 return e.complexity.ConcreteNodeA.ID(childComplexity), true
799
800 case "ConcreteNodeA.name":
801 if e.complexity.ConcreteNodeA.Name == nil {
802 break
803 }
804
805 return e.complexity.ConcreteNodeA.Name(childComplexity), true
806
807 case "ConcreteNodeInterface.child":
808 if e.complexity.ConcreteNodeInterface.Child == nil {
809 break
810 }
811
812 return e.complexity.ConcreteNodeInterface.Child(childComplexity), true
813
814 case "ConcreteNodeInterface.id":
815 if e.complexity.ConcreteNodeInterface.ID == nil {
816 break
817 }
818
819 return e.complexity.ConcreteNodeInterface.ID(childComplexity), true
820
821 case "Content_Post.foo":
822 if e.complexity.Content_Post.Foo == nil {
823 break
824 }
825
826 return e.complexity.Content_Post.Foo(childComplexity), true
827
828 case "Content_User.foo":
829 if e.complexity.Content_User.Foo == nil {
830 break
831 }
832
833 return e.complexity.Content_User.Foo(childComplexity), true
834
835 case "Coordinates.x":
836 if e.complexity.Coordinates.X == nil {
837 break
838 }
839
840 return e.complexity.Coordinates.X(childComplexity), true
841
842 case "Coordinates.y":
843 if e.complexity.Coordinates.Y == nil {
844 break
845 }
846
847 return e.complexity.Coordinates.Y(childComplexity), true
848
849 case "DefaultParametersMirror.falsyBoolean":
850 if e.complexity.DefaultParametersMirror.FalsyBoolean == nil {
851 break
852 }
853
854 return e.complexity.DefaultParametersMirror.FalsyBoolean(childComplexity), true
855
856 case "DefaultParametersMirror.truthyBoolean":
857 if e.complexity.DefaultParametersMirror.TruthyBoolean == nil {
858 break
859 }
860
861 return e.complexity.DefaultParametersMirror.TruthyBoolean(childComplexity), true
862
863 case "DeferModel.id":
864 if e.complexity.DeferModel.ID == nil {
865 break
866 }
867
868 return e.complexity.DeferModel.ID(childComplexity), true
869
870 case "DeferModel.name":
871 if e.complexity.DeferModel.Name == nil {
872 break
873 }
874
875 return e.complexity.DeferModel.Name(childComplexity), true
876
877 case "DeferModel.values":
878 if e.complexity.DeferModel.Values == nil {
879 break
880 }
881
882 return e.complexity.DeferModel.Values(childComplexity), true
883
884 case "Dog.dogBreed":
885 if e.complexity.Dog.DogBreed == nil {
886 break
887 }
888
889 return e.complexity.Dog.DogBreed(childComplexity), true
890
891 case "Dog.size":
892 if e.complexity.Dog.Size == nil {
893 break
894 }
895
896 return e.complexity.Dog.Size(childComplexity), true
897
898 case "Dog.species":
899 if e.complexity.Dog.Species == nil {
900 break
901 }
902
903 return e.complexity.Dog.Species(childComplexity), true
904
905 case "EmbeddedCase1.exportedEmbeddedPointerExportedMethod":
906 if e.complexity.EmbeddedCase1.ExportedEmbeddedPointerExportedMethod == nil {
907 break
908 }
909
910 return e.complexity.EmbeddedCase1.ExportedEmbeddedPointerExportedMethod(childComplexity), true
911
912 case "EmbeddedCase2.unexportedEmbeddedPointerExportedMethod":
913 if e.complexity.EmbeddedCase2.UnexportedEmbeddedPointerExportedMethod == nil {
914 break
915 }
916
917 return e.complexity.EmbeddedCase2.UnexportedEmbeddedPointerExportedMethod(childComplexity), true
918
919 case "EmbeddedCase3.unexportedEmbeddedInterfaceExportedMethod":
920 if e.complexity.EmbeddedCase3.UnexportedEmbeddedInterfaceExportedMethod == nil {
921 break
922 }
923
924 return e.complexity.EmbeddedCase3.UnexportedEmbeddedInterfaceExportedMethod(childComplexity), true
925
926 case "EmbeddedDefaultScalar.value":
927 if e.complexity.EmbeddedDefaultScalar.Value == nil {
928 break
929 }
930
931 return e.complexity.EmbeddedDefaultScalar.Value(childComplexity), true
932
933 case "EmbeddedPointer.ID":
934 if e.complexity.EmbeddedPointer.ID == nil {
935 break
936 }
937
938 return e.complexity.EmbeddedPointer.ID(childComplexity), true
939
940 case "EmbeddedPointer.Title":
941 if e.complexity.EmbeddedPointer.Title == nil {
942 break
943 }
944
945 return e.complexity.EmbeddedPointer.Title(childComplexity), true
946
947 case "Error.errorOnNonRequiredField":
948 if e.complexity.Error.ErrorOnNonRequiredField == nil {
949 break
950 }
951
952 return e.complexity.Error.ErrorOnNonRequiredField(childComplexity), true
953
954 case "Error.errorOnRequiredField":
955 if e.complexity.Error.ErrorOnRequiredField == nil {
956 break
957 }
958
959 return e.complexity.Error.ErrorOnRequiredField(childComplexity), true
960
961 case "Error.id":
962 if e.complexity.Error.ID == nil {
963 break
964 }
965
966 return e.complexity.Error.ID(childComplexity), true
967
968 case "Error.nilOnRequiredField":
969 if e.complexity.Error.NilOnRequiredField == nil {
970 break
971 }
972
973 return e.complexity.Error.NilOnRequiredField(childComplexity), true
974
975 case "Errors.a":
976 if e.complexity.Errors.A == nil {
977 break
978 }
979
980 return e.complexity.Errors.A(childComplexity), true
981
982 case "Errors.b":
983 if e.complexity.Errors.B == nil {
984 break
985 }
986
987 return e.complexity.Errors.B(childComplexity), true
988
989 case "Errors.c":
990 if e.complexity.Errors.C == nil {
991 break
992 }
993
994 return e.complexity.Errors.C(childComplexity), true
995
996 case "Errors.d":
997 if e.complexity.Errors.D == nil {
998 break
999 }
1000
1001 return e.complexity.Errors.D(childComplexity), true
1002
1003 case "Errors.e":
1004 if e.complexity.Errors.E == nil {
1005 break
1006 }
1007
1008 return e.complexity.Errors.E(childComplexity), true
1009
1010 case "FieldsOrderPayload.firstFieldValue":
1011 if e.complexity.FieldsOrderPayload.FirstFieldValue == nil {
1012 break
1013 }
1014
1015 return e.complexity.FieldsOrderPayload.FirstFieldValue(childComplexity), true
1016
1017 case "ForcedResolver.field":
1018 if e.complexity.ForcedResolver.Field == nil {
1019 break
1020 }
1021
1022 return e.complexity.ForcedResolver.Field(childComplexity), true
1023
1024 case "Horse.horseBreed":
1025 if e.complexity.Horse.HorseBreed == nil {
1026 break
1027 }
1028
1029 return e.complexity.Horse.HorseBreed(childComplexity), true
1030
1031 case "Horse.size":
1032 if e.complexity.Horse.Size == nil {
1033 break
1034 }
1035
1036 return e.complexity.Horse.Size(childComplexity), true
1037
1038 case "Horse.species":
1039 if e.complexity.Horse.Species == nil {
1040 break
1041 }
1042
1043 return e.complexity.Horse.Species(childComplexity), true
1044
1045 case "InnerObject.id":
1046 if e.complexity.InnerObject.ID == nil {
1047 break
1048 }
1049
1050 return e.complexity.InnerObject.ID(childComplexity), true
1051
1052 case "InvalidIdentifier.id":
1053 if e.complexity.InvalidIdentifier.ID == nil {
1054 break
1055 }
1056
1057 return e.complexity.InvalidIdentifier.ID(childComplexity), true
1058
1059 case "It.id":
1060 if e.complexity.It.ID == nil {
1061 break
1062 }
1063
1064 return e.complexity.It.ID(childComplexity), true
1065
1066 case "LoopA.b":
1067 if e.complexity.LoopA.B == nil {
1068 break
1069 }
1070
1071 return e.complexity.LoopA.B(childComplexity), true
1072
1073 case "LoopB.a":
1074 if e.complexity.LoopB.A == nil {
1075 break
1076 }
1077
1078 return e.complexity.LoopB.A(childComplexity), true
1079
1080 case "Map.id":
1081 if e.complexity.Map.ID == nil {
1082 break
1083 }
1084
1085 return e.complexity.Map.ID(childComplexity), true
1086
1087 case "MapNested.value":
1088 if e.complexity.MapNested.Value == nil {
1089 break
1090 }
1091
1092 return e.complexity.MapNested.Value(childComplexity), true
1093
1094 case "MapStringInterfaceType.a":
1095 if e.complexity.MapStringInterfaceType.A == nil {
1096 break
1097 }
1098
1099 return e.complexity.MapStringInterfaceType.A(childComplexity), true
1100
1101 case "MapStringInterfaceType.b":
1102 if e.complexity.MapStringInterfaceType.B == nil {
1103 break
1104 }
1105
1106 return e.complexity.MapStringInterfaceType.B(childComplexity), true
1107
1108 case "MapStringInterfaceType.c":
1109 if e.complexity.MapStringInterfaceType.C == nil {
1110 break
1111 }
1112
1113 return e.complexity.MapStringInterfaceType.C(childComplexity), true
1114
1115 case "MapStringInterfaceType.nested":
1116 if e.complexity.MapStringInterfaceType.Nested == nil {
1117 break
1118 }
1119
1120 return e.complexity.MapStringInterfaceType.Nested(childComplexity), true
1121
1122 case "ModelMethods.noContext":
1123 if e.complexity.ModelMethods.NoContext == nil {
1124 break
1125 }
1126
1127 return e.complexity.ModelMethods.NoContext(childComplexity), true
1128
1129 case "ModelMethods.resolverField":
1130 if e.complexity.ModelMethods.ResolverField == nil {
1131 break
1132 }
1133
1134 return e.complexity.ModelMethods.ResolverField(childComplexity), true
1135
1136 case "ModelMethods.withContext":
1137 if e.complexity.ModelMethods.WithContext == nil {
1138 break
1139 }
1140
1141 return e.complexity.ModelMethods.WithContext(childComplexity), true
1142
1143 case "Mutation.defaultInput":
1144 if e.complexity.Mutation.DefaultInput == nil {
1145 break
1146 }
1147
1148 args, err := ec.field_Mutation_defaultInput_args(context.TODO(), rawArgs)
1149 if err != nil {
1150 return 0, false
1151 }
1152
1153 return e.complexity.Mutation.DefaultInput(childComplexity, args["input"].(DefaultInput)), true
1154
1155 case "Mutation.overrideValueViaInput":
1156 if e.complexity.Mutation.OverrideValueViaInput == nil {
1157 break
1158 }
1159
1160 args, err := ec.field_Mutation_overrideValueViaInput_args(context.TODO(), rawArgs)
1161 if err != nil {
1162 return 0, false
1163 }
1164
1165 return e.complexity.Mutation.OverrideValueViaInput(childComplexity, args["input"].(FieldsOrderInput)), true
1166
1167 case "Mutation.updatePtrToPtr":
1168 if e.complexity.Mutation.UpdatePtrToPtr == nil {
1169 break
1170 }
1171
1172 args, err := ec.field_Mutation_updatePtrToPtr_args(context.TODO(), rawArgs)
1173 if err != nil {
1174 return 0, false
1175 }
1176
1177 return e.complexity.Mutation.UpdatePtrToPtr(childComplexity, args["input"].(UpdatePtrToPtrOuter)), true
1178
1179 case "Mutation.updateSomething":
1180 if e.complexity.Mutation.UpdateSomething == nil {
1181 break
1182 }
1183
1184 args, err := ec.field_Mutation_updateSomething_args(context.TODO(), rawArgs)
1185 if err != nil {
1186 return 0, false
1187 }
1188
1189 return e.complexity.Mutation.UpdateSomething(childComplexity, args["input"].(SpecialInput)), true
1190
1191 case "ObjectDirectives.nullableText":
1192 if e.complexity.ObjectDirectives.NullableText == nil {
1193 break
1194 }
1195
1196 return e.complexity.ObjectDirectives.NullableText(childComplexity), true
1197
1198 case "ObjectDirectives.order":
1199 if e.complexity.ObjectDirectives.Order == nil {
1200 break
1201 }
1202
1203 return e.complexity.ObjectDirectives.Order(childComplexity), true
1204
1205 case "ObjectDirectives.text":
1206 if e.complexity.ObjectDirectives.Text == nil {
1207 break
1208 }
1209
1210 return e.complexity.ObjectDirectives.Text(childComplexity), true
1211
1212 case "ObjectDirectivesWithCustomGoModel.nullableText":
1213 if e.complexity.ObjectDirectivesWithCustomGoModel.NullableText == nil {
1214 break
1215 }
1216
1217 return e.complexity.ObjectDirectivesWithCustomGoModel.NullableText(childComplexity), true
1218
1219 case "OuterObject.inner":
1220 if e.complexity.OuterObject.Inner == nil {
1221 break
1222 }
1223
1224 return e.complexity.OuterObject.Inner(childComplexity), true
1225
1226 case "OverlappingFields.oneFoo", "OverlappingFields.twoFoo":
1227 if e.complexity.OverlappingFields.Foo == nil {
1228 break
1229 }
1230
1231 return e.complexity.OverlappingFields.Foo(childComplexity), true
1232
1233 case "OverlappingFields.newFoo", "OverlappingFields.new_foo":
1234 if e.complexity.OverlappingFields.NewFoo == nil {
1235 break
1236 }
1237
1238 return e.complexity.OverlappingFields.NewFoo(childComplexity), true
1239
1240 case "OverlappingFields.oldFoo":
1241 if e.complexity.OverlappingFields.OldFoo == nil {
1242 break
1243 }
1244
1245 return e.complexity.OverlappingFields.OldFoo(childComplexity), true
1246
1247 case "Panics.argUnmarshal":
1248 if e.complexity.Panics.ArgUnmarshal == nil {
1249 break
1250 }
1251
1252 args, err := ec.field_Panics_argUnmarshal_args(context.TODO(), rawArgs)
1253 if err != nil {
1254 return 0, false
1255 }
1256
1257 return e.complexity.Panics.ArgUnmarshal(childComplexity, args["u"].([]MarshalPanic)), true
1258
1259 case "Panics.fieldFuncMarshal":
1260 if e.complexity.Panics.FieldFuncMarshal == nil {
1261 break
1262 }
1263
1264 args, err := ec.field_Panics_fieldFuncMarshal_args(context.TODO(), rawArgs)
1265 if err != nil {
1266 return 0, false
1267 }
1268
1269 return e.complexity.Panics.FieldFuncMarshal(childComplexity, args["u"].([]MarshalPanic)), true
1270
1271 case "Panics.fieldScalarMarshal":
1272 if e.complexity.Panics.FieldScalarMarshal == nil {
1273 break
1274 }
1275
1276 return e.complexity.Panics.FieldScalarMarshal(childComplexity), true
1277
1278 case "Pet.friends":
1279 if e.complexity.Pet.Friends == nil {
1280 break
1281 }
1282
1283 args, err := ec.field_Pet_friends_args(context.TODO(), rawArgs)
1284 if err != nil {
1285 return 0, false
1286 }
1287
1288 return e.complexity.Pet.Friends(childComplexity, args["limit"].(*int)), true
1289
1290 case "Pet.id":
1291 if e.complexity.Pet.ID == nil {
1292 break
1293 }
1294
1295 return e.complexity.Pet.ID(childComplexity), true
1296
1297 case "Primitive.squared":
1298 if e.complexity.Primitive.Squared == nil {
1299 break
1300 }
1301
1302 return e.complexity.Primitive.Squared(childComplexity), true
1303
1304 case "Primitive.value":
1305 if e.complexity.Primitive.Value == nil {
1306 break
1307 }
1308
1309 return e.complexity.Primitive.Value(childComplexity), true
1310
1311 case "PrimitiveString.doubled":
1312 if e.complexity.PrimitiveString.Doubled == nil {
1313 break
1314 }
1315
1316 return e.complexity.PrimitiveString.Doubled(childComplexity), true
1317
1318 case "PrimitiveString.len":
1319 if e.complexity.PrimitiveString.Len == nil {
1320 break
1321 }
1322
1323 return e.complexity.PrimitiveString.Len(childComplexity), true
1324
1325 case "PrimitiveString.value":
1326 if e.complexity.PrimitiveString.Value == nil {
1327 break
1328 }
1329
1330 return e.complexity.PrimitiveString.Value(childComplexity), true
1331
1332 case "PtrToAnyContainer.binding":
1333 if e.complexity.PtrToAnyContainer.Binding == nil {
1334 break
1335 }
1336
1337 return e.complexity.PtrToAnyContainer.Binding(childComplexity), true
1338
1339 case "PtrToAnyContainer.ptrToAny":
1340 if e.complexity.PtrToAnyContainer.PtrToAny == nil {
1341 break
1342 }
1343
1344 return e.complexity.PtrToAnyContainer.PtrToAny(childComplexity), true
1345
1346 case "PtrToPtrInner.key":
1347 if e.complexity.PtrToPtrInner.Key == nil {
1348 break
1349 }
1350
1351 return e.complexity.PtrToPtrInner.Key(childComplexity), true
1352
1353 case "PtrToPtrInner.value":
1354 if e.complexity.PtrToPtrInner.Value == nil {
1355 break
1356 }
1357
1358 return e.complexity.PtrToPtrInner.Value(childComplexity), true
1359
1360 case "PtrToPtrOuter.inner":
1361 if e.complexity.PtrToPtrOuter.Inner == nil {
1362 break
1363 }
1364
1365 return e.complexity.PtrToPtrOuter.Inner(childComplexity), true
1366
1367 case "PtrToPtrOuter.name":
1368 if e.complexity.PtrToPtrOuter.Name == nil {
1369 break
1370 }
1371
1372 return e.complexity.PtrToPtrOuter.Name(childComplexity), true
1373
1374 case "PtrToPtrOuter.stupidInner":
1375 if e.complexity.PtrToPtrOuter.StupidInner == nil {
1376 break
1377 }
1378
1379 return e.complexity.PtrToPtrOuter.StupidInner(childComplexity), true
1380
1381 case "PtrToSliceContainer.ptrToSlice":
1382 if e.complexity.PtrToSliceContainer.PtrToSlice == nil {
1383 break
1384 }
1385
1386 return e.complexity.PtrToSliceContainer.PtrToSlice(childComplexity), true
1387
1388 case "Query.animal":
1389 if e.complexity.Query.Animal == nil {
1390 break
1391 }
1392
1393 return e.complexity.Query.Animal(childComplexity), true
1394
1395 case "Query.autobind":
1396 if e.complexity.Query.Autobind == nil {
1397 break
1398 }
1399
1400 return e.complexity.Query.Autobind(childComplexity), true
1401
1402 case "Query.collision":
1403 if e.complexity.Query.Collision == nil {
1404 break
1405 }
1406
1407 return e.complexity.Query.Collision(childComplexity), true
1408
1409 case "Query.defaultParameters":
1410 if e.complexity.Query.DefaultParameters == nil {
1411 break
1412 }
1413
1414 args, err := ec.field_Query_defaultParameters_args(context.TODO(), rawArgs)
1415 if err != nil {
1416 return 0, false
1417 }
1418
1419 return e.complexity.Query.DefaultParameters(childComplexity, args["falsyBoolean"].(*bool), args["truthyBoolean"].(*bool)), true
1420
1421 case "Query.defaultScalar":
1422 if e.complexity.Query.DefaultScalar == nil {
1423 break
1424 }
1425
1426 args, err := ec.field_Query_defaultScalar_args(context.TODO(), rawArgs)
1427 if err != nil {
1428 return 0, false
1429 }
1430
1431 return e.complexity.Query.DefaultScalar(childComplexity, args["arg"].(string)), true
1432
1433 case "Query.deferCase1":
1434 if e.complexity.Query.DeferCase1 == nil {
1435 break
1436 }
1437
1438 return e.complexity.Query.DeferCase1(childComplexity), true
1439
1440 case "Query.deferCase2":
1441 if e.complexity.Query.DeferCase2 == nil {
1442 break
1443 }
1444
1445 return e.complexity.Query.DeferCase2(childComplexity), true
1446
1447 case "Query.deprecatedField":
1448 if e.complexity.Query.DeprecatedField == nil {
1449 break
1450 }
1451
1452 return e.complexity.Query.DeprecatedField(childComplexity), true
1453
1454 case "Query.directiveArg":
1455 if e.complexity.Query.DirectiveArg == nil {
1456 break
1457 }
1458
1459 args, err := ec.field_Query_directiveArg_args(context.TODO(), rawArgs)
1460 if err != nil {
1461 return 0, false
1462 }
1463
1464 return e.complexity.Query.DirectiveArg(childComplexity, args["arg"].(string)), true
1465
1466 case "Query.directiveDouble":
1467 if e.complexity.Query.DirectiveDouble == nil {
1468 break
1469 }
1470
1471 return e.complexity.Query.DirectiveDouble(childComplexity), true
1472
1473 case "Query.directiveField":
1474 if e.complexity.Query.DirectiveField == nil {
1475 break
1476 }
1477
1478 return e.complexity.Query.DirectiveField(childComplexity), true
1479
1480 case "Query.directiveFieldDef":
1481 if e.complexity.Query.DirectiveFieldDef == nil {
1482 break
1483 }
1484
1485 args, err := ec.field_Query_directiveFieldDef_args(context.TODO(), rawArgs)
1486 if err != nil {
1487 return 0, false
1488 }
1489
1490 return e.complexity.Query.DirectiveFieldDef(childComplexity, args["ret"].(string)), true
1491
1492 case "Query.directiveInput":
1493 if e.complexity.Query.DirectiveInput == nil {
1494 break
1495 }
1496
1497 args, err := ec.field_Query_directiveInput_args(context.TODO(), rawArgs)
1498 if err != nil {
1499 return 0, false
1500 }
1501
1502 return e.complexity.Query.DirectiveInput(childComplexity, args["arg"].(InputDirectives)), true
1503
1504 case "Query.directiveInputNullable":
1505 if e.complexity.Query.DirectiveInputNullable == nil {
1506 break
1507 }
1508
1509 args, err := ec.field_Query_directiveInputNullable_args(context.TODO(), rawArgs)
1510 if err != nil {
1511 return 0, false
1512 }
1513
1514 return e.complexity.Query.DirectiveInputNullable(childComplexity, args["arg"].(*InputDirectives)), true
1515
1516 case "Query.directiveInputType":
1517 if e.complexity.Query.DirectiveInputType == nil {
1518 break
1519 }
1520
1521 args, err := ec.field_Query_directiveInputType_args(context.TODO(), rawArgs)
1522 if err != nil {
1523 return 0, false
1524 }
1525
1526 return e.complexity.Query.DirectiveInputType(childComplexity, args["arg"].(InnerInput)), true
1527
1528 case "Query.directiveNullableArg":
1529 if e.complexity.Query.DirectiveNullableArg == nil {
1530 break
1531 }
1532
1533 args, err := ec.field_Query_directiveNullableArg_args(context.TODO(), rawArgs)
1534 if err != nil {
1535 return 0, false
1536 }
1537
1538 return e.complexity.Query.DirectiveNullableArg(childComplexity, args["arg"].(*int), args["arg2"].(*int), args["arg3"].(*string)), true
1539
1540 case "Query.directiveObject":
1541 if e.complexity.Query.DirectiveObject == nil {
1542 break
1543 }
1544
1545 return e.complexity.Query.DirectiveObject(childComplexity), true
1546
1547 case "Query.directiveObjectWithCustomGoModel":
1548 if e.complexity.Query.DirectiveObjectWithCustomGoModel == nil {
1549 break
1550 }
1551
1552 return e.complexity.Query.DirectiveObjectWithCustomGoModel(childComplexity), true
1553
1554 case "Query.directiveUnimplemented":
1555 if e.complexity.Query.DirectiveUnimplemented == nil {
1556 break
1557 }
1558
1559 return e.complexity.Query.DirectiveUnimplemented(childComplexity), true
1560
1561 case "Query.dog":
1562 if e.complexity.Query.Dog == nil {
1563 break
1564 }
1565
1566 return e.complexity.Query.Dog(childComplexity), true
1567
1568 case "Query.embeddedCase1":
1569 if e.complexity.Query.EmbeddedCase1 == nil {
1570 break
1571 }
1572
1573 return e.complexity.Query.EmbeddedCase1(childComplexity), true
1574
1575 case "Query.embeddedCase2":
1576 if e.complexity.Query.EmbeddedCase2 == nil {
1577 break
1578 }
1579
1580 return e.complexity.Query.EmbeddedCase2(childComplexity), true
1581
1582 case "Query.embeddedCase3":
1583 if e.complexity.Query.EmbeddedCase3 == nil {
1584 break
1585 }
1586
1587 return e.complexity.Query.EmbeddedCase3(childComplexity), true
1588
1589 case "Query.enumInInput":
1590 if e.complexity.Query.EnumInInput == nil {
1591 break
1592 }
1593
1594 args, err := ec.field_Query_enumInInput_args(context.TODO(), rawArgs)
1595 if err != nil {
1596 return 0, false
1597 }
1598
1599 return e.complexity.Query.EnumInInput(childComplexity, args["input"].(*InputWithEnumValue)), true
1600
1601 case "Query.errorBubble":
1602 if e.complexity.Query.ErrorBubble == nil {
1603 break
1604 }
1605
1606 return e.complexity.Query.ErrorBubble(childComplexity), true
1607
1608 case "Query.errorBubbleList":
1609 if e.complexity.Query.ErrorBubbleList == nil {
1610 break
1611 }
1612
1613 return e.complexity.Query.ErrorBubbleList(childComplexity), true
1614
1615 case "Query.errorList":
1616 if e.complexity.Query.ErrorList == nil {
1617 break
1618 }
1619
1620 return e.complexity.Query.ErrorList(childComplexity), true
1621
1622 case "Query.errors":
1623 if e.complexity.Query.Errors == nil {
1624 break
1625 }
1626
1627 return e.complexity.Query.Errors(childComplexity), true
1628
1629 case "Query.fallback":
1630 if e.complexity.Query.Fallback == nil {
1631 break
1632 }
1633
1634 args, err := ec.field_Query_fallback_args(context.TODO(), rawArgs)
1635 if err != nil {
1636 return 0, false
1637 }
1638
1639 return e.complexity.Query.Fallback(childComplexity, args["arg"].(FallbackToStringEncoding)), true
1640
1641 case "Query.infinity":
1642 if e.complexity.Query.Infinity == nil {
1643 break
1644 }
1645
1646 return e.complexity.Query.Infinity(childComplexity), true
1647
1648 case "Query.inputNullableSlice":
1649 if e.complexity.Query.InputNullableSlice == nil {
1650 break
1651 }
1652
1653 args, err := ec.field_Query_inputNullableSlice_args(context.TODO(), rawArgs)
1654 if err != nil {
1655 return 0, false
1656 }
1657
1658 return e.complexity.Query.InputNullableSlice(childComplexity, args["arg"].([]string)), true
1659
1660 case "Query.inputOmittable":
1661 if e.complexity.Query.InputOmittable == nil {
1662 break
1663 }
1664
1665 args, err := ec.field_Query_inputOmittable_args(context.TODO(), rawArgs)
1666 if err != nil {
1667 return 0, false
1668 }
1669
1670 return e.complexity.Query.InputOmittable(childComplexity, args["arg"].(OmittableInput)), true
1671
1672 case "Query.inputSlice":
1673 if e.complexity.Query.InputSlice == nil {
1674 break
1675 }
1676
1677 args, err := ec.field_Query_inputSlice_args(context.TODO(), rawArgs)
1678 if err != nil {
1679 return 0, false
1680 }
1681
1682 return e.complexity.Query.InputSlice(childComplexity, args["arg"].([]string)), true
1683
1684 case "Query.invalid":
1685 if e.complexity.Query.Invalid == nil {
1686 break
1687 }
1688
1689 return e.complexity.Query.Invalid(childComplexity), true
1690
1691 case "Query.invalidIdentifier":
1692 if e.complexity.Query.InvalidIdentifier == nil {
1693 break
1694 }
1695
1696 return e.complexity.Query.InvalidIdentifier(childComplexity), true
1697
1698 case "Query.issue896a":
1699 if e.complexity.Query.Issue896a == nil {
1700 break
1701 }
1702
1703 return e.complexity.Query.Issue896a(childComplexity), true
1704
1705 case "Query.mapInput":
1706 if e.complexity.Query.MapInput == nil {
1707 break
1708 }
1709
1710 args, err := ec.field_Query_mapInput_args(context.TODO(), rawArgs)
1711 if err != nil {
1712 return 0, false
1713 }
1714
1715 return e.complexity.Query.MapInput(childComplexity, args["input"].(map[string]interface{})), true
1716
1717 case "Query.mapNestedStringInterface":
1718 if e.complexity.Query.MapNestedStringInterface == nil {
1719 break
1720 }
1721
1722 args, err := ec.field_Query_mapNestedStringInterface_args(context.TODO(), rawArgs)
1723 if err != nil {
1724 return 0, false
1725 }
1726
1727 return e.complexity.Query.MapNestedStringInterface(childComplexity, args["in"].(*NestedMapInput)), true
1728
1729 case "Query.mapStringInterface":
1730 if e.complexity.Query.MapStringInterface == nil {
1731 break
1732 }
1733
1734 args, err := ec.field_Query_mapStringInterface_args(context.TODO(), rawArgs)
1735 if err != nil {
1736 return 0, false
1737 }
1738
1739 return e.complexity.Query.MapStringInterface(childComplexity, args["in"].(map[string]interface{})), true
1740
1741 case "Query.modelMethods":
1742 if e.complexity.Query.ModelMethods == nil {
1743 break
1744 }
1745
1746 return e.complexity.Query.ModelMethods(childComplexity), true
1747
1748 case "Query.nestedInputs":
1749 if e.complexity.Query.NestedInputs == nil {
1750 break
1751 }
1752
1753 args, err := ec.field_Query_nestedInputs_args(context.TODO(), rawArgs)
1754 if err != nil {
1755 return 0, false
1756 }
1757
1758 return e.complexity.Query.NestedInputs(childComplexity, args["input"].([][]*OuterInput)), true
1759
1760 case "Query.nestedOutputs":
1761 if e.complexity.Query.NestedOutputs == nil {
1762 break
1763 }
1764
1765 return e.complexity.Query.NestedOutputs(childComplexity), true
1766
1767 case "Query.noShape":
1768 if e.complexity.Query.NoShape == nil {
1769 break
1770 }
1771
1772 return e.complexity.Query.NoShape(childComplexity), true
1773
1774 case "Query.noShapeTypedNil":
1775 if e.complexity.Query.NoShapeTypedNil == nil {
1776 break
1777 }
1778
1779 return e.complexity.Query.NoShapeTypedNil(childComplexity), true
1780
1781 case "Query.node":
1782 if e.complexity.Query.Node == nil {
1783 break
1784 }
1785
1786 return e.complexity.Query.Node(childComplexity), true
1787
1788 case "Query.notAnInterface":
1789 if e.complexity.Query.NotAnInterface == nil {
1790 break
1791 }
1792
1793 return e.complexity.Query.NotAnInterface(childComplexity), true
1794
1795 case "Query.nullableArg":
1796 if e.complexity.Query.NullableArg == nil {
1797 break
1798 }
1799
1800 args, err := ec.field_Query_nullableArg_args(context.TODO(), rawArgs)
1801 if err != nil {
1802 return 0, false
1803 }
1804
1805 return e.complexity.Query.NullableArg(childComplexity, args["arg"].(*int)), true
1806
1807 case "Query.optionalUnion":
1808 if e.complexity.Query.OptionalUnion == nil {
1809 break
1810 }
1811
1812 return e.complexity.Query.OptionalUnion(childComplexity), true
1813
1814 case "Query.overlapping":
1815 if e.complexity.Query.Overlapping == nil {
1816 break
1817 }
1818
1819 return e.complexity.Query.Overlapping(childComplexity), true
1820
1821 case "Query.panics":
1822 if e.complexity.Query.Panics == nil {
1823 break
1824 }
1825
1826 return e.complexity.Query.Panics(childComplexity), true
1827
1828 case "Query.primitiveObject":
1829 if e.complexity.Query.PrimitiveObject == nil {
1830 break
1831 }
1832
1833 return e.complexity.Query.PrimitiveObject(childComplexity), true
1834
1835 case "Query.primitiveStringObject":
1836 if e.complexity.Query.PrimitiveStringObject == nil {
1837 break
1838 }
1839
1840 return e.complexity.Query.PrimitiveStringObject(childComplexity), true
1841
1842 case "Query.ptrToAnyContainer":
1843 if e.complexity.Query.PtrToAnyContainer == nil {
1844 break
1845 }
1846
1847 return e.complexity.Query.PtrToAnyContainer(childComplexity), true
1848
1849 case "Query.ptrToSliceContainer":
1850 if e.complexity.Query.PtrToSliceContainer == nil {
1851 break
1852 }
1853
1854 return e.complexity.Query.PtrToSliceContainer(childComplexity), true
1855
1856 case "Query.recursive":
1857 if e.complexity.Query.Recursive == nil {
1858 break
1859 }
1860
1861 args, err := ec.field_Query_recursive_args(context.TODO(), rawArgs)
1862 if err != nil {
1863 return 0, false
1864 }
1865
1866 return e.complexity.Query.Recursive(childComplexity, args["input"].(*RecursiveInputSlice)), true
1867
1868 case "Query.scalarSlice":
1869 if e.complexity.Query.ScalarSlice == nil {
1870 break
1871 }
1872
1873 return e.complexity.Query.ScalarSlice(childComplexity), true
1874
1875 case "Query.shapeUnion":
1876 if e.complexity.Query.ShapeUnion == nil {
1877 break
1878 }
1879
1880 return e.complexity.Query.ShapeUnion(childComplexity), true
1881
1882 case "Query.shapes":
1883 if e.complexity.Query.Shapes == nil {
1884 break
1885 }
1886
1887 return e.complexity.Query.Shapes(childComplexity), true
1888
1889 case "Query.slices":
1890 if e.complexity.Query.Slices == nil {
1891 break
1892 }
1893
1894 return e.complexity.Query.Slices(childComplexity), true
1895
1896 case "Query.stringFromContextFunction":
1897 if e.complexity.Query.StringFromContextFunction == nil {
1898 break
1899 }
1900
1901 return e.complexity.Query.StringFromContextFunction(childComplexity), true
1902
1903 case "Query.stringFromContextInterface":
1904 if e.complexity.Query.StringFromContextInterface == nil {
1905 break
1906 }
1907
1908 return e.complexity.Query.StringFromContextInterface(childComplexity), true
1909
1910 case "Query.user":
1911 if e.complexity.Query.User == nil {
1912 break
1913 }
1914
1915 args, err := ec.field_Query_user_args(context.TODO(), rawArgs)
1916 if err != nil {
1917 return 0, false
1918 }
1919
1920 return e.complexity.Query.User(childComplexity, args["id"].(int)), true
1921
1922 case "Query.vOkCaseNil":
1923 if e.complexity.Query.VOkCaseNil == nil {
1924 break
1925 }
1926
1927 return e.complexity.Query.VOkCaseNil(childComplexity), true
1928
1929 case "Query.vOkCaseValue":
1930 if e.complexity.Query.VOkCaseValue == nil {
1931 break
1932 }
1933
1934 return e.complexity.Query.VOkCaseValue(childComplexity), true
1935
1936 case "Query.valid":
1937 if e.complexity.Query.Valid == nil {
1938 break
1939 }
1940
1941 return e.complexity.Query.Valid(childComplexity), true
1942
1943 case "Query.validType":
1944 if e.complexity.Query.ValidType == nil {
1945 break
1946 }
1947
1948 return e.complexity.Query.ValidType(childComplexity), true
1949
1950 case "Query.variadicModel":
1951 if e.complexity.Query.VariadicModel == nil {
1952 break
1953 }
1954
1955 return e.complexity.Query.VariadicModel(childComplexity), true
1956
1957 case "Query.wrappedMap":
1958 if e.complexity.Query.WrappedMap == nil {
1959 break
1960 }
1961
1962 return e.complexity.Query.WrappedMap(childComplexity), true
1963
1964 case "Query.wrappedScalar":
1965 if e.complexity.Query.WrappedScalar == nil {
1966 break
1967 }
1968
1969 return e.complexity.Query.WrappedScalar(childComplexity), true
1970
1971 case "Query.wrappedSlice":
1972 if e.complexity.Query.WrappedSlice == nil {
1973 break
1974 }
1975
1976 return e.complexity.Query.WrappedSlice(childComplexity), true
1977
1978 case "Query.wrappedStruct":
1979 if e.complexity.Query.WrappedStruct == nil {
1980 break
1981 }
1982
1983 return e.complexity.Query.WrappedStruct(childComplexity), true
1984
1985 case "Rectangle.area":
1986 if e.complexity.Rectangle.Area == nil {
1987 break
1988 }
1989
1990 return e.complexity.Rectangle.Area(childComplexity), true
1991
1992 case "Rectangle.coordinates":
1993 if e.complexity.Rectangle.Coordinates == nil {
1994 break
1995 }
1996
1997 return e.complexity.Rectangle.Coordinates(childComplexity), true
1998
1999 case "Rectangle.length":
2000 if e.complexity.Rectangle.Length == nil {
2001 break
2002 }
2003
2004 return e.complexity.Rectangle.Length(childComplexity), true
2005
2006 case "Rectangle.width":
2007 if e.complexity.Rectangle.Width == nil {
2008 break
2009 }
2010
2011 return e.complexity.Rectangle.Width(childComplexity), true
2012
2013 case "Size.height":
2014 if e.complexity.Size.Height == nil {
2015 break
2016 }
2017
2018 return e.complexity.Size.Height(childComplexity), true
2019
2020 case "Size.weight":
2021 if e.complexity.Size.Weight == nil {
2022 break
2023 }
2024
2025 return e.complexity.Size.Weight(childComplexity), true
2026
2027 case "Slices.test1":
2028 if e.complexity.Slices.Test1 == nil {
2029 break
2030 }
2031
2032 return e.complexity.Slices.Test1(childComplexity), true
2033
2034 case "Slices.test2":
2035 if e.complexity.Slices.Test2 == nil {
2036 break
2037 }
2038
2039 return e.complexity.Slices.Test2(childComplexity), true
2040
2041 case "Slices.test3":
2042 if e.complexity.Slices.Test3 == nil {
2043 break
2044 }
2045
2046 return e.complexity.Slices.Test3(childComplexity), true
2047
2048 case "Slices.test4":
2049 if e.complexity.Slices.Test4 == nil {
2050 break
2051 }
2052
2053 return e.complexity.Slices.Test4(childComplexity), true
2054
2055 case "Subscription.directiveArg":
2056 if e.complexity.Subscription.DirectiveArg == nil {
2057 break
2058 }
2059
2060 args, err := ec.field_Subscription_directiveArg_args(context.TODO(), rawArgs)
2061 if err != nil {
2062 return 0, false
2063 }
2064
2065 return e.complexity.Subscription.DirectiveArg(childComplexity, args["arg"].(string)), true
2066
2067 case "Subscription.directiveDouble":
2068 if e.complexity.Subscription.DirectiveDouble == nil {
2069 break
2070 }
2071
2072 return e.complexity.Subscription.DirectiveDouble(childComplexity), true
2073
2074 case "Subscription.directiveNullableArg":
2075 if e.complexity.Subscription.DirectiveNullableArg == nil {
2076 break
2077 }
2078
2079 args, err := ec.field_Subscription_directiveNullableArg_args(context.TODO(), rawArgs)
2080 if err != nil {
2081 return 0, false
2082 }
2083
2084 return e.complexity.Subscription.DirectiveNullableArg(childComplexity, args["arg"].(*int), args["arg2"].(*int), args["arg3"].(*string)), true
2085
2086 case "Subscription.directiveUnimplemented":
2087 if e.complexity.Subscription.DirectiveUnimplemented == nil {
2088 break
2089 }
2090
2091 return e.complexity.Subscription.DirectiveUnimplemented(childComplexity), true
2092
2093 case "Subscription.errorRequired":
2094 if e.complexity.Subscription.ErrorRequired == nil {
2095 break
2096 }
2097
2098 return e.complexity.Subscription.ErrorRequired(childComplexity), true
2099
2100 case "Subscription.initPayload":
2101 if e.complexity.Subscription.InitPayload == nil {
2102 break
2103 }
2104
2105 return e.complexity.Subscription.InitPayload(childComplexity), true
2106
2107 case "Subscription.issue896b":
2108 if e.complexity.Subscription.Issue896b == nil {
2109 break
2110 }
2111
2112 return e.complexity.Subscription.Issue896b(childComplexity), true
2113
2114 case "Subscription.updated":
2115 if e.complexity.Subscription.Updated == nil {
2116 break
2117 }
2118
2119 return e.complexity.Subscription.Updated(childComplexity), true
2120
2121 case "User.created":
2122 if e.complexity.User.Created == nil {
2123 break
2124 }
2125
2126 return e.complexity.User.Created(childComplexity), true
2127
2128 case "User.friends":
2129 if e.complexity.User.Friends == nil {
2130 break
2131 }
2132
2133 return e.complexity.User.Friends(childComplexity), true
2134
2135 case "User.id":
2136 if e.complexity.User.ID == nil {
2137 break
2138 }
2139
2140 return e.complexity.User.ID(childComplexity), true
2141
2142 case "User.pets":
2143 if e.complexity.User.Pets == nil {
2144 break
2145 }
2146
2147 args, err := ec.field_User_pets_args(context.TODO(), rawArgs)
2148 if err != nil {
2149 return 0, false
2150 }
2151
2152 return e.complexity.User.Pets(childComplexity, args["limit"].(*int)), true
2153
2154 case "User.updated":
2155 if e.complexity.User.Updated == nil {
2156 break
2157 }
2158
2159 return e.complexity.User.Updated(childComplexity), true
2160
2161 case "VOkCaseNil.value":
2162 if e.complexity.VOkCaseNil.Value == nil {
2163 break
2164 }
2165
2166 return e.complexity.VOkCaseNil.Value(childComplexity), true
2167
2168 case "VOkCaseValue.value":
2169 if e.complexity.VOkCaseValue.Value == nil {
2170 break
2171 }
2172
2173 return e.complexity.VOkCaseValue.Value(childComplexity), true
2174
2175 case "ValidType.differentCase":
2176 if e.complexity.ValidType.DifferentCase == nil {
2177 break
2178 }
2179
2180 return e.complexity.ValidType.DifferentCase(childComplexity), true
2181
2182 case "ValidType.different_case":
2183 if e.complexity.ValidType.DifferentCaseOld == nil {
2184 break
2185 }
2186
2187 return e.complexity.ValidType.DifferentCaseOld(childComplexity), true
2188
2189 case "ValidType.validArgs":
2190 if e.complexity.ValidType.ValidArgs == nil {
2191 break
2192 }
2193
2194 args, err := ec.field_ValidType_validArgs_args(context.TODO(), rawArgs)
2195 if err != nil {
2196 return 0, false
2197 }
2198
2199 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
2200
2201 case "ValidType.validInputKeywords":
2202 if e.complexity.ValidType.ValidInputKeywords == nil {
2203 break
2204 }
2205
2206 args, err := ec.field_ValidType_validInputKeywords_args(context.TODO(), rawArgs)
2207 if err != nil {
2208 return 0, false
2209 }
2210
2211 return e.complexity.ValidType.ValidInputKeywords(childComplexity, args["input"].(*ValidInput)), true
2212
2213 case "VariadicModel.value":
2214 if e.complexity.VariadicModel.Value == nil {
2215 break
2216 }
2217
2218 args, err := ec.field_VariadicModel_value_args(context.TODO(), rawArgs)
2219 if err != nil {
2220 return 0, false
2221 }
2222
2223 return e.complexity.VariadicModel.Value(childComplexity, args["rank"].(int)), true
2224
2225 case "WrappedMap.get":
2226 if e.complexity.WrappedMap.Get == nil {
2227 break
2228 }
2229
2230 args, err := ec.field_WrappedMap_get_args(context.TODO(), rawArgs)
2231 if err != nil {
2232 return 0, false
2233 }
2234
2235 return e.complexity.WrappedMap.Get(childComplexity, args["key"].(string)), true
2236
2237 case "WrappedSlice.get":
2238 if e.complexity.WrappedSlice.Get == nil {
2239 break
2240 }
2241
2242 args, err := ec.field_WrappedSlice_get_args(context.TODO(), rawArgs)
2243 if err != nil {
2244 return 0, false
2245 }
2246
2247 return e.complexity.WrappedSlice.Get(childComplexity, args["idx"].(int)), true
2248
2249 case "WrappedStruct.desc":
2250 if e.complexity.WrappedStruct.Desc == nil {
2251 break
2252 }
2253
2254 return e.complexity.WrappedStruct.Desc(childComplexity), true
2255
2256 case "WrappedStruct.name":
2257 if e.complexity.WrappedStruct.Name == nil {
2258 break
2259 }
2260
2261 return e.complexity.WrappedStruct.Name(childComplexity), true
2262
2263 case "XXIt.id":
2264 if e.complexity.XXIt.ID == nil {
2265 break
2266 }
2267
2268 return e.complexity.XXIt.ID(childComplexity), true
2269
2270 case "XxIt.id":
2271 if e.complexity.XxIt.ID == nil {
2272 break
2273 }
2274
2275 return e.complexity.XxIt.ID(childComplexity), true
2276
2277 case "asdfIt.id":
2278 if e.complexity.AsdfIt.ID == nil {
2279 break
2280 }
2281
2282 return e.complexity.AsdfIt.ID(childComplexity), true
2283
2284 case "iIt.id":
2285 if e.complexity.IIt.ID == nil {
2286 break
2287 }
2288
2289 return e.complexity.IIt.ID(childComplexity), true
2290
2291 }
2292 return 0, false
2293 }
2294
2295 func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
2296 rc := graphql.GetOperationContext(ctx)
2297 ec := executionContext{rc, e, 0, 0, make(chan graphql.DeferredResult)}
2298 inputUnmarshalMap := graphql.BuildUnmarshalerMap(
2299 ec.unmarshalInputChanges,
2300 ec.unmarshalInputDefaultInput,
2301 ec.unmarshalInputFieldsOrderInput,
2302 ec.unmarshalInputInnerDirectives,
2303 ec.unmarshalInputInnerInput,
2304 ec.unmarshalInputInputDirectives,
2305 ec.unmarshalInputInputWithEnumValue,
2306 ec.unmarshalInputMapNestedInput,
2307 ec.unmarshalInputMapStringInterfaceInput,
2308 ec.unmarshalInputNestedInput,
2309 ec.unmarshalInputNestedMapInput,
2310 ec.unmarshalInputOmittableInput,
2311 ec.unmarshalInputOuterInput,
2312 ec.unmarshalInputRecursiveInputSlice,
2313 ec.unmarshalInputSpecialInput,
2314 ec.unmarshalInputUpdatePtrToPtrInner,
2315 ec.unmarshalInputUpdatePtrToPtrOuter,
2316 ec.unmarshalInputValidInput,
2317 )
2318 first := true
2319
2320 switch rc.Operation.Operation {
2321 case ast.Query:
2322 return func(ctx context.Context) *graphql.Response {
2323 var response graphql.Response
2324 var data graphql.Marshaler
2325 if first {
2326 first = false
2327 ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
2328 data = ec._Query(ctx, rc.Operation.SelectionSet)
2329 } else {
2330 if atomic.LoadInt32(&ec.pendingDeferred) > 0 {
2331 result := <-ec.deferredResults
2332 atomic.AddInt32(&ec.pendingDeferred, -1)
2333 data = result.Result
2334 response.Path = result.Path
2335 response.Label = result.Label
2336 response.Errors = result.Errors
2337 } else {
2338 return nil
2339 }
2340 }
2341 var buf bytes.Buffer
2342 data.MarshalGQL(&buf)
2343 response.Data = buf.Bytes()
2344 if atomic.LoadInt32(&ec.deferred) > 0 {
2345 hasNext := atomic.LoadInt32(&ec.pendingDeferred) > 0
2346 response.HasNext = &hasNext
2347 }
2348
2349 return &response
2350 }
2351 case ast.Mutation:
2352 return func(ctx context.Context) *graphql.Response {
2353 if !first {
2354 return nil
2355 }
2356 first = false
2357 ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
2358 data := ec._Mutation(ctx, rc.Operation.SelectionSet)
2359 var buf bytes.Buffer
2360 data.MarshalGQL(&buf)
2361
2362 return &graphql.Response{
2363 Data: buf.Bytes(),
2364 }
2365 }
2366 case ast.Subscription:
2367 next := ec._Subscription(ctx, rc.Operation.SelectionSet)
2368
2369 var buf bytes.Buffer
2370 return func(ctx context.Context) *graphql.Response {
2371 buf.Reset()
2372 data := next(ctx)
2373
2374 if data == nil {
2375 return nil
2376 }
2377 data.MarshalGQL(&buf)
2378
2379 return &graphql.Response{
2380 Data: buf.Bytes(),
2381 }
2382 }
2383
2384 default:
2385 return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
2386 }
2387 }
2388
2389 type executionContext struct {
2390 *graphql.OperationContext
2391 *executableSchema
2392 deferred int32
2393 pendingDeferred int32
2394 deferredResults chan graphql.DeferredResult
2395 }
2396
2397 func (ec *executionContext) processDeferredGroup(dg graphql.DeferredGroup) {
2398 atomic.AddInt32(&ec.pendingDeferred, 1)
2399 go func() {
2400 ctx := graphql.WithFreshResponseContext(dg.Context)
2401 dg.FieldSet.Dispatch(ctx)
2402 ds := graphql.DeferredResult{
2403 Path: dg.Path,
2404 Label: dg.Label,
2405 Result: dg.FieldSet,
2406 Errors: graphql.GetErrors(ctx),
2407 }
2408
2409 if dg.FieldSet.Invalids > 0 {
2410 ds.Result = graphql.Null
2411 }
2412 ec.deferredResults <- ds
2413 }()
2414 }
2415
2416 func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
2417 if ec.DisableIntrospection {
2418 return nil, errors.New("introspection disabled")
2419 }
2420 return introspection.WrapSchema(ec.Schema()), nil
2421 }
2422
2423 func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
2424 if ec.DisableIntrospection {
2425 return nil, errors.New("introspection disabled")
2426 }
2427 return introspection.WrapTypeFromDef(ec.Schema(), ec.Schema().Types[name]), nil
2428 }
2429
2430
2431 var sourcesFS embed.FS
2432
2433 func sourceData(filename string) string {
2434 data, err := sourcesFS.ReadFile(filename)
2435 if err != nil {
2436 panic(fmt.Sprintf("codegen problem: %s not available", filename))
2437 }
2438 return string(data)
2439 }
2440
2441 var sources = []*ast.Source{
2442 {Name: "builtinscalar.graphql", Input: sourceData("builtinscalar.graphql"), BuiltIn: false},
2443 {Name: "complexity.graphql", Input: sourceData("complexity.graphql"), BuiltIn: false},
2444 {Name: "defaults.graphql", Input: sourceData("defaults.graphql"), BuiltIn: false},
2445 {Name: "defer.graphql", Input: sourceData("defer.graphql"), BuiltIn: false},
2446 {Name: "directive.graphql", Input: sourceData("directive.graphql"), BuiltIn: false},
2447 {Name: "embedded.graphql", Input: sourceData("embedded.graphql"), BuiltIn: false},
2448 {Name: "enum.graphql", Input: sourceData("enum.graphql"), BuiltIn: false},
2449 {Name: "fields_order.graphql", Input: sourceData("fields_order.graphql"), BuiltIn: false},
2450 {Name: "interfaces.graphql", Input: sourceData("interfaces.graphql"), BuiltIn: false},
2451 {Name: "issue896.graphql", Input: sourceData("issue896.graphql"), BuiltIn: false},
2452 {Name: "loops.graphql", Input: sourceData("loops.graphql"), BuiltIn: false},
2453 {Name: "maps.graphql", Input: sourceData("maps.graphql"), BuiltIn: false},
2454 {Name: "mutation_with_custom_scalar.graphql", Input: sourceData("mutation_with_custom_scalar.graphql"), BuiltIn: false},
2455 {Name: "nulls.graphql", Input: sourceData("nulls.graphql"), BuiltIn: false},
2456 {Name: "panics.graphql", Input: sourceData("panics.graphql"), BuiltIn: false},
2457 {Name: "primitive_objects.graphql", Input: sourceData("primitive_objects.graphql"), BuiltIn: false},
2458 {Name: "ptr_to_any.graphql", Input: sourceData("ptr_to_any.graphql"), BuiltIn: false},
2459 {Name: "ptr_to_ptr_input.graphql", Input: sourceData("ptr_to_ptr_input.graphql"), BuiltIn: false},
2460 {Name: "ptr_to_slice.graphql", Input: sourceData("ptr_to_slice.graphql"), BuiltIn: false},
2461 {Name: "scalar_context.graphql", Input: sourceData("scalar_context.graphql"), BuiltIn: false},
2462 {Name: "scalar_default.graphql", Input: sourceData("scalar_default.graphql"), BuiltIn: false},
2463 {Name: "schema.graphql", Input: sourceData("schema.graphql"), BuiltIn: false},
2464 {Name: "slices.graphql", Input: sourceData("slices.graphql"), BuiltIn: false},
2465 {Name: "typefallback.graphql", Input: sourceData("typefallback.graphql"), BuiltIn: false},
2466 {Name: "useptr.graphql", Input: sourceData("useptr.graphql"), BuiltIn: false},
2467 {Name: "v-ok.graphql", Input: sourceData("v-ok.graphql"), BuiltIn: false},
2468 {Name: "validtypes.graphql", Input: sourceData("validtypes.graphql"), BuiltIn: false},
2469 {Name: "variadic.graphql", Input: sourceData("variadic.graphql"), BuiltIn: false},
2470 {Name: "weird_type_cases.graphql", Input: sourceData("weird_type_cases.graphql"), BuiltIn: false},
2471 {Name: "wrapped_type.graphql", Input: sourceData("wrapped_type.graphql"), BuiltIn: false},
2472 }
2473 var parsedSchema = gqlparser.MustLoadSchema(sources...)
2474
2475
2476
2477
2478
2479 func (ec *executionContext) dir_defer_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2480 var err error
2481 args := map[string]interface{}{}
2482 var arg0 *bool
2483 if tmp, ok := rawArgs["if"]; ok {
2484 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("if"))
2485 arg0, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
2486 if err != nil {
2487 return nil, err
2488 }
2489 }
2490 args["if"] = arg0
2491 var arg1 *string
2492 if tmp, ok := rawArgs["label"]; ok {
2493 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("label"))
2494 arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2495 if err != nil {
2496 return nil, err
2497 }
2498 }
2499 args["label"] = arg1
2500 return args, nil
2501 }
2502
2503 func (ec *executionContext) dir_length_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2504 var err error
2505 args := map[string]interface{}{}
2506 var arg0 int
2507 if tmp, ok := rawArgs["min"]; ok {
2508 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("min"))
2509 arg0, err = ec.unmarshalNInt2int(ctx, tmp)
2510 if err != nil {
2511 return nil, err
2512 }
2513 }
2514 args["min"] = arg0
2515 var arg1 *int
2516 if tmp, ok := rawArgs["max"]; ok {
2517 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("max"))
2518 arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2519 if err != nil {
2520 return nil, err
2521 }
2522 }
2523 args["max"] = arg1
2524 var arg2 *string
2525 if tmp, ok := rawArgs["message"]; ok {
2526 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
2527 arg2, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
2528 if err != nil {
2529 return nil, err
2530 }
2531 }
2532 args["message"] = arg2
2533 return args, nil
2534 }
2535
2536 func (ec *executionContext) dir_logged_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2537 var err error
2538 args := map[string]interface{}{}
2539 var arg0 string
2540 if tmp, ok := rawArgs["id"]; ok {
2541 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
2542 arg0, err = ec.unmarshalNUUID2string(ctx, tmp)
2543 if err != nil {
2544 return nil, err
2545 }
2546 }
2547 args["id"] = arg0
2548 return args, nil
2549 }
2550
2551 func (ec *executionContext) dir_order1_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2552 var err error
2553 args := map[string]interface{}{}
2554 var arg0 string
2555 if tmp, ok := rawArgs["location"]; ok {
2556 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("location"))
2557 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2558 if err != nil {
2559 return nil, err
2560 }
2561 }
2562 args["location"] = arg0
2563 return args, nil
2564 }
2565
2566 func (ec *executionContext) dir_order2_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2567 var err error
2568 args := map[string]interface{}{}
2569 var arg0 string
2570 if tmp, ok := rawArgs["location"]; ok {
2571 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("location"))
2572 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2573 if err != nil {
2574 return nil, err
2575 }
2576 }
2577 args["location"] = arg0
2578 return args, nil
2579 }
2580
2581 func (ec *executionContext) dir_range_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2582 var err error
2583 args := map[string]interface{}{}
2584 var arg0 *int
2585 if tmp, ok := rawArgs["min"]; ok {
2586 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("min"))
2587 arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2588 if err != nil {
2589 return nil, err
2590 }
2591 }
2592 args["min"] = arg0
2593 var arg1 *int
2594 if tmp, ok := rawArgs["max"]; ok {
2595 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("max"))
2596 arg1, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2597 if err != nil {
2598 return nil, err
2599 }
2600 }
2601 args["max"] = arg1
2602 return args, nil
2603 }
2604
2605 func (ec *executionContext) field_Mutation_defaultInput_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2606 var err error
2607 args := map[string]interface{}{}
2608 var arg0 DefaultInput
2609 if tmp, ok := rawArgs["input"]; ok {
2610 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2611 arg0, err = ec.unmarshalNDefaultInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐDefaultInput(ctx, tmp)
2612 if err != nil {
2613 return nil, err
2614 }
2615 }
2616 args["input"] = arg0
2617 return args, nil
2618 }
2619
2620 func (ec *executionContext) field_Mutation_overrideValueViaInput_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2621 var err error
2622 args := map[string]interface{}{}
2623 var arg0 FieldsOrderInput
2624 if tmp, ok := rawArgs["input"]; ok {
2625 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2626 arg0, err = ec.unmarshalNFieldsOrderInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐFieldsOrderInput(ctx, tmp)
2627 if err != nil {
2628 return nil, err
2629 }
2630 }
2631 args["input"] = arg0
2632 return args, nil
2633 }
2634
2635 func (ec *executionContext) field_Mutation_updatePtrToPtr_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2636 var err error
2637 args := map[string]interface{}{}
2638 var arg0 UpdatePtrToPtrOuter
2639 if tmp, ok := rawArgs["input"]; ok {
2640 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2641 arg0, err = ec.unmarshalNUpdatePtrToPtrOuter2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrOuter(ctx, tmp)
2642 if err != nil {
2643 return nil, err
2644 }
2645 }
2646 args["input"] = arg0
2647 return args, nil
2648 }
2649
2650 func (ec *executionContext) field_Mutation_updateSomething_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2651 var err error
2652 args := map[string]interface{}{}
2653 var arg0 SpecialInput
2654 if tmp, ok := rawArgs["input"]; ok {
2655 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2656 arg0, err = ec.unmarshalNSpecialInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐSpecialInput(ctx, tmp)
2657 if err != nil {
2658 return nil, err
2659 }
2660 }
2661 args["input"] = arg0
2662 return args, nil
2663 }
2664
2665 func (ec *executionContext) field_Panics_argUnmarshal_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2666 var err error
2667 args := map[string]interface{}{}
2668 var arg0 []MarshalPanic
2669 if tmp, ok := rawArgs["u"]; ok {
2670 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("u"))
2671 arg0, err = ec.unmarshalNMarshalPanic2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐMarshalPanicᚄ(ctx, tmp)
2672 if err != nil {
2673 return nil, err
2674 }
2675 }
2676 args["u"] = arg0
2677 return args, nil
2678 }
2679
2680 func (ec *executionContext) field_Panics_fieldFuncMarshal_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2681 var err error
2682 args := map[string]interface{}{}
2683 var arg0 []MarshalPanic
2684 if tmp, ok := rawArgs["u"]; ok {
2685 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("u"))
2686 arg0, err = ec.unmarshalNMarshalPanic2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐMarshalPanicᚄ(ctx, tmp)
2687 if err != nil {
2688 return nil, err
2689 }
2690 }
2691 args["u"] = arg0
2692 return args, nil
2693 }
2694
2695 func (ec *executionContext) field_Pet_friends_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2696 var err error
2697 args := map[string]interface{}{}
2698 var arg0 *int
2699 if tmp, ok := rawArgs["limit"]; ok {
2700 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
2701 arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
2702 if err != nil {
2703 return nil, err
2704 }
2705 }
2706 args["limit"] = arg0
2707 return args, nil
2708 }
2709
2710 func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2711 var err error
2712 args := map[string]interface{}{}
2713 var arg0 string
2714 if tmp, ok := rawArgs["name"]; ok {
2715 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
2716 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2717 if err != nil {
2718 return nil, err
2719 }
2720 }
2721 args["name"] = arg0
2722 return args, nil
2723 }
2724
2725 func (ec *executionContext) field_Query_defaultParameters_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2726 var err error
2727 args := map[string]interface{}{}
2728 var arg0 *bool
2729 if tmp, ok := rawArgs["falsyBoolean"]; ok {
2730 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("falsyBoolean"))
2731 arg0, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
2732 if err != nil {
2733 return nil, err
2734 }
2735 }
2736 args["falsyBoolean"] = arg0
2737 var arg1 *bool
2738 if tmp, ok := rawArgs["truthyBoolean"]; ok {
2739 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("truthyBoolean"))
2740 arg1, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
2741 if err != nil {
2742 return nil, err
2743 }
2744 }
2745 args["truthyBoolean"] = arg1
2746 return args, nil
2747 }
2748
2749 func (ec *executionContext) field_Query_defaultScalar_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2750 var err error
2751 args := map[string]interface{}{}
2752 var arg0 string
2753 if tmp, ok := rawArgs["arg"]; ok {
2754 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
2755 arg0, err = ec.unmarshalNDefaultScalarImplementation2string(ctx, tmp)
2756 if err != nil {
2757 return nil, err
2758 }
2759 }
2760 args["arg"] = arg0
2761 return args, nil
2762 }
2763
2764 func (ec *executionContext) field_Query_directiveArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2765 var err error
2766 args := map[string]interface{}{}
2767 var arg0 string
2768 if tmp, ok := rawArgs["arg"]; ok {
2769 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
2770 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalNString2string(ctx, tmp) }
2771 directive1 := func(ctx context.Context) (interface{}, error) {
2772 min, err := ec.unmarshalNInt2int(ctx, 1)
2773 if err != nil {
2774 return nil, err
2775 }
2776 max, err := ec.unmarshalOInt2ᚖint(ctx, 255)
2777 if err != nil {
2778 return nil, err
2779 }
2780 message, err := ec.unmarshalOString2ᚖstring(ctx, "invalid length")
2781 if err != nil {
2782 return nil, err
2783 }
2784 if ec.directives.Length == nil {
2785 return nil, errors.New("directive length is not implemented")
2786 }
2787 return ec.directives.Length(ctx, rawArgs, directive0, min, max, message)
2788 }
2789
2790 tmp, err = directive1(ctx)
2791 if err != nil {
2792 return nil, graphql.ErrorOnPath(ctx, err)
2793 }
2794 if data, ok := tmp.(string); ok {
2795 arg0 = data
2796 } else {
2797 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp))
2798 }
2799 }
2800 args["arg"] = arg0
2801 return args, nil
2802 }
2803
2804 func (ec *executionContext) field_Query_directiveFieldDef_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2805 var err error
2806 args := map[string]interface{}{}
2807 var arg0 string
2808 if tmp, ok := rawArgs["ret"]; ok {
2809 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ret"))
2810 arg0, err = ec.unmarshalNString2string(ctx, tmp)
2811 if err != nil {
2812 return nil, err
2813 }
2814 }
2815 args["ret"] = arg0
2816 return args, nil
2817 }
2818
2819 func (ec *executionContext) field_Query_directiveInputNullable_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2820 var err error
2821 args := map[string]interface{}{}
2822 var arg0 *InputDirectives
2823 if tmp, ok := rawArgs["arg"]; ok {
2824 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
2825 arg0, err = ec.unmarshalOInputDirectives2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInputDirectives(ctx, tmp)
2826 if err != nil {
2827 return nil, err
2828 }
2829 }
2830 args["arg"] = arg0
2831 return args, nil
2832 }
2833
2834 func (ec *executionContext) field_Query_directiveInputType_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2835 var err error
2836 args := map[string]interface{}{}
2837 var arg0 InnerInput
2838 if tmp, ok := rawArgs["arg"]; ok {
2839 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
2840 directive0 := func(ctx context.Context) (interface{}, error) {
2841 return ec.unmarshalNInnerInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInnerInput(ctx, tmp)
2842 }
2843 directive1 := func(ctx context.Context) (interface{}, error) {
2844 if ec.directives.Custom == nil {
2845 return nil, errors.New("directive custom is not implemented")
2846 }
2847 return ec.directives.Custom(ctx, rawArgs, directive0)
2848 }
2849
2850 tmp, err = directive1(ctx)
2851 if err != nil {
2852 return nil, graphql.ErrorOnPath(ctx, err)
2853 }
2854 if data, ok := tmp.(InnerInput); ok {
2855 arg0 = data
2856 } else {
2857 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be github.com/99designs/gqlgen/codegen/testserver/singlefile.InnerInput`, tmp))
2858 }
2859 }
2860 args["arg"] = arg0
2861 return args, nil
2862 }
2863
2864 func (ec *executionContext) field_Query_directiveInput_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2865 var err error
2866 args := map[string]interface{}{}
2867 var arg0 InputDirectives
2868 if tmp, ok := rawArgs["arg"]; ok {
2869 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
2870 arg0, err = ec.unmarshalNInputDirectives2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInputDirectives(ctx, tmp)
2871 if err != nil {
2872 return nil, err
2873 }
2874 }
2875 args["arg"] = arg0
2876 return args, nil
2877 }
2878
2879 func (ec *executionContext) field_Query_directiveNullableArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2880 var err error
2881 args := map[string]interface{}{}
2882 var arg0 *int
2883 if tmp, ok := rawArgs["arg"]; ok {
2884 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
2885 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) }
2886 directive1 := func(ctx context.Context) (interface{}, error) {
2887 min, err := ec.unmarshalOInt2ᚖint(ctx, 0)
2888 if err != nil {
2889 return nil, err
2890 }
2891 if ec.directives.Range == nil {
2892 return nil, errors.New("directive range is not implemented")
2893 }
2894 return ec.directives.Range(ctx, rawArgs, directive0, min, nil)
2895 }
2896
2897 tmp, err = directive1(ctx)
2898 if err != nil {
2899 return nil, graphql.ErrorOnPath(ctx, err)
2900 }
2901 if data, ok := tmp.(*int); ok {
2902 arg0 = data
2903 } else if tmp == nil {
2904 arg0 = nil
2905 } else {
2906 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp))
2907 }
2908 }
2909 args["arg"] = arg0
2910 var arg1 *int
2911 if tmp, ok := rawArgs["arg2"]; ok {
2912 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg2"))
2913 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) }
2914 directive1 := func(ctx context.Context) (interface{}, error) {
2915 min, err := ec.unmarshalOInt2ᚖint(ctx, 0)
2916 if err != nil {
2917 return nil, err
2918 }
2919 if ec.directives.Range == nil {
2920 return nil, errors.New("directive range is not implemented")
2921 }
2922 return ec.directives.Range(ctx, rawArgs, directive0, min, nil)
2923 }
2924
2925 tmp, err = directive1(ctx)
2926 if err != nil {
2927 return nil, graphql.ErrorOnPath(ctx, err)
2928 }
2929 if data, ok := tmp.(*int); ok {
2930 arg1 = data
2931 } else if tmp == nil {
2932 arg1 = nil
2933 } else {
2934 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp))
2935 }
2936 }
2937 args["arg2"] = arg1
2938 var arg2 *string
2939 if tmp, ok := rawArgs["arg3"]; ok {
2940 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg3"))
2941 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOString2ᚖstring(ctx, tmp) }
2942 directive1 := func(ctx context.Context) (interface{}, error) {
2943 if ec.directives.ToNull == nil {
2944 return nil, errors.New("directive toNull is not implemented")
2945 }
2946 return ec.directives.ToNull(ctx, rawArgs, directive0)
2947 }
2948
2949 tmp, err = directive1(ctx)
2950 if err != nil {
2951 return nil, graphql.ErrorOnPath(ctx, err)
2952 }
2953 if data, ok := tmp.(*string); ok {
2954 arg2 = data
2955 } else if tmp == nil {
2956 arg2 = nil
2957 } else {
2958 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp))
2959 }
2960 }
2961 args["arg3"] = arg2
2962 return args, nil
2963 }
2964
2965 func (ec *executionContext) field_Query_enumInInput_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2966 var err error
2967 args := map[string]interface{}{}
2968 var arg0 *InputWithEnumValue
2969 if tmp, ok := rawArgs["input"]; ok {
2970 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
2971 arg0, err = ec.unmarshalOInputWithEnumValue2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInputWithEnumValue(ctx, tmp)
2972 if err != nil {
2973 return nil, err
2974 }
2975 }
2976 args["input"] = arg0
2977 return args, nil
2978 }
2979
2980 func (ec *executionContext) field_Query_fallback_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2981 var err error
2982 args := map[string]interface{}{}
2983 var arg0 FallbackToStringEncoding
2984 if tmp, ok := rawArgs["arg"]; ok {
2985 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
2986 arg0, err = ec.unmarshalNFallbackToStringEncoding2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐFallbackToStringEncoding(ctx, tmp)
2987 if err != nil {
2988 return nil, err
2989 }
2990 }
2991 args["arg"] = arg0
2992 return args, nil
2993 }
2994
2995 func (ec *executionContext) field_Query_inputNullableSlice_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2996 var err error
2997 args := map[string]interface{}{}
2998 var arg0 []string
2999 if tmp, ok := rawArgs["arg"]; ok {
3000 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
3001 arg0, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
3002 if err != nil {
3003 return nil, err
3004 }
3005 }
3006 args["arg"] = arg0
3007 return args, nil
3008 }
3009
3010 func (ec *executionContext) field_Query_inputOmittable_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3011 var err error
3012 args := map[string]interface{}{}
3013 var arg0 OmittableInput
3014 if tmp, ok := rawArgs["arg"]; ok {
3015 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
3016 arg0, err = ec.unmarshalNOmittableInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOmittableInput(ctx, tmp)
3017 if err != nil {
3018 return nil, err
3019 }
3020 }
3021 args["arg"] = arg0
3022 return args, nil
3023 }
3024
3025 func (ec *executionContext) field_Query_inputSlice_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3026 var err error
3027 args := map[string]interface{}{}
3028 var arg0 []string
3029 if tmp, ok := rawArgs["arg"]; ok {
3030 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
3031 arg0, err = ec.unmarshalNString2ᚕstringᚄ(ctx, tmp)
3032 if err != nil {
3033 return nil, err
3034 }
3035 }
3036 args["arg"] = arg0
3037 return args, nil
3038 }
3039
3040 func (ec *executionContext) field_Query_mapInput_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3041 var err error
3042 args := map[string]interface{}{}
3043 var arg0 map[string]interface{}
3044 if tmp, ok := rawArgs["input"]; ok {
3045 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
3046 arg0, err = ec.unmarshalOChanges2map(ctx, tmp)
3047 if err != nil {
3048 return nil, err
3049 }
3050 }
3051 args["input"] = arg0
3052 return args, nil
3053 }
3054
3055 func (ec *executionContext) field_Query_mapNestedStringInterface_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3056 var err error
3057 args := map[string]interface{}{}
3058 var arg0 *NestedMapInput
3059 if tmp, ok := rawArgs["in"]; ok {
3060 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("in"))
3061 arg0, err = ec.unmarshalONestedMapInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐNestedMapInput(ctx, tmp)
3062 if err != nil {
3063 return nil, err
3064 }
3065 }
3066 args["in"] = arg0
3067 return args, nil
3068 }
3069
3070 func (ec *executionContext) field_Query_mapStringInterface_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3071 var err error
3072 args := map[string]interface{}{}
3073 var arg0 map[string]interface{}
3074 if tmp, ok := rawArgs["in"]; ok {
3075 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("in"))
3076 arg0, err = ec.unmarshalOMapStringInterfaceInput2map(ctx, tmp)
3077 if err != nil {
3078 return nil, err
3079 }
3080 }
3081 args["in"] = arg0
3082 return args, nil
3083 }
3084
3085 func (ec *executionContext) field_Query_nestedInputs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3086 var err error
3087 args := map[string]interface{}{}
3088 var arg0 [][]*OuterInput
3089 if tmp, ok := rawArgs["input"]; ok {
3090 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
3091 arg0, err = ec.unmarshalOOuterInput2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOuterInput(ctx, tmp)
3092 if err != nil {
3093 return nil, err
3094 }
3095 }
3096 args["input"] = arg0
3097 return args, nil
3098 }
3099
3100 func (ec *executionContext) field_Query_nullableArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3101 var err error
3102 args := map[string]interface{}{}
3103 var arg0 *int
3104 if tmp, ok := rawArgs["arg"]; ok {
3105 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
3106 arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3107 if err != nil {
3108 return nil, err
3109 }
3110 }
3111 args["arg"] = arg0
3112 return args, nil
3113 }
3114
3115 func (ec *executionContext) field_Query_recursive_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3116 var err error
3117 args := map[string]interface{}{}
3118 var arg0 *RecursiveInputSlice
3119 if tmp, ok := rawArgs["input"]; ok {
3120 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
3121 arg0, err = ec.unmarshalORecursiveInputSlice2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐRecursiveInputSlice(ctx, tmp)
3122 if err != nil {
3123 return nil, err
3124 }
3125 }
3126 args["input"] = arg0
3127 return args, nil
3128 }
3129
3130 func (ec *executionContext) field_Query_user_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3131 var err error
3132 args := map[string]interface{}{}
3133 var arg0 int
3134 if tmp, ok := rawArgs["id"]; ok {
3135 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
3136 arg0, err = ec.unmarshalNInt2int(ctx, tmp)
3137 if err != nil {
3138 return nil, err
3139 }
3140 }
3141 args["id"] = arg0
3142 return args, nil
3143 }
3144
3145 func (ec *executionContext) field_Subscription_directiveArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3146 var err error
3147 args := map[string]interface{}{}
3148 var arg0 string
3149 if tmp, ok := rawArgs["arg"]; ok {
3150 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
3151 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalNString2string(ctx, tmp) }
3152 directive1 := func(ctx context.Context) (interface{}, error) {
3153 min, err := ec.unmarshalNInt2int(ctx, 1)
3154 if err != nil {
3155 return nil, err
3156 }
3157 max, err := ec.unmarshalOInt2ᚖint(ctx, 255)
3158 if err != nil {
3159 return nil, err
3160 }
3161 message, err := ec.unmarshalOString2ᚖstring(ctx, "invalid length")
3162 if err != nil {
3163 return nil, err
3164 }
3165 if ec.directives.Length == nil {
3166 return nil, errors.New("directive length is not implemented")
3167 }
3168 return ec.directives.Length(ctx, rawArgs, directive0, min, max, message)
3169 }
3170
3171 tmp, err = directive1(ctx)
3172 if err != nil {
3173 return nil, graphql.ErrorOnPath(ctx, err)
3174 }
3175 if data, ok := tmp.(string); ok {
3176 arg0 = data
3177 } else {
3178 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp))
3179 }
3180 }
3181 args["arg"] = arg0
3182 return args, nil
3183 }
3184
3185 func (ec *executionContext) field_Subscription_directiveNullableArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3186 var err error
3187 args := map[string]interface{}{}
3188 var arg0 *int
3189 if tmp, ok := rawArgs["arg"]; ok {
3190 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg"))
3191 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) }
3192 directive1 := func(ctx context.Context) (interface{}, error) {
3193 min, err := ec.unmarshalOInt2ᚖint(ctx, 0)
3194 if err != nil {
3195 return nil, err
3196 }
3197 if ec.directives.Range == nil {
3198 return nil, errors.New("directive range is not implemented")
3199 }
3200 return ec.directives.Range(ctx, rawArgs, directive0, min, nil)
3201 }
3202
3203 tmp, err = directive1(ctx)
3204 if err != nil {
3205 return nil, graphql.ErrorOnPath(ctx, err)
3206 }
3207 if data, ok := tmp.(*int); ok {
3208 arg0 = data
3209 } else if tmp == nil {
3210 arg0 = nil
3211 } else {
3212 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp))
3213 }
3214 }
3215 args["arg"] = arg0
3216 var arg1 *int
3217 if tmp, ok := rawArgs["arg2"]; ok {
3218 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg2"))
3219 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) }
3220 directive1 := func(ctx context.Context) (interface{}, error) {
3221 min, err := ec.unmarshalOInt2ᚖint(ctx, 0)
3222 if err != nil {
3223 return nil, err
3224 }
3225 if ec.directives.Range == nil {
3226 return nil, errors.New("directive range is not implemented")
3227 }
3228 return ec.directives.Range(ctx, rawArgs, directive0, min, nil)
3229 }
3230
3231 tmp, err = directive1(ctx)
3232 if err != nil {
3233 return nil, graphql.ErrorOnPath(ctx, err)
3234 }
3235 if data, ok := tmp.(*int); ok {
3236 arg1 = data
3237 } else if tmp == nil {
3238 arg1 = nil
3239 } else {
3240 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp))
3241 }
3242 }
3243 args["arg2"] = arg1
3244 var arg2 *string
3245 if tmp, ok := rawArgs["arg3"]; ok {
3246 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg3"))
3247 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOString2ᚖstring(ctx, tmp) }
3248 directive1 := func(ctx context.Context) (interface{}, error) {
3249 if ec.directives.ToNull == nil {
3250 return nil, errors.New("directive toNull is not implemented")
3251 }
3252 return ec.directives.ToNull(ctx, rawArgs, directive0)
3253 }
3254
3255 tmp, err = directive1(ctx)
3256 if err != nil {
3257 return nil, graphql.ErrorOnPath(ctx, err)
3258 }
3259 if data, ok := tmp.(*string); ok {
3260 arg2 = data
3261 } else if tmp == nil {
3262 arg2 = nil
3263 } else {
3264 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp))
3265 }
3266 }
3267 args["arg3"] = arg2
3268 return args, nil
3269 }
3270
3271 func (ec *executionContext) field_User_pets_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3272 var err error
3273 args := map[string]interface{}{}
3274 var arg0 *int
3275 if tmp, ok := rawArgs["limit"]; ok {
3276 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit"))
3277 arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
3278 if err != nil {
3279 return nil, err
3280 }
3281 }
3282 args["limit"] = arg0
3283 return args, nil
3284 }
3285
3286 func (ec *executionContext) field_ValidType_validArgs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3287 var err error
3288 args := map[string]interface{}{}
3289 var arg0 string
3290 if tmp, ok := rawArgs["break"]; ok {
3291 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("break"))
3292 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3293 if err != nil {
3294 return nil, err
3295 }
3296 }
3297 args["break"] = arg0
3298 var arg1 string
3299 if tmp, ok := rawArgs["default"]; ok {
3300 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("default"))
3301 arg1, err = ec.unmarshalNString2string(ctx, tmp)
3302 if err != nil {
3303 return nil, err
3304 }
3305 }
3306 args["default"] = arg1
3307 var arg2 string
3308 if tmp, ok := rawArgs["func"]; ok {
3309 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("func"))
3310 arg2, err = ec.unmarshalNString2string(ctx, tmp)
3311 if err != nil {
3312 return nil, err
3313 }
3314 }
3315 args["func"] = arg2
3316 var arg3 string
3317 if tmp, ok := rawArgs["interface"]; ok {
3318 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("interface"))
3319 arg3, err = ec.unmarshalNString2string(ctx, tmp)
3320 if err != nil {
3321 return nil, err
3322 }
3323 }
3324 args["interface"] = arg3
3325 var arg4 string
3326 if tmp, ok := rawArgs["select"]; ok {
3327 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("select"))
3328 arg4, err = ec.unmarshalNString2string(ctx, tmp)
3329 if err != nil {
3330 return nil, err
3331 }
3332 }
3333 args["select"] = arg4
3334 var arg5 string
3335 if tmp, ok := rawArgs["case"]; ok {
3336 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("case"))
3337 arg5, err = ec.unmarshalNString2string(ctx, tmp)
3338 if err != nil {
3339 return nil, err
3340 }
3341 }
3342 args["case"] = arg5
3343 var arg6 string
3344 if tmp, ok := rawArgs["defer"]; ok {
3345 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("defer"))
3346 arg6, err = ec.unmarshalNString2string(ctx, tmp)
3347 if err != nil {
3348 return nil, err
3349 }
3350 }
3351 args["defer"] = arg6
3352 var arg7 string
3353 if tmp, ok := rawArgs["go"]; ok {
3354 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("go"))
3355 arg7, err = ec.unmarshalNString2string(ctx, tmp)
3356 if err != nil {
3357 return nil, err
3358 }
3359 }
3360 args["go"] = arg7
3361 var arg8 string
3362 if tmp, ok := rawArgs["map"]; ok {
3363 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("map"))
3364 arg8, err = ec.unmarshalNString2string(ctx, tmp)
3365 if err != nil {
3366 return nil, err
3367 }
3368 }
3369 args["map"] = arg8
3370 var arg9 string
3371 if tmp, ok := rawArgs["struct"]; ok {
3372 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("struct"))
3373 arg9, err = ec.unmarshalNString2string(ctx, tmp)
3374 if err != nil {
3375 return nil, err
3376 }
3377 }
3378 args["struct"] = arg9
3379 var arg10 string
3380 if tmp, ok := rawArgs["chan"]; ok {
3381 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("chan"))
3382 arg10, err = ec.unmarshalNString2string(ctx, tmp)
3383 if err != nil {
3384 return nil, err
3385 }
3386 }
3387 args["chan"] = arg10
3388 var arg11 string
3389 if tmp, ok := rawArgs["else"]; ok {
3390 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("else"))
3391 arg11, err = ec.unmarshalNString2string(ctx, tmp)
3392 if err != nil {
3393 return nil, err
3394 }
3395 }
3396 args["else"] = arg11
3397 var arg12 string
3398 if tmp, ok := rawArgs["goto"]; ok {
3399 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("goto"))
3400 arg12, err = ec.unmarshalNString2string(ctx, tmp)
3401 if err != nil {
3402 return nil, err
3403 }
3404 }
3405 args["goto"] = arg12
3406 var arg13 string
3407 if tmp, ok := rawArgs["package"]; ok {
3408 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("package"))
3409 arg13, err = ec.unmarshalNString2string(ctx, tmp)
3410 if err != nil {
3411 return nil, err
3412 }
3413 }
3414 args["package"] = arg13
3415 var arg14 string
3416 if tmp, ok := rawArgs["switch"]; ok {
3417 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("switch"))
3418 arg14, err = ec.unmarshalNString2string(ctx, tmp)
3419 if err != nil {
3420 return nil, err
3421 }
3422 }
3423 args["switch"] = arg14
3424 var arg15 string
3425 if tmp, ok := rawArgs["const"]; ok {
3426 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("const"))
3427 arg15, err = ec.unmarshalNString2string(ctx, tmp)
3428 if err != nil {
3429 return nil, err
3430 }
3431 }
3432 args["const"] = arg15
3433 var arg16 string
3434 if tmp, ok := rawArgs["fallthrough"]; ok {
3435 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("fallthrough"))
3436 arg16, err = ec.unmarshalNString2string(ctx, tmp)
3437 if err != nil {
3438 return nil, err
3439 }
3440 }
3441 args["fallthrough"] = arg16
3442 var arg17 string
3443 if tmp, ok := rawArgs["if"]; ok {
3444 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("if"))
3445 arg17, err = ec.unmarshalNString2string(ctx, tmp)
3446 if err != nil {
3447 return nil, err
3448 }
3449 }
3450 args["if"] = arg17
3451 var arg18 string
3452 if tmp, ok := rawArgs["range"]; ok {
3453 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("range"))
3454 arg18, err = ec.unmarshalNString2string(ctx, tmp)
3455 if err != nil {
3456 return nil, err
3457 }
3458 }
3459 args["range"] = arg18
3460 var arg19 string
3461 if tmp, ok := rawArgs["type"]; ok {
3462 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("type"))
3463 arg19, err = ec.unmarshalNString2string(ctx, tmp)
3464 if err != nil {
3465 return nil, err
3466 }
3467 }
3468 args["type"] = arg19
3469 var arg20 string
3470 if tmp, ok := rawArgs["continue"]; ok {
3471 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("continue"))
3472 arg20, err = ec.unmarshalNString2string(ctx, tmp)
3473 if err != nil {
3474 return nil, err
3475 }
3476 }
3477 args["continue"] = arg20
3478 var arg21 string
3479 if tmp, ok := rawArgs["for"]; ok {
3480 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("for"))
3481 arg21, err = ec.unmarshalNString2string(ctx, tmp)
3482 if err != nil {
3483 return nil, err
3484 }
3485 }
3486 args["for"] = arg21
3487 var arg22 string
3488 if tmp, ok := rawArgs["import"]; ok {
3489 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("import"))
3490 arg22, err = ec.unmarshalNString2string(ctx, tmp)
3491 if err != nil {
3492 return nil, err
3493 }
3494 }
3495 args["import"] = arg22
3496 var arg23 string
3497 if tmp, ok := rawArgs["return"]; ok {
3498 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("return"))
3499 arg23, err = ec.unmarshalNString2string(ctx, tmp)
3500 if err != nil {
3501 return nil, err
3502 }
3503 }
3504 args["return"] = arg23
3505 var arg24 string
3506 if tmp, ok := rawArgs["var"]; ok {
3507 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("var"))
3508 arg24, err = ec.unmarshalNString2string(ctx, tmp)
3509 if err != nil {
3510 return nil, err
3511 }
3512 }
3513 args["var"] = arg24
3514 var arg25 string
3515 if tmp, ok := rawArgs["_"]; ok {
3516 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("_"))
3517 arg25, err = ec.unmarshalNString2string(ctx, tmp)
3518 if err != nil {
3519 return nil, err
3520 }
3521 }
3522 args["_"] = arg25
3523 return args, nil
3524 }
3525
3526 func (ec *executionContext) field_ValidType_validInputKeywords_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3527 var err error
3528 args := map[string]interface{}{}
3529 var arg0 *ValidInput
3530 if tmp, ok := rawArgs["input"]; ok {
3531 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
3532 arg0, err = ec.unmarshalOValidInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐValidInput(ctx, tmp)
3533 if err != nil {
3534 return nil, err
3535 }
3536 }
3537 args["input"] = arg0
3538 return args, nil
3539 }
3540
3541 func (ec *executionContext) field_VariadicModel_value_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3542 var err error
3543 args := map[string]interface{}{}
3544 var arg0 int
3545 if tmp, ok := rawArgs["rank"]; ok {
3546 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rank"))
3547 arg0, err = ec.unmarshalNInt2int(ctx, tmp)
3548 if err != nil {
3549 return nil, err
3550 }
3551 }
3552 args["rank"] = arg0
3553 return args, nil
3554 }
3555
3556 func (ec *executionContext) field_WrappedMap_get_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3557 var err error
3558 args := map[string]interface{}{}
3559 var arg0 string
3560 if tmp, ok := rawArgs["key"]; ok {
3561 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("key"))
3562 arg0, err = ec.unmarshalNString2string(ctx, tmp)
3563 if err != nil {
3564 return nil, err
3565 }
3566 }
3567 args["key"] = arg0
3568 return args, nil
3569 }
3570
3571 func (ec *executionContext) field_WrappedSlice_get_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3572 var err error
3573 args := map[string]interface{}{}
3574 var arg0 int
3575 if tmp, ok := rawArgs["idx"]; ok {
3576 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idx"))
3577 arg0, err = ec.unmarshalNInt2int(ctx, tmp)
3578 if err != nil {
3579 return nil, err
3580 }
3581 }
3582 args["idx"] = arg0
3583 return args, nil
3584 }
3585
3586 func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3587 var err error
3588 args := map[string]interface{}{}
3589 var arg0 bool
3590 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3591 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
3592 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3593 if err != nil {
3594 return nil, err
3595 }
3596 }
3597 args["includeDeprecated"] = arg0
3598 return args, nil
3599 }
3600
3601 func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
3602 var err error
3603 args := map[string]interface{}{}
3604 var arg0 bool
3605 if tmp, ok := rawArgs["includeDeprecated"]; ok {
3606 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
3607 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
3608 if err != nil {
3609 return nil, err
3610 }
3611 }
3612 args["includeDeprecated"] = arg0
3613 return args, nil
3614 }
3615
3616
3617
3618
3619
3620 func (ec *executionContext) _fieldMiddleware(ctx context.Context, obj interface{}, next graphql.Resolver) interface{} {
3621 fc := graphql.GetFieldContext(ctx)
3622 for _, d := range fc.Field.Directives {
3623 switch d.Name {
3624 case "logged":
3625 rawArgs := d.ArgumentMap(ec.Variables)
3626 args, err := ec.dir_logged_args(ctx, rawArgs)
3627 if err != nil {
3628 ec.Error(ctx, err)
3629 return nil
3630 }
3631 n := next
3632 next = func(ctx context.Context) (interface{}, error) {
3633 if ec.directives.Logged == nil {
3634 return nil, errors.New("directive logged is not implemented")
3635 }
3636 return ec.directives.Logged(ctx, obj, n, args["id"].(string))
3637 }
3638 }
3639 }
3640 res, err := ec.ResolverMiddleware(ctx, next)
3641 if err != nil {
3642 ec.Error(ctx, err)
3643 return nil
3644 }
3645 return res
3646 }
3647
3648
3649
3650
3651
3652 func (ec *executionContext) _A_id(ctx context.Context, field graphql.CollectedField, obj *A) (ret graphql.Marshaler) {
3653 fc, err := ec.fieldContext_A_id(ctx, field)
3654 if err != nil {
3655 return graphql.Null
3656 }
3657 ctx = graphql.WithFieldContext(ctx, fc)
3658 defer func() {
3659 if r := recover(); r != nil {
3660 ec.Error(ctx, ec.Recover(ctx, r))
3661 ret = graphql.Null
3662 }
3663 }()
3664 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3665 ctx = rctx
3666 return obj.ID, nil
3667 })
3668
3669 if resTmp == nil {
3670 if !graphql.HasFieldError(ctx, fc) {
3671 ec.Errorf(ctx, "must not be null")
3672 }
3673 return graphql.Null
3674 }
3675 res := resTmp.(string)
3676 fc.Result = res
3677 return ec.marshalNID2string(ctx, field.Selections, res)
3678 }
3679
3680 func (ec *executionContext) fieldContext_A_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3681 fc = &graphql.FieldContext{
3682 Object: "A",
3683 Field: field,
3684 IsMethod: false,
3685 IsResolver: false,
3686 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3687 return nil, errors.New("field of type ID does not have child fields")
3688 },
3689 }
3690 return fc, nil
3691 }
3692
3693 func (ec *executionContext) _AIt_id(ctx context.Context, field graphql.CollectedField, obj *AIt) (ret graphql.Marshaler) {
3694 fc, err := ec.fieldContext_AIt_id(ctx, field)
3695 if err != nil {
3696 return graphql.Null
3697 }
3698 ctx = graphql.WithFieldContext(ctx, fc)
3699 defer func() {
3700 if r := recover(); r != nil {
3701 ec.Error(ctx, ec.Recover(ctx, r))
3702 ret = graphql.Null
3703 }
3704 }()
3705 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3706 ctx = rctx
3707 return obj.ID, nil
3708 })
3709
3710 if resTmp == nil {
3711 if !graphql.HasFieldError(ctx, fc) {
3712 ec.Errorf(ctx, "must not be null")
3713 }
3714 return graphql.Null
3715 }
3716 res := resTmp.(string)
3717 fc.Result = res
3718 return ec.marshalNID2string(ctx, field.Selections, res)
3719 }
3720
3721 func (ec *executionContext) fieldContext_AIt_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3722 fc = &graphql.FieldContext{
3723 Object: "AIt",
3724 Field: field,
3725 IsMethod: false,
3726 IsResolver: false,
3727 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3728 return nil, errors.New("field of type ID does not have child fields")
3729 },
3730 }
3731 return fc, nil
3732 }
3733
3734 func (ec *executionContext) _AbIt_id(ctx context.Context, field graphql.CollectedField, obj *AbIt) (ret graphql.Marshaler) {
3735 fc, err := ec.fieldContext_AbIt_id(ctx, field)
3736 if err != nil {
3737 return graphql.Null
3738 }
3739 ctx = graphql.WithFieldContext(ctx, fc)
3740 defer func() {
3741 if r := recover(); r != nil {
3742 ec.Error(ctx, ec.Recover(ctx, r))
3743 ret = graphql.Null
3744 }
3745 }()
3746 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3747 ctx = rctx
3748 return obj.ID, nil
3749 })
3750
3751 if resTmp == nil {
3752 if !graphql.HasFieldError(ctx, fc) {
3753 ec.Errorf(ctx, "must not be null")
3754 }
3755 return graphql.Null
3756 }
3757 res := resTmp.(string)
3758 fc.Result = res
3759 return ec.marshalNID2string(ctx, field.Selections, res)
3760 }
3761
3762 func (ec *executionContext) fieldContext_AbIt_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3763 fc = &graphql.FieldContext{
3764 Object: "AbIt",
3765 Field: field,
3766 IsMethod: false,
3767 IsResolver: false,
3768 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3769 return nil, errors.New("field of type ID does not have child fields")
3770 },
3771 }
3772 return fc, nil
3773 }
3774
3775 func (ec *executionContext) _Autobind_int(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) {
3776 fc, err := ec.fieldContext_Autobind_int(ctx, field)
3777 if err != nil {
3778 return graphql.Null
3779 }
3780 ctx = graphql.WithFieldContext(ctx, fc)
3781 defer func() {
3782 if r := recover(); r != nil {
3783 ec.Error(ctx, ec.Recover(ctx, r))
3784 ret = graphql.Null
3785 }
3786 }()
3787 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3788 ctx = rctx
3789 return obj.Int, nil
3790 })
3791
3792 if resTmp == nil {
3793 if !graphql.HasFieldError(ctx, fc) {
3794 ec.Errorf(ctx, "must not be null")
3795 }
3796 return graphql.Null
3797 }
3798 res := resTmp.(int)
3799 fc.Result = res
3800 return ec.marshalNInt2int(ctx, field.Selections, res)
3801 }
3802
3803 func (ec *executionContext) fieldContext_Autobind_int(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3804 fc = &graphql.FieldContext{
3805 Object: "Autobind",
3806 Field: field,
3807 IsMethod: false,
3808 IsResolver: false,
3809 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3810 return nil, errors.New("field of type Int does not have child fields")
3811 },
3812 }
3813 return fc, nil
3814 }
3815
3816 func (ec *executionContext) _Autobind_int32(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) {
3817 fc, err := ec.fieldContext_Autobind_int32(ctx, field)
3818 if err != nil {
3819 return graphql.Null
3820 }
3821 ctx = graphql.WithFieldContext(ctx, fc)
3822 defer func() {
3823 if r := recover(); r != nil {
3824 ec.Error(ctx, ec.Recover(ctx, r))
3825 ret = graphql.Null
3826 }
3827 }()
3828 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3829 ctx = rctx
3830 return obj.Int32, nil
3831 })
3832
3833 if resTmp == nil {
3834 if !graphql.HasFieldError(ctx, fc) {
3835 ec.Errorf(ctx, "must not be null")
3836 }
3837 return graphql.Null
3838 }
3839 res := resTmp.(int32)
3840 fc.Result = res
3841 return ec.marshalNInt2int32(ctx, field.Selections, res)
3842 }
3843
3844 func (ec *executionContext) fieldContext_Autobind_int32(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3845 fc = &graphql.FieldContext{
3846 Object: "Autobind",
3847 Field: field,
3848 IsMethod: false,
3849 IsResolver: false,
3850 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3851 return nil, errors.New("field of type Int does not have child fields")
3852 },
3853 }
3854 return fc, nil
3855 }
3856
3857 func (ec *executionContext) _Autobind_int64(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) {
3858 fc, err := ec.fieldContext_Autobind_int64(ctx, field)
3859 if err != nil {
3860 return graphql.Null
3861 }
3862 ctx = graphql.WithFieldContext(ctx, fc)
3863 defer func() {
3864 if r := recover(); r != nil {
3865 ec.Error(ctx, ec.Recover(ctx, r))
3866 ret = graphql.Null
3867 }
3868 }()
3869 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3870 ctx = rctx
3871 return obj.Int64, nil
3872 })
3873
3874 if resTmp == nil {
3875 if !graphql.HasFieldError(ctx, fc) {
3876 ec.Errorf(ctx, "must not be null")
3877 }
3878 return graphql.Null
3879 }
3880 res := resTmp.(int64)
3881 fc.Result = res
3882 return ec.marshalNInt2int64(ctx, field.Selections, res)
3883 }
3884
3885 func (ec *executionContext) fieldContext_Autobind_int64(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3886 fc = &graphql.FieldContext{
3887 Object: "Autobind",
3888 Field: field,
3889 IsMethod: false,
3890 IsResolver: false,
3891 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3892 return nil, errors.New("field of type Int does not have child fields")
3893 },
3894 }
3895 return fc, nil
3896 }
3897
3898 func (ec *executionContext) _Autobind_idStr(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) {
3899 fc, err := ec.fieldContext_Autobind_idStr(ctx, field)
3900 if err != nil {
3901 return graphql.Null
3902 }
3903 ctx = graphql.WithFieldContext(ctx, fc)
3904 defer func() {
3905 if r := recover(); r != nil {
3906 ec.Error(ctx, ec.Recover(ctx, r))
3907 ret = graphql.Null
3908 }
3909 }()
3910 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3911 ctx = rctx
3912 return obj.IdStr, nil
3913 })
3914
3915 if resTmp == nil {
3916 if !graphql.HasFieldError(ctx, fc) {
3917 ec.Errorf(ctx, "must not be null")
3918 }
3919 return graphql.Null
3920 }
3921 res := resTmp.(string)
3922 fc.Result = res
3923 return ec.marshalNID2string(ctx, field.Selections, res)
3924 }
3925
3926 func (ec *executionContext) fieldContext_Autobind_idStr(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3927 fc = &graphql.FieldContext{
3928 Object: "Autobind",
3929 Field: field,
3930 IsMethod: false,
3931 IsResolver: false,
3932 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3933 return nil, errors.New("field of type ID does not have child fields")
3934 },
3935 }
3936 return fc, nil
3937 }
3938
3939 func (ec *executionContext) _Autobind_idInt(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) {
3940 fc, err := ec.fieldContext_Autobind_idInt(ctx, field)
3941 if err != nil {
3942 return graphql.Null
3943 }
3944 ctx = graphql.WithFieldContext(ctx, fc)
3945 defer func() {
3946 if r := recover(); r != nil {
3947 ec.Error(ctx, ec.Recover(ctx, r))
3948 ret = graphql.Null
3949 }
3950 }()
3951 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3952 ctx = rctx
3953 return obj.IdInt, nil
3954 })
3955
3956 if resTmp == nil {
3957 if !graphql.HasFieldError(ctx, fc) {
3958 ec.Errorf(ctx, "must not be null")
3959 }
3960 return graphql.Null
3961 }
3962 res := resTmp.(int)
3963 fc.Result = res
3964 return ec.marshalNID2int(ctx, field.Selections, res)
3965 }
3966
3967 func (ec *executionContext) fieldContext_Autobind_idInt(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
3968 fc = &graphql.FieldContext{
3969 Object: "Autobind",
3970 Field: field,
3971 IsMethod: false,
3972 IsResolver: false,
3973 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
3974 return nil, errors.New("field of type ID does not have child fields")
3975 },
3976 }
3977 return fc, nil
3978 }
3979
3980 func (ec *executionContext) _B_id(ctx context.Context, field graphql.CollectedField, obj *B) (ret graphql.Marshaler) {
3981 fc, err := ec.fieldContext_B_id(ctx, field)
3982 if err != nil {
3983 return graphql.Null
3984 }
3985 ctx = graphql.WithFieldContext(ctx, fc)
3986 defer func() {
3987 if r := recover(); r != nil {
3988 ec.Error(ctx, ec.Recover(ctx, r))
3989 ret = graphql.Null
3990 }
3991 }()
3992 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3993 ctx = rctx
3994 return obj.ID, nil
3995 })
3996
3997 if resTmp == nil {
3998 if !graphql.HasFieldError(ctx, fc) {
3999 ec.Errorf(ctx, "must not be null")
4000 }
4001 return graphql.Null
4002 }
4003 res := resTmp.(string)
4004 fc.Result = res
4005 return ec.marshalNID2string(ctx, field.Selections, res)
4006 }
4007
4008 func (ec *executionContext) fieldContext_B_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4009 fc = &graphql.FieldContext{
4010 Object: "B",
4011 Field: field,
4012 IsMethod: false,
4013 IsResolver: false,
4014 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4015 return nil, errors.New("field of type ID does not have child fields")
4016 },
4017 }
4018 return fc, nil
4019 }
4020
4021 func (ec *executionContext) _BackedByInterface_id(ctx context.Context, field graphql.CollectedField, obj BackedByInterface) (ret graphql.Marshaler) {
4022 fc, err := ec.fieldContext_BackedByInterface_id(ctx, field)
4023 if err != nil {
4024 return graphql.Null
4025 }
4026 ctx = graphql.WithFieldContext(ctx, fc)
4027 defer func() {
4028 if r := recover(); r != nil {
4029 ec.Error(ctx, ec.Recover(ctx, r))
4030 ret = graphql.Null
4031 }
4032 }()
4033 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4034 ctx = rctx
4035 return ec.resolvers.BackedByInterface().ID(rctx, obj)
4036 })
4037
4038 if resTmp == nil {
4039 if !graphql.HasFieldError(ctx, fc) {
4040 ec.Errorf(ctx, "must not be null")
4041 }
4042 return graphql.Null
4043 }
4044 res := resTmp.(string)
4045 fc.Result = res
4046 return ec.marshalNString2string(ctx, field.Selections, res)
4047 }
4048
4049 func (ec *executionContext) fieldContext_BackedByInterface_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4050 fc = &graphql.FieldContext{
4051 Object: "BackedByInterface",
4052 Field: field,
4053 IsMethod: true,
4054 IsResolver: true,
4055 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4056 return nil, errors.New("field of type String does not have child fields")
4057 },
4058 }
4059 return fc, nil
4060 }
4061
4062 func (ec *executionContext) _BackedByInterface_thisShouldBind(ctx context.Context, field graphql.CollectedField, obj BackedByInterface) (ret graphql.Marshaler) {
4063 fc, err := ec.fieldContext_BackedByInterface_thisShouldBind(ctx, field)
4064 if err != nil {
4065 return graphql.Null
4066 }
4067 ctx = graphql.WithFieldContext(ctx, fc)
4068 defer func() {
4069 if r := recover(); r != nil {
4070 ec.Error(ctx, ec.Recover(ctx, r))
4071 ret = graphql.Null
4072 }
4073 }()
4074 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4075 ctx = rctx
4076 return obj.ThisShouldBind(), nil
4077 })
4078
4079 if resTmp == nil {
4080 if !graphql.HasFieldError(ctx, fc) {
4081 ec.Errorf(ctx, "must not be null")
4082 }
4083 return graphql.Null
4084 }
4085 res := resTmp.(string)
4086 fc.Result = res
4087 return ec.marshalNString2string(ctx, field.Selections, res)
4088 }
4089
4090 func (ec *executionContext) fieldContext_BackedByInterface_thisShouldBind(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4091 fc = &graphql.FieldContext{
4092 Object: "BackedByInterface",
4093 Field: field,
4094 IsMethod: true,
4095 IsResolver: false,
4096 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4097 return nil, errors.New("field of type String does not have child fields")
4098 },
4099 }
4100 return fc, nil
4101 }
4102
4103 func (ec *executionContext) _BackedByInterface_thisShouldBindWithError(ctx context.Context, field graphql.CollectedField, obj BackedByInterface) (ret graphql.Marshaler) {
4104 fc, err := ec.fieldContext_BackedByInterface_thisShouldBindWithError(ctx, field)
4105 if err != nil {
4106 return graphql.Null
4107 }
4108 ctx = graphql.WithFieldContext(ctx, fc)
4109 defer func() {
4110 if r := recover(); r != nil {
4111 ec.Error(ctx, ec.Recover(ctx, r))
4112 ret = graphql.Null
4113 }
4114 }()
4115 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4116 ctx = rctx
4117 return obj.ThisShouldBindWithError()
4118 })
4119
4120 if resTmp == nil {
4121 if !graphql.HasFieldError(ctx, fc) {
4122 ec.Errorf(ctx, "must not be null")
4123 }
4124 return graphql.Null
4125 }
4126 res := resTmp.(string)
4127 fc.Result = res
4128 return ec.marshalNString2string(ctx, field.Selections, res)
4129 }
4130
4131 func (ec *executionContext) fieldContext_BackedByInterface_thisShouldBindWithError(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4132 fc = &graphql.FieldContext{
4133 Object: "BackedByInterface",
4134 Field: field,
4135 IsMethod: true,
4136 IsResolver: false,
4137 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4138 return nil, errors.New("field of type String does not have child fields")
4139 },
4140 }
4141 return fc, nil
4142 }
4143
4144 func (ec *executionContext) _Cat_species(ctx context.Context, field graphql.CollectedField, obj *Cat) (ret graphql.Marshaler) {
4145 fc, err := ec.fieldContext_Cat_species(ctx, field)
4146 if err != nil {
4147 return graphql.Null
4148 }
4149 ctx = graphql.WithFieldContext(ctx, fc)
4150 defer func() {
4151 if r := recover(); r != nil {
4152 ec.Error(ctx, ec.Recover(ctx, r))
4153 ret = graphql.Null
4154 }
4155 }()
4156 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4157 ctx = rctx
4158 return obj.Species, nil
4159 })
4160
4161 if resTmp == nil {
4162 if !graphql.HasFieldError(ctx, fc) {
4163 ec.Errorf(ctx, "must not be null")
4164 }
4165 return graphql.Null
4166 }
4167 res := resTmp.(string)
4168 fc.Result = res
4169 return ec.marshalNString2string(ctx, field.Selections, res)
4170 }
4171
4172 func (ec *executionContext) fieldContext_Cat_species(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4173 fc = &graphql.FieldContext{
4174 Object: "Cat",
4175 Field: field,
4176 IsMethod: false,
4177 IsResolver: false,
4178 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4179 return nil, errors.New("field of type String does not have child fields")
4180 },
4181 }
4182 return fc, nil
4183 }
4184
4185 func (ec *executionContext) _Cat_size(ctx context.Context, field graphql.CollectedField, obj *Cat) (ret graphql.Marshaler) {
4186 fc, err := ec.fieldContext_Cat_size(ctx, field)
4187 if err != nil {
4188 return graphql.Null
4189 }
4190 ctx = graphql.WithFieldContext(ctx, fc)
4191 defer func() {
4192 if r := recover(); r != nil {
4193 ec.Error(ctx, ec.Recover(ctx, r))
4194 ret = graphql.Null
4195 }
4196 }()
4197 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4198 ctx = rctx
4199 return obj.Size, nil
4200 })
4201
4202 if resTmp == nil {
4203 if !graphql.HasFieldError(ctx, fc) {
4204 ec.Errorf(ctx, "must not be null")
4205 }
4206 return graphql.Null
4207 }
4208 res := resTmp.(*Size)
4209 fc.Result = res
4210 return ec.marshalNSize2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐSize(ctx, field.Selections, res)
4211 }
4212
4213 func (ec *executionContext) fieldContext_Cat_size(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4214 fc = &graphql.FieldContext{
4215 Object: "Cat",
4216 Field: field,
4217 IsMethod: false,
4218 IsResolver: false,
4219 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4220 switch field.Name {
4221 case "height":
4222 return ec.fieldContext_Size_height(ctx, field)
4223 case "weight":
4224 return ec.fieldContext_Size_weight(ctx, field)
4225 }
4226 return nil, fmt.Errorf("no field named %q was found under type Size", field.Name)
4227 },
4228 }
4229 return fc, nil
4230 }
4231
4232 func (ec *executionContext) _Cat_catBreed(ctx context.Context, field graphql.CollectedField, obj *Cat) (ret graphql.Marshaler) {
4233 fc, err := ec.fieldContext_Cat_catBreed(ctx, field)
4234 if err != nil {
4235 return graphql.Null
4236 }
4237 ctx = graphql.WithFieldContext(ctx, fc)
4238 defer func() {
4239 if r := recover(); r != nil {
4240 ec.Error(ctx, ec.Recover(ctx, r))
4241 ret = graphql.Null
4242 }
4243 }()
4244 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4245 ctx = rctx
4246 return obj.CatBreed, nil
4247 })
4248
4249 if resTmp == nil {
4250 if !graphql.HasFieldError(ctx, fc) {
4251 ec.Errorf(ctx, "must not be null")
4252 }
4253 return graphql.Null
4254 }
4255 res := resTmp.(string)
4256 fc.Result = res
4257 return ec.marshalNString2string(ctx, field.Selections, res)
4258 }
4259
4260 func (ec *executionContext) fieldContext_Cat_catBreed(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4261 fc = &graphql.FieldContext{
4262 Object: "Cat",
4263 Field: field,
4264 IsMethod: false,
4265 IsResolver: false,
4266 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4267 return nil, errors.New("field of type String does not have child fields")
4268 },
4269 }
4270 return fc, nil
4271 }
4272
4273 func (ec *executionContext) _CheckIssue896_id(ctx context.Context, field graphql.CollectedField, obj *CheckIssue896) (ret graphql.Marshaler) {
4274 fc, err := ec.fieldContext_CheckIssue896_id(ctx, field)
4275 if err != nil {
4276 return graphql.Null
4277 }
4278 ctx = graphql.WithFieldContext(ctx, fc)
4279 defer func() {
4280 if r := recover(); r != nil {
4281 ec.Error(ctx, ec.Recover(ctx, r))
4282 ret = graphql.Null
4283 }
4284 }()
4285 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4286 ctx = rctx
4287 return obj.ID, nil
4288 })
4289
4290 if resTmp == nil {
4291 return graphql.Null
4292 }
4293 res := resTmp.(*int)
4294 fc.Result = res
4295 return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
4296 }
4297
4298 func (ec *executionContext) fieldContext_CheckIssue896_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4299 fc = &graphql.FieldContext{
4300 Object: "CheckIssue896",
4301 Field: field,
4302 IsMethod: false,
4303 IsResolver: false,
4304 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4305 return nil, errors.New("field of type Int does not have child fields")
4306 },
4307 }
4308 return fc, nil
4309 }
4310
4311 func (ec *executionContext) _Circle_radius(ctx context.Context, field graphql.CollectedField, obj *Circle) (ret graphql.Marshaler) {
4312 fc, err := ec.fieldContext_Circle_radius(ctx, field)
4313 if err != nil {
4314 return graphql.Null
4315 }
4316 ctx = graphql.WithFieldContext(ctx, fc)
4317 defer func() {
4318 if r := recover(); r != nil {
4319 ec.Error(ctx, ec.Recover(ctx, r))
4320 ret = graphql.Null
4321 }
4322 }()
4323 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4324 ctx = rctx
4325 return obj.Radius, nil
4326 })
4327
4328 if resTmp == nil {
4329 return graphql.Null
4330 }
4331 res := resTmp.(float64)
4332 fc.Result = res
4333 return ec.marshalOFloat2float64(ctx, field.Selections, res)
4334 }
4335
4336 func (ec *executionContext) fieldContext_Circle_radius(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4337 fc = &graphql.FieldContext{
4338 Object: "Circle",
4339 Field: field,
4340 IsMethod: false,
4341 IsResolver: false,
4342 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4343 return nil, errors.New("field of type Float does not have child fields")
4344 },
4345 }
4346 return fc, nil
4347 }
4348
4349 func (ec *executionContext) _Circle_area(ctx context.Context, field graphql.CollectedField, obj *Circle) (ret graphql.Marshaler) {
4350 fc, err := ec.fieldContext_Circle_area(ctx, field)
4351 if err != nil {
4352 return graphql.Null
4353 }
4354 ctx = graphql.WithFieldContext(ctx, fc)
4355 defer func() {
4356 if r := recover(); r != nil {
4357 ec.Error(ctx, ec.Recover(ctx, r))
4358 ret = graphql.Null
4359 }
4360 }()
4361 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4362 ctx = rctx
4363 return obj.Area(), nil
4364 })
4365
4366 if resTmp == nil {
4367 return graphql.Null
4368 }
4369 res := resTmp.(float64)
4370 fc.Result = res
4371 return ec.marshalOFloat2float64(ctx, field.Selections, res)
4372 }
4373
4374 func (ec *executionContext) fieldContext_Circle_area(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4375 fc = &graphql.FieldContext{
4376 Object: "Circle",
4377 Field: field,
4378 IsMethod: true,
4379 IsResolver: false,
4380 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4381 return nil, errors.New("field of type Float does not have child fields")
4382 },
4383 }
4384 return fc, nil
4385 }
4386
4387 func (ec *executionContext) _Circle_coordinates(ctx context.Context, field graphql.CollectedField, obj *Circle) (ret graphql.Marshaler) {
4388 fc, err := ec.fieldContext_Circle_coordinates(ctx, field)
4389 if err != nil {
4390 return graphql.Null
4391 }
4392 ctx = graphql.WithFieldContext(ctx, fc)
4393 defer func() {
4394 if r := recover(); r != nil {
4395 ec.Error(ctx, ec.Recover(ctx, r))
4396 ret = graphql.Null
4397 }
4398 }()
4399 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4400 ctx = rctx
4401 return obj.Coordinates, nil
4402 })
4403
4404 if resTmp == nil {
4405 return graphql.Null
4406 }
4407 res := resTmp.(Coordinates)
4408 fc.Result = res
4409 return ec.marshalOCoordinates2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCoordinates(ctx, field.Selections, res)
4410 }
4411
4412 func (ec *executionContext) fieldContext_Circle_coordinates(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4413 fc = &graphql.FieldContext{
4414 Object: "Circle",
4415 Field: field,
4416 IsMethod: false,
4417 IsResolver: false,
4418 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4419 switch field.Name {
4420 case "x":
4421 return ec.fieldContext_Coordinates_x(ctx, field)
4422 case "y":
4423 return ec.fieldContext_Coordinates_y(ctx, field)
4424 }
4425 return nil, fmt.Errorf("no field named %q was found under type Coordinates", field.Name)
4426 },
4427 }
4428 return fc, nil
4429 }
4430
4431 func (ec *executionContext) _ConcreteNodeA_id(ctx context.Context, field graphql.CollectedField, obj *ConcreteNodeA) (ret graphql.Marshaler) {
4432 fc, err := ec.fieldContext_ConcreteNodeA_id(ctx, field)
4433 if err != nil {
4434 return graphql.Null
4435 }
4436 ctx = graphql.WithFieldContext(ctx, fc)
4437 defer func() {
4438 if r := recover(); r != nil {
4439 ec.Error(ctx, ec.Recover(ctx, r))
4440 ret = graphql.Null
4441 }
4442 }()
4443 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4444 ctx = rctx
4445 return obj.ID, nil
4446 })
4447
4448 if resTmp == nil {
4449 if !graphql.HasFieldError(ctx, fc) {
4450 ec.Errorf(ctx, "must not be null")
4451 }
4452 return graphql.Null
4453 }
4454 res := resTmp.(string)
4455 fc.Result = res
4456 return ec.marshalNID2string(ctx, field.Selections, res)
4457 }
4458
4459 func (ec *executionContext) fieldContext_ConcreteNodeA_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4460 fc = &graphql.FieldContext{
4461 Object: "ConcreteNodeA",
4462 Field: field,
4463 IsMethod: false,
4464 IsResolver: false,
4465 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4466 return nil, errors.New("field of type ID does not have child fields")
4467 },
4468 }
4469 return fc, nil
4470 }
4471
4472 func (ec *executionContext) _ConcreteNodeA_child(ctx context.Context, field graphql.CollectedField, obj *ConcreteNodeA) (ret graphql.Marshaler) {
4473 fc, err := ec.fieldContext_ConcreteNodeA_child(ctx, field)
4474 if err != nil {
4475 return graphql.Null
4476 }
4477 ctx = graphql.WithFieldContext(ctx, fc)
4478 defer func() {
4479 if r := recover(); r != nil {
4480 ec.Error(ctx, ec.Recover(ctx, r))
4481 ret = graphql.Null
4482 }
4483 }()
4484 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4485 ctx = rctx
4486 return obj.Child()
4487 })
4488
4489 if resTmp == nil {
4490 if !graphql.HasFieldError(ctx, fc) {
4491 ec.Errorf(ctx, "must not be null")
4492 }
4493 return graphql.Null
4494 }
4495 res := resTmp.(Node)
4496 fc.Result = res
4497 return ec.marshalNNode2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐNode(ctx, field.Selections, res)
4498 }
4499
4500 func (ec *executionContext) fieldContext_ConcreteNodeA_child(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4501 fc = &graphql.FieldContext{
4502 Object: "ConcreteNodeA",
4503 Field: field,
4504 IsMethod: true,
4505 IsResolver: false,
4506 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4507 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
4508 },
4509 }
4510 return fc, nil
4511 }
4512
4513 func (ec *executionContext) _ConcreteNodeA_name(ctx context.Context, field graphql.CollectedField, obj *ConcreteNodeA) (ret graphql.Marshaler) {
4514 fc, err := ec.fieldContext_ConcreteNodeA_name(ctx, field)
4515 if err != nil {
4516 return graphql.Null
4517 }
4518 ctx = graphql.WithFieldContext(ctx, fc)
4519 defer func() {
4520 if r := recover(); r != nil {
4521 ec.Error(ctx, ec.Recover(ctx, r))
4522 ret = graphql.Null
4523 }
4524 }()
4525 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4526 ctx = rctx
4527 return obj.Name, nil
4528 })
4529
4530 if resTmp == nil {
4531 if !graphql.HasFieldError(ctx, fc) {
4532 ec.Errorf(ctx, "must not be null")
4533 }
4534 return graphql.Null
4535 }
4536 res := resTmp.(string)
4537 fc.Result = res
4538 return ec.marshalNString2string(ctx, field.Selections, res)
4539 }
4540
4541 func (ec *executionContext) fieldContext_ConcreteNodeA_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4542 fc = &graphql.FieldContext{
4543 Object: "ConcreteNodeA",
4544 Field: field,
4545 IsMethod: false,
4546 IsResolver: false,
4547 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4548 return nil, errors.New("field of type String does not have child fields")
4549 },
4550 }
4551 return fc, nil
4552 }
4553
4554 func (ec *executionContext) _ConcreteNodeInterface_id(ctx context.Context, field graphql.CollectedField, obj ConcreteNodeInterface) (ret graphql.Marshaler) {
4555 fc, err := ec.fieldContext_ConcreteNodeInterface_id(ctx, field)
4556 if err != nil {
4557 return graphql.Null
4558 }
4559 ctx = graphql.WithFieldContext(ctx, fc)
4560 defer func() {
4561 if r := recover(); r != nil {
4562 ec.Error(ctx, ec.Recover(ctx, r))
4563 ret = graphql.Null
4564 }
4565 }()
4566 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4567 ctx = rctx
4568 return obj.ID(), nil
4569 })
4570
4571 if resTmp == nil {
4572 if !graphql.HasFieldError(ctx, fc) {
4573 ec.Errorf(ctx, "must not be null")
4574 }
4575 return graphql.Null
4576 }
4577 res := resTmp.(string)
4578 fc.Result = res
4579 return ec.marshalNID2string(ctx, field.Selections, res)
4580 }
4581
4582 func (ec *executionContext) fieldContext_ConcreteNodeInterface_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4583 fc = &graphql.FieldContext{
4584 Object: "ConcreteNodeInterface",
4585 Field: field,
4586 IsMethod: true,
4587 IsResolver: false,
4588 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4589 return nil, errors.New("field of type ID does not have child fields")
4590 },
4591 }
4592 return fc, nil
4593 }
4594
4595 func (ec *executionContext) _ConcreteNodeInterface_child(ctx context.Context, field graphql.CollectedField, obj ConcreteNodeInterface) (ret graphql.Marshaler) {
4596 fc, err := ec.fieldContext_ConcreteNodeInterface_child(ctx, field)
4597 if err != nil {
4598 return graphql.Null
4599 }
4600 ctx = graphql.WithFieldContext(ctx, fc)
4601 defer func() {
4602 if r := recover(); r != nil {
4603 ec.Error(ctx, ec.Recover(ctx, r))
4604 ret = graphql.Null
4605 }
4606 }()
4607 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4608 ctx = rctx
4609 return obj.Child()
4610 })
4611
4612 if resTmp == nil {
4613 if !graphql.HasFieldError(ctx, fc) {
4614 ec.Errorf(ctx, "must not be null")
4615 }
4616 return graphql.Null
4617 }
4618 res := resTmp.(Node)
4619 fc.Result = res
4620 return ec.marshalNNode2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐNode(ctx, field.Selections, res)
4621 }
4622
4623 func (ec *executionContext) fieldContext_ConcreteNodeInterface_child(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4624 fc = &graphql.FieldContext{
4625 Object: "ConcreteNodeInterface",
4626 Field: field,
4627 IsMethod: true,
4628 IsResolver: false,
4629 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4630 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
4631 },
4632 }
4633 return fc, nil
4634 }
4635
4636 func (ec *executionContext) _Content_Post_foo(ctx context.Context, field graphql.CollectedField, obj *ContentPost) (ret graphql.Marshaler) {
4637 fc, err := ec.fieldContext_Content_Post_foo(ctx, field)
4638 if err != nil {
4639 return graphql.Null
4640 }
4641 ctx = graphql.WithFieldContext(ctx, fc)
4642 defer func() {
4643 if r := recover(); r != nil {
4644 ec.Error(ctx, ec.Recover(ctx, r))
4645 ret = graphql.Null
4646 }
4647 }()
4648 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4649 ctx = rctx
4650 return obj.Foo, nil
4651 })
4652
4653 if resTmp == nil {
4654 return graphql.Null
4655 }
4656 res := resTmp.(*string)
4657 fc.Result = res
4658 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4659 }
4660
4661 func (ec *executionContext) fieldContext_Content_Post_foo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4662 fc = &graphql.FieldContext{
4663 Object: "Content_Post",
4664 Field: field,
4665 IsMethod: false,
4666 IsResolver: false,
4667 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4668 return nil, errors.New("field of type String does not have child fields")
4669 },
4670 }
4671 return fc, nil
4672 }
4673
4674 func (ec *executionContext) _Content_User_foo(ctx context.Context, field graphql.CollectedField, obj *ContentUser) (ret graphql.Marshaler) {
4675 fc, err := ec.fieldContext_Content_User_foo(ctx, field)
4676 if err != nil {
4677 return graphql.Null
4678 }
4679 ctx = graphql.WithFieldContext(ctx, fc)
4680 defer func() {
4681 if r := recover(); r != nil {
4682 ec.Error(ctx, ec.Recover(ctx, r))
4683 ret = graphql.Null
4684 }
4685 }()
4686 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4687 ctx = rctx
4688 return obj.Foo, nil
4689 })
4690
4691 if resTmp == nil {
4692 return graphql.Null
4693 }
4694 res := resTmp.(*string)
4695 fc.Result = res
4696 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
4697 }
4698
4699 func (ec *executionContext) fieldContext_Content_User_foo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4700 fc = &graphql.FieldContext{
4701 Object: "Content_User",
4702 Field: field,
4703 IsMethod: false,
4704 IsResolver: false,
4705 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4706 return nil, errors.New("field of type String does not have child fields")
4707 },
4708 }
4709 return fc, nil
4710 }
4711
4712 func (ec *executionContext) _Coordinates_x(ctx context.Context, field graphql.CollectedField, obj *Coordinates) (ret graphql.Marshaler) {
4713 fc, err := ec.fieldContext_Coordinates_x(ctx, field)
4714 if err != nil {
4715 return graphql.Null
4716 }
4717 ctx = graphql.WithFieldContext(ctx, fc)
4718 defer func() {
4719 if r := recover(); r != nil {
4720 ec.Error(ctx, ec.Recover(ctx, r))
4721 ret = graphql.Null
4722 }
4723 }()
4724 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4725 ctx = rctx
4726 return obj.X, nil
4727 })
4728
4729 if resTmp == nil {
4730 if !graphql.HasFieldError(ctx, fc) {
4731 ec.Errorf(ctx, "must not be null")
4732 }
4733 return graphql.Null
4734 }
4735 res := resTmp.(float64)
4736 fc.Result = res
4737 return ec.marshalNFloat2float64(ctx, field.Selections, res)
4738 }
4739
4740 func (ec *executionContext) fieldContext_Coordinates_x(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4741 fc = &graphql.FieldContext{
4742 Object: "Coordinates",
4743 Field: field,
4744 IsMethod: false,
4745 IsResolver: false,
4746 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4747 return nil, errors.New("field of type Float does not have child fields")
4748 },
4749 }
4750 return fc, nil
4751 }
4752
4753 func (ec *executionContext) _Coordinates_y(ctx context.Context, field graphql.CollectedField, obj *Coordinates) (ret graphql.Marshaler) {
4754 fc, err := ec.fieldContext_Coordinates_y(ctx, field)
4755 if err != nil {
4756 return graphql.Null
4757 }
4758 ctx = graphql.WithFieldContext(ctx, fc)
4759 defer func() {
4760 if r := recover(); r != nil {
4761 ec.Error(ctx, ec.Recover(ctx, r))
4762 ret = graphql.Null
4763 }
4764 }()
4765 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4766 ctx = rctx
4767 return obj.Y, nil
4768 })
4769
4770 if resTmp == nil {
4771 if !graphql.HasFieldError(ctx, fc) {
4772 ec.Errorf(ctx, "must not be null")
4773 }
4774 return graphql.Null
4775 }
4776 res := resTmp.(float64)
4777 fc.Result = res
4778 return ec.marshalNFloat2float64(ctx, field.Selections, res)
4779 }
4780
4781 func (ec *executionContext) fieldContext_Coordinates_y(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4782 fc = &graphql.FieldContext{
4783 Object: "Coordinates",
4784 Field: field,
4785 IsMethod: false,
4786 IsResolver: false,
4787 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4788 return nil, errors.New("field of type Float does not have child fields")
4789 },
4790 }
4791 return fc, nil
4792 }
4793
4794 func (ec *executionContext) _DefaultParametersMirror_falsyBoolean(ctx context.Context, field graphql.CollectedField, obj *DefaultParametersMirror) (ret graphql.Marshaler) {
4795 fc, err := ec.fieldContext_DefaultParametersMirror_falsyBoolean(ctx, field)
4796 if err != nil {
4797 return graphql.Null
4798 }
4799 ctx = graphql.WithFieldContext(ctx, fc)
4800 defer func() {
4801 if r := recover(); r != nil {
4802 ec.Error(ctx, ec.Recover(ctx, r))
4803 ret = graphql.Null
4804 }
4805 }()
4806 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4807 ctx = rctx
4808 return obj.FalsyBoolean, nil
4809 })
4810
4811 if resTmp == nil {
4812 return graphql.Null
4813 }
4814 res := resTmp.(*bool)
4815 fc.Result = res
4816 return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)
4817 }
4818
4819 func (ec *executionContext) fieldContext_DefaultParametersMirror_falsyBoolean(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4820 fc = &graphql.FieldContext{
4821 Object: "DefaultParametersMirror",
4822 Field: field,
4823 IsMethod: false,
4824 IsResolver: false,
4825 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4826 return nil, errors.New("field of type Boolean does not have child fields")
4827 },
4828 }
4829 return fc, nil
4830 }
4831
4832 func (ec *executionContext) _DefaultParametersMirror_truthyBoolean(ctx context.Context, field graphql.CollectedField, obj *DefaultParametersMirror) (ret graphql.Marshaler) {
4833 fc, err := ec.fieldContext_DefaultParametersMirror_truthyBoolean(ctx, field)
4834 if err != nil {
4835 return graphql.Null
4836 }
4837 ctx = graphql.WithFieldContext(ctx, fc)
4838 defer func() {
4839 if r := recover(); r != nil {
4840 ec.Error(ctx, ec.Recover(ctx, r))
4841 ret = graphql.Null
4842 }
4843 }()
4844 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4845 ctx = rctx
4846 return obj.TruthyBoolean, nil
4847 })
4848
4849 if resTmp == nil {
4850 return graphql.Null
4851 }
4852 res := resTmp.(*bool)
4853 fc.Result = res
4854 return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)
4855 }
4856
4857 func (ec *executionContext) fieldContext_DefaultParametersMirror_truthyBoolean(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4858 fc = &graphql.FieldContext{
4859 Object: "DefaultParametersMirror",
4860 Field: field,
4861 IsMethod: false,
4862 IsResolver: false,
4863 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4864 return nil, errors.New("field of type Boolean does not have child fields")
4865 },
4866 }
4867 return fc, nil
4868 }
4869
4870 func (ec *executionContext) _DeferModel_id(ctx context.Context, field graphql.CollectedField, obj *DeferModel) (ret graphql.Marshaler) {
4871 fc, err := ec.fieldContext_DeferModel_id(ctx, field)
4872 if err != nil {
4873 return graphql.Null
4874 }
4875 ctx = graphql.WithFieldContext(ctx, fc)
4876 defer func() {
4877 if r := recover(); r != nil {
4878 ec.Error(ctx, ec.Recover(ctx, r))
4879 ret = graphql.Null
4880 }
4881 }()
4882 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4883 ctx = rctx
4884 return obj.ID, nil
4885 })
4886
4887 if resTmp == nil {
4888 if !graphql.HasFieldError(ctx, fc) {
4889 ec.Errorf(ctx, "must not be null")
4890 }
4891 return graphql.Null
4892 }
4893 res := resTmp.(string)
4894 fc.Result = res
4895 return ec.marshalNID2string(ctx, field.Selections, res)
4896 }
4897
4898 func (ec *executionContext) fieldContext_DeferModel_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4899 fc = &graphql.FieldContext{
4900 Object: "DeferModel",
4901 Field: field,
4902 IsMethod: false,
4903 IsResolver: false,
4904 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4905 return nil, errors.New("field of type ID does not have child fields")
4906 },
4907 }
4908 return fc, nil
4909 }
4910
4911 func (ec *executionContext) _DeferModel_name(ctx context.Context, field graphql.CollectedField, obj *DeferModel) (ret graphql.Marshaler) {
4912 fc, err := ec.fieldContext_DeferModel_name(ctx, field)
4913 if err != nil {
4914 return graphql.Null
4915 }
4916 ctx = graphql.WithFieldContext(ctx, fc)
4917 defer func() {
4918 if r := recover(); r != nil {
4919 ec.Error(ctx, ec.Recover(ctx, r))
4920 ret = graphql.Null
4921 }
4922 }()
4923 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4924 ctx = rctx
4925 return obj.Name, nil
4926 })
4927
4928 if resTmp == nil {
4929 if !graphql.HasFieldError(ctx, fc) {
4930 ec.Errorf(ctx, "must not be null")
4931 }
4932 return graphql.Null
4933 }
4934 res := resTmp.(string)
4935 fc.Result = res
4936 return ec.marshalNString2string(ctx, field.Selections, res)
4937 }
4938
4939 func (ec *executionContext) fieldContext_DeferModel_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4940 fc = &graphql.FieldContext{
4941 Object: "DeferModel",
4942 Field: field,
4943 IsMethod: false,
4944 IsResolver: false,
4945 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4946 return nil, errors.New("field of type String does not have child fields")
4947 },
4948 }
4949 return fc, nil
4950 }
4951
4952 func (ec *executionContext) _DeferModel_values(ctx context.Context, field graphql.CollectedField, obj *DeferModel) (ret graphql.Marshaler) {
4953 fc, err := ec.fieldContext_DeferModel_values(ctx, field)
4954 if err != nil {
4955 return graphql.Null
4956 }
4957 ctx = graphql.WithFieldContext(ctx, fc)
4958 defer func() {
4959 if r := recover(); r != nil {
4960 ec.Error(ctx, ec.Recover(ctx, r))
4961 ret = graphql.Null
4962 }
4963 }()
4964 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4965 ctx = rctx
4966 return ec.resolvers.DeferModel().Values(rctx, obj)
4967 })
4968
4969 if resTmp == nil {
4970 if !graphql.HasFieldError(ctx, fc) {
4971 ec.Errorf(ctx, "must not be null")
4972 }
4973 return graphql.Null
4974 }
4975 res := resTmp.([]string)
4976 fc.Result = res
4977 return ec.marshalNString2ᚕstringᚄ(ctx, field.Selections, res)
4978 }
4979
4980 func (ec *executionContext) fieldContext_DeferModel_values(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
4981 fc = &graphql.FieldContext{
4982 Object: "DeferModel",
4983 Field: field,
4984 IsMethod: true,
4985 IsResolver: true,
4986 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
4987 return nil, errors.New("field of type String does not have child fields")
4988 },
4989 }
4990 return fc, nil
4991 }
4992
4993 func (ec *executionContext) _Dog_species(ctx context.Context, field graphql.CollectedField, obj *Dog) (ret graphql.Marshaler) {
4994 fc, err := ec.fieldContext_Dog_species(ctx, field)
4995 if err != nil {
4996 return graphql.Null
4997 }
4998 ctx = graphql.WithFieldContext(ctx, fc)
4999 defer func() {
5000 if r := recover(); r != nil {
5001 ec.Error(ctx, ec.Recover(ctx, r))
5002 ret = graphql.Null
5003 }
5004 }()
5005 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5006 ctx = rctx
5007 return obj.Species, nil
5008 })
5009
5010 if resTmp == nil {
5011 if !graphql.HasFieldError(ctx, fc) {
5012 ec.Errorf(ctx, "must not be null")
5013 }
5014 return graphql.Null
5015 }
5016 res := resTmp.(string)
5017 fc.Result = res
5018 return ec.marshalNString2string(ctx, field.Selections, res)
5019 }
5020
5021 func (ec *executionContext) fieldContext_Dog_species(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5022 fc = &graphql.FieldContext{
5023 Object: "Dog",
5024 Field: field,
5025 IsMethod: false,
5026 IsResolver: false,
5027 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5028 return nil, errors.New("field of type String does not have child fields")
5029 },
5030 }
5031 return fc, nil
5032 }
5033
5034 func (ec *executionContext) _Dog_size(ctx context.Context, field graphql.CollectedField, obj *Dog) (ret graphql.Marshaler) {
5035 fc, err := ec.fieldContext_Dog_size(ctx, field)
5036 if err != nil {
5037 return graphql.Null
5038 }
5039 ctx = graphql.WithFieldContext(ctx, fc)
5040 defer func() {
5041 if r := recover(); r != nil {
5042 ec.Error(ctx, ec.Recover(ctx, r))
5043 ret = graphql.Null
5044 }
5045 }()
5046 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5047 ctx = rctx
5048 return obj.Size, nil
5049 })
5050
5051 if resTmp == nil {
5052 if !graphql.HasFieldError(ctx, fc) {
5053 ec.Errorf(ctx, "must not be null")
5054 }
5055 return graphql.Null
5056 }
5057 res := resTmp.(*Size)
5058 fc.Result = res
5059 return ec.marshalNSize2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐSize(ctx, field.Selections, res)
5060 }
5061
5062 func (ec *executionContext) fieldContext_Dog_size(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5063 fc = &graphql.FieldContext{
5064 Object: "Dog",
5065 Field: field,
5066 IsMethod: false,
5067 IsResolver: false,
5068 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5069 switch field.Name {
5070 case "height":
5071 return ec.fieldContext_Size_height(ctx, field)
5072 case "weight":
5073 return ec.fieldContext_Size_weight(ctx, field)
5074 }
5075 return nil, fmt.Errorf("no field named %q was found under type Size", field.Name)
5076 },
5077 }
5078 return fc, nil
5079 }
5080
5081 func (ec *executionContext) _Dog_dogBreed(ctx context.Context, field graphql.CollectedField, obj *Dog) (ret graphql.Marshaler) {
5082 fc, err := ec.fieldContext_Dog_dogBreed(ctx, field)
5083 if err != nil {
5084 return graphql.Null
5085 }
5086 ctx = graphql.WithFieldContext(ctx, fc)
5087 defer func() {
5088 if r := recover(); r != nil {
5089 ec.Error(ctx, ec.Recover(ctx, r))
5090 ret = graphql.Null
5091 }
5092 }()
5093 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5094 ctx = rctx
5095 return obj.DogBreed, nil
5096 })
5097
5098 if resTmp == nil {
5099 if !graphql.HasFieldError(ctx, fc) {
5100 ec.Errorf(ctx, "must not be null")
5101 }
5102 return graphql.Null
5103 }
5104 res := resTmp.(string)
5105 fc.Result = res
5106 return ec.marshalNString2string(ctx, field.Selections, res)
5107 }
5108
5109 func (ec *executionContext) fieldContext_Dog_dogBreed(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5110 fc = &graphql.FieldContext{
5111 Object: "Dog",
5112 Field: field,
5113 IsMethod: false,
5114 IsResolver: false,
5115 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5116 return nil, errors.New("field of type String does not have child fields")
5117 },
5118 }
5119 return fc, nil
5120 }
5121
5122 func (ec *executionContext) _EmbeddedCase1_exportedEmbeddedPointerExportedMethod(ctx context.Context, field graphql.CollectedField, obj *EmbeddedCase1) (ret graphql.Marshaler) {
5123 fc, err := ec.fieldContext_EmbeddedCase1_exportedEmbeddedPointerExportedMethod(ctx, field)
5124 if err != nil {
5125 return graphql.Null
5126 }
5127 ctx = graphql.WithFieldContext(ctx, fc)
5128 defer func() {
5129 if r := recover(); r != nil {
5130 ec.Error(ctx, ec.Recover(ctx, r))
5131 ret = graphql.Null
5132 }
5133 }()
5134 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5135 ctx = rctx
5136 return obj.ExportedEmbeddedPointerExportedMethod(), nil
5137 })
5138
5139 if resTmp == nil {
5140 if !graphql.HasFieldError(ctx, fc) {
5141 ec.Errorf(ctx, "must not be null")
5142 }
5143 return graphql.Null
5144 }
5145 res := resTmp.(string)
5146 fc.Result = res
5147 return ec.marshalNString2string(ctx, field.Selections, res)
5148 }
5149
5150 func (ec *executionContext) fieldContext_EmbeddedCase1_exportedEmbeddedPointerExportedMethod(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5151 fc = &graphql.FieldContext{
5152 Object: "EmbeddedCase1",
5153 Field: field,
5154 IsMethod: true,
5155 IsResolver: false,
5156 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5157 return nil, errors.New("field of type String does not have child fields")
5158 },
5159 }
5160 return fc, nil
5161 }
5162
5163 func (ec *executionContext) _EmbeddedCase2_unexportedEmbeddedPointerExportedMethod(ctx context.Context, field graphql.CollectedField, obj *EmbeddedCase2) (ret graphql.Marshaler) {
5164 fc, err := ec.fieldContext_EmbeddedCase2_unexportedEmbeddedPointerExportedMethod(ctx, field)
5165 if err != nil {
5166 return graphql.Null
5167 }
5168 ctx = graphql.WithFieldContext(ctx, fc)
5169 defer func() {
5170 if r := recover(); r != nil {
5171 ec.Error(ctx, ec.Recover(ctx, r))
5172 ret = graphql.Null
5173 }
5174 }()
5175 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5176 ctx = rctx
5177 return obj.UnexportedEmbeddedPointerExportedMethod(), nil
5178 })
5179
5180 if resTmp == nil {
5181 if !graphql.HasFieldError(ctx, fc) {
5182 ec.Errorf(ctx, "must not be null")
5183 }
5184 return graphql.Null
5185 }
5186 res := resTmp.(string)
5187 fc.Result = res
5188 return ec.marshalNString2string(ctx, field.Selections, res)
5189 }
5190
5191 func (ec *executionContext) fieldContext_EmbeddedCase2_unexportedEmbeddedPointerExportedMethod(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5192 fc = &graphql.FieldContext{
5193 Object: "EmbeddedCase2",
5194 Field: field,
5195 IsMethod: true,
5196 IsResolver: false,
5197 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5198 return nil, errors.New("field of type String does not have child fields")
5199 },
5200 }
5201 return fc, nil
5202 }
5203
5204 func (ec *executionContext) _EmbeddedCase3_unexportedEmbeddedInterfaceExportedMethod(ctx context.Context, field graphql.CollectedField, obj *EmbeddedCase3) (ret graphql.Marshaler) {
5205 fc, err := ec.fieldContext_EmbeddedCase3_unexportedEmbeddedInterfaceExportedMethod(ctx, field)
5206 if err != nil {
5207 return graphql.Null
5208 }
5209 ctx = graphql.WithFieldContext(ctx, fc)
5210 defer func() {
5211 if r := recover(); r != nil {
5212 ec.Error(ctx, ec.Recover(ctx, r))
5213 ret = graphql.Null
5214 }
5215 }()
5216 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5217 ctx = rctx
5218 return obj.UnexportedEmbeddedInterfaceExportedMethod(), nil
5219 })
5220
5221 if resTmp == nil {
5222 if !graphql.HasFieldError(ctx, fc) {
5223 ec.Errorf(ctx, "must not be null")
5224 }
5225 return graphql.Null
5226 }
5227 res := resTmp.(string)
5228 fc.Result = res
5229 return ec.marshalNString2string(ctx, field.Selections, res)
5230 }
5231
5232 func (ec *executionContext) fieldContext_EmbeddedCase3_unexportedEmbeddedInterfaceExportedMethod(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5233 fc = &graphql.FieldContext{
5234 Object: "EmbeddedCase3",
5235 Field: field,
5236 IsMethod: true,
5237 IsResolver: false,
5238 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5239 return nil, errors.New("field of type String does not have child fields")
5240 },
5241 }
5242 return fc, nil
5243 }
5244
5245 func (ec *executionContext) _EmbeddedDefaultScalar_value(ctx context.Context, field graphql.CollectedField, obj *EmbeddedDefaultScalar) (ret graphql.Marshaler) {
5246 fc, err := ec.fieldContext_EmbeddedDefaultScalar_value(ctx, field)
5247 if err != nil {
5248 return graphql.Null
5249 }
5250 ctx = graphql.WithFieldContext(ctx, fc)
5251 defer func() {
5252 if r := recover(); r != nil {
5253 ec.Error(ctx, ec.Recover(ctx, r))
5254 ret = graphql.Null
5255 }
5256 }()
5257 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5258 ctx = rctx
5259 return obj.Value, nil
5260 })
5261
5262 if resTmp == nil {
5263 return graphql.Null
5264 }
5265 res := resTmp.(*string)
5266 fc.Result = res
5267 return ec.marshalODefaultScalarImplementation2ᚖstring(ctx, field.Selections, res)
5268 }
5269
5270 func (ec *executionContext) fieldContext_EmbeddedDefaultScalar_value(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5271 fc = &graphql.FieldContext{
5272 Object: "EmbeddedDefaultScalar",
5273 Field: field,
5274 IsMethod: false,
5275 IsResolver: false,
5276 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5277 return nil, errors.New("field of type DefaultScalarImplementation does not have child fields")
5278 },
5279 }
5280 return fc, nil
5281 }
5282
5283 func (ec *executionContext) _EmbeddedPointer_ID(ctx context.Context, field graphql.CollectedField, obj *EmbeddedPointerModel) (ret graphql.Marshaler) {
5284 fc, err := ec.fieldContext_EmbeddedPointer_ID(ctx, field)
5285 if err != nil {
5286 return graphql.Null
5287 }
5288 ctx = graphql.WithFieldContext(ctx, fc)
5289 defer func() {
5290 if r := recover(); r != nil {
5291 ec.Error(ctx, ec.Recover(ctx, r))
5292 ret = graphql.Null
5293 }
5294 }()
5295 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5296 ctx = rctx
5297 return obj.ID, nil
5298 })
5299
5300 if resTmp == nil {
5301 return graphql.Null
5302 }
5303 res := resTmp.(string)
5304 fc.Result = res
5305 return ec.marshalOString2string(ctx, field.Selections, res)
5306 }
5307
5308 func (ec *executionContext) fieldContext_EmbeddedPointer_ID(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5309 fc = &graphql.FieldContext{
5310 Object: "EmbeddedPointer",
5311 Field: field,
5312 IsMethod: false,
5313 IsResolver: false,
5314 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5315 return nil, errors.New("field of type String does not have child fields")
5316 },
5317 }
5318 return fc, nil
5319 }
5320
5321 func (ec *executionContext) _EmbeddedPointer_Title(ctx context.Context, field graphql.CollectedField, obj *EmbeddedPointerModel) (ret graphql.Marshaler) {
5322 fc, err := ec.fieldContext_EmbeddedPointer_Title(ctx, field)
5323 if err != nil {
5324 return graphql.Null
5325 }
5326 ctx = graphql.WithFieldContext(ctx, fc)
5327 defer func() {
5328 if r := recover(); r != nil {
5329 ec.Error(ctx, ec.Recover(ctx, r))
5330 ret = graphql.Null
5331 }
5332 }()
5333 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5334 ctx = rctx
5335 return obj.Title, nil
5336 })
5337
5338 if resTmp == nil {
5339 return graphql.Null
5340 }
5341 res := resTmp.(string)
5342 fc.Result = res
5343 return ec.marshalOString2string(ctx, field.Selections, res)
5344 }
5345
5346 func (ec *executionContext) fieldContext_EmbeddedPointer_Title(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5347 fc = &graphql.FieldContext{
5348 Object: "EmbeddedPointer",
5349 Field: field,
5350 IsMethod: false,
5351 IsResolver: false,
5352 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5353 return nil, errors.New("field of type String does not have child fields")
5354 },
5355 }
5356 return fc, nil
5357 }
5358
5359 func (ec *executionContext) _Error_id(ctx context.Context, field graphql.CollectedField, obj *Error) (ret graphql.Marshaler) {
5360 fc, err := ec.fieldContext_Error_id(ctx, field)
5361 if err != nil {
5362 return graphql.Null
5363 }
5364 ctx = graphql.WithFieldContext(ctx, fc)
5365 defer func() {
5366 if r := recover(); r != nil {
5367 ec.Error(ctx, ec.Recover(ctx, r))
5368 ret = graphql.Null
5369 }
5370 }()
5371 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5372 ctx = rctx
5373 return obj.ID, nil
5374 })
5375
5376 if resTmp == nil {
5377 if !graphql.HasFieldError(ctx, fc) {
5378 ec.Errorf(ctx, "must not be null")
5379 }
5380 return graphql.Null
5381 }
5382 res := resTmp.(string)
5383 fc.Result = res
5384 return ec.marshalNID2string(ctx, field.Selections, res)
5385 }
5386
5387 func (ec *executionContext) fieldContext_Error_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5388 fc = &graphql.FieldContext{
5389 Object: "Error",
5390 Field: field,
5391 IsMethod: false,
5392 IsResolver: false,
5393 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5394 return nil, errors.New("field of type ID does not have child fields")
5395 },
5396 }
5397 return fc, nil
5398 }
5399
5400 func (ec *executionContext) _Error_errorOnNonRequiredField(ctx context.Context, field graphql.CollectedField, obj *Error) (ret graphql.Marshaler) {
5401 fc, err := ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
5402 if err != nil {
5403 return graphql.Null
5404 }
5405 ctx = graphql.WithFieldContext(ctx, fc)
5406 defer func() {
5407 if r := recover(); r != nil {
5408 ec.Error(ctx, ec.Recover(ctx, r))
5409 ret = graphql.Null
5410 }
5411 }()
5412 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5413 ctx = rctx
5414 return obj.ErrorOnNonRequiredField()
5415 })
5416
5417 if resTmp == nil {
5418 return graphql.Null
5419 }
5420 res := resTmp.(string)
5421 fc.Result = res
5422 return ec.marshalOString2string(ctx, field.Selections, res)
5423 }
5424
5425 func (ec *executionContext) fieldContext_Error_errorOnNonRequiredField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5426 fc = &graphql.FieldContext{
5427 Object: "Error",
5428 Field: field,
5429 IsMethod: true,
5430 IsResolver: false,
5431 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5432 return nil, errors.New("field of type String does not have child fields")
5433 },
5434 }
5435 return fc, nil
5436 }
5437
5438 func (ec *executionContext) _Error_errorOnRequiredField(ctx context.Context, field graphql.CollectedField, obj *Error) (ret graphql.Marshaler) {
5439 fc, err := ec.fieldContext_Error_errorOnRequiredField(ctx, field)
5440 if err != nil {
5441 return graphql.Null
5442 }
5443 ctx = graphql.WithFieldContext(ctx, fc)
5444 defer func() {
5445 if r := recover(); r != nil {
5446 ec.Error(ctx, ec.Recover(ctx, r))
5447 ret = graphql.Null
5448 }
5449 }()
5450 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5451 ctx = rctx
5452 return obj.ErrorOnRequiredField()
5453 })
5454
5455 if resTmp == nil {
5456 if !graphql.HasFieldError(ctx, fc) {
5457 ec.Errorf(ctx, "must not be null")
5458 }
5459 return graphql.Null
5460 }
5461 res := resTmp.(string)
5462 fc.Result = res
5463 return ec.marshalNString2string(ctx, field.Selections, res)
5464 }
5465
5466 func (ec *executionContext) fieldContext_Error_errorOnRequiredField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5467 fc = &graphql.FieldContext{
5468 Object: "Error",
5469 Field: field,
5470 IsMethod: true,
5471 IsResolver: false,
5472 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5473 return nil, errors.New("field of type String does not have child fields")
5474 },
5475 }
5476 return fc, nil
5477 }
5478
5479 func (ec *executionContext) _Error_nilOnRequiredField(ctx context.Context, field graphql.CollectedField, obj *Error) (ret graphql.Marshaler) {
5480 fc, err := ec.fieldContext_Error_nilOnRequiredField(ctx, field)
5481 if err != nil {
5482 return graphql.Null
5483 }
5484 ctx = graphql.WithFieldContext(ctx, fc)
5485 defer func() {
5486 if r := recover(); r != nil {
5487 ec.Error(ctx, ec.Recover(ctx, r))
5488 ret = graphql.Null
5489 }
5490 }()
5491 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5492 ctx = rctx
5493 return obj.NilOnRequiredField(), nil
5494 })
5495
5496 if resTmp == nil {
5497 if !graphql.HasFieldError(ctx, fc) {
5498 ec.Errorf(ctx, "must not be null")
5499 }
5500 return graphql.Null
5501 }
5502 res := resTmp.(*string)
5503 fc.Result = res
5504 return ec.marshalNString2ᚖstring(ctx, field.Selections, res)
5505 }
5506
5507 func (ec *executionContext) fieldContext_Error_nilOnRequiredField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5508 fc = &graphql.FieldContext{
5509 Object: "Error",
5510 Field: field,
5511 IsMethod: true,
5512 IsResolver: false,
5513 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5514 return nil, errors.New("field of type String does not have child fields")
5515 },
5516 }
5517 return fc, nil
5518 }
5519
5520 func (ec *executionContext) _Errors_a(ctx context.Context, field graphql.CollectedField, obj *Errors) (ret graphql.Marshaler) {
5521 fc, err := ec.fieldContext_Errors_a(ctx, field)
5522 if err != nil {
5523 return graphql.Null
5524 }
5525 ctx = graphql.WithFieldContext(ctx, fc)
5526 defer func() {
5527 if r := recover(); r != nil {
5528 ec.Error(ctx, ec.Recover(ctx, r))
5529 ret = graphql.Null
5530 }
5531 }()
5532 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5533 ctx = rctx
5534 return ec.resolvers.Errors().A(rctx, obj)
5535 })
5536
5537 if resTmp == nil {
5538 if !graphql.HasFieldError(ctx, fc) {
5539 ec.Errorf(ctx, "must not be null")
5540 }
5541 return graphql.Null
5542 }
5543 res := resTmp.(*Error)
5544 fc.Result = res
5545 return ec.marshalNError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐError(ctx, field.Selections, res)
5546 }
5547
5548 func (ec *executionContext) fieldContext_Errors_a(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5549 fc = &graphql.FieldContext{
5550 Object: "Errors",
5551 Field: field,
5552 IsMethod: true,
5553 IsResolver: true,
5554 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5555 switch field.Name {
5556 case "id":
5557 return ec.fieldContext_Error_id(ctx, field)
5558 case "errorOnNonRequiredField":
5559 return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
5560 case "errorOnRequiredField":
5561 return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
5562 case "nilOnRequiredField":
5563 return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
5564 }
5565 return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
5566 },
5567 }
5568 return fc, nil
5569 }
5570
5571 func (ec *executionContext) _Errors_b(ctx context.Context, field graphql.CollectedField, obj *Errors) (ret graphql.Marshaler) {
5572 fc, err := ec.fieldContext_Errors_b(ctx, field)
5573 if err != nil {
5574 return graphql.Null
5575 }
5576 ctx = graphql.WithFieldContext(ctx, fc)
5577 defer func() {
5578 if r := recover(); r != nil {
5579 ec.Error(ctx, ec.Recover(ctx, r))
5580 ret = graphql.Null
5581 }
5582 }()
5583 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5584 ctx = rctx
5585 return ec.resolvers.Errors().B(rctx, obj)
5586 })
5587
5588 if resTmp == nil {
5589 if !graphql.HasFieldError(ctx, fc) {
5590 ec.Errorf(ctx, "must not be null")
5591 }
5592 return graphql.Null
5593 }
5594 res := resTmp.(*Error)
5595 fc.Result = res
5596 return ec.marshalNError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐError(ctx, field.Selections, res)
5597 }
5598
5599 func (ec *executionContext) fieldContext_Errors_b(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5600 fc = &graphql.FieldContext{
5601 Object: "Errors",
5602 Field: field,
5603 IsMethod: true,
5604 IsResolver: true,
5605 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5606 switch field.Name {
5607 case "id":
5608 return ec.fieldContext_Error_id(ctx, field)
5609 case "errorOnNonRequiredField":
5610 return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
5611 case "errorOnRequiredField":
5612 return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
5613 case "nilOnRequiredField":
5614 return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
5615 }
5616 return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
5617 },
5618 }
5619 return fc, nil
5620 }
5621
5622 func (ec *executionContext) _Errors_c(ctx context.Context, field graphql.CollectedField, obj *Errors) (ret graphql.Marshaler) {
5623 fc, err := ec.fieldContext_Errors_c(ctx, field)
5624 if err != nil {
5625 return graphql.Null
5626 }
5627 ctx = graphql.WithFieldContext(ctx, fc)
5628 defer func() {
5629 if r := recover(); r != nil {
5630 ec.Error(ctx, ec.Recover(ctx, r))
5631 ret = graphql.Null
5632 }
5633 }()
5634 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5635 ctx = rctx
5636 return ec.resolvers.Errors().C(rctx, obj)
5637 })
5638
5639 if resTmp == nil {
5640 if !graphql.HasFieldError(ctx, fc) {
5641 ec.Errorf(ctx, "must not be null")
5642 }
5643 return graphql.Null
5644 }
5645 res := resTmp.(*Error)
5646 fc.Result = res
5647 return ec.marshalNError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐError(ctx, field.Selections, res)
5648 }
5649
5650 func (ec *executionContext) fieldContext_Errors_c(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5651 fc = &graphql.FieldContext{
5652 Object: "Errors",
5653 Field: field,
5654 IsMethod: true,
5655 IsResolver: true,
5656 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5657 switch field.Name {
5658 case "id":
5659 return ec.fieldContext_Error_id(ctx, field)
5660 case "errorOnNonRequiredField":
5661 return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
5662 case "errorOnRequiredField":
5663 return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
5664 case "nilOnRequiredField":
5665 return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
5666 }
5667 return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
5668 },
5669 }
5670 return fc, nil
5671 }
5672
5673 func (ec *executionContext) _Errors_d(ctx context.Context, field graphql.CollectedField, obj *Errors) (ret graphql.Marshaler) {
5674 fc, err := ec.fieldContext_Errors_d(ctx, field)
5675 if err != nil {
5676 return graphql.Null
5677 }
5678 ctx = graphql.WithFieldContext(ctx, fc)
5679 defer func() {
5680 if r := recover(); r != nil {
5681 ec.Error(ctx, ec.Recover(ctx, r))
5682 ret = graphql.Null
5683 }
5684 }()
5685 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5686 ctx = rctx
5687 return ec.resolvers.Errors().D(rctx, obj)
5688 })
5689
5690 if resTmp == nil {
5691 if !graphql.HasFieldError(ctx, fc) {
5692 ec.Errorf(ctx, "must not be null")
5693 }
5694 return graphql.Null
5695 }
5696 res := resTmp.(*Error)
5697 fc.Result = res
5698 return ec.marshalNError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐError(ctx, field.Selections, res)
5699 }
5700
5701 func (ec *executionContext) fieldContext_Errors_d(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5702 fc = &graphql.FieldContext{
5703 Object: "Errors",
5704 Field: field,
5705 IsMethod: true,
5706 IsResolver: true,
5707 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5708 switch field.Name {
5709 case "id":
5710 return ec.fieldContext_Error_id(ctx, field)
5711 case "errorOnNonRequiredField":
5712 return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
5713 case "errorOnRequiredField":
5714 return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
5715 case "nilOnRequiredField":
5716 return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
5717 }
5718 return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
5719 },
5720 }
5721 return fc, nil
5722 }
5723
5724 func (ec *executionContext) _Errors_e(ctx context.Context, field graphql.CollectedField, obj *Errors) (ret graphql.Marshaler) {
5725 fc, err := ec.fieldContext_Errors_e(ctx, field)
5726 if err != nil {
5727 return graphql.Null
5728 }
5729 ctx = graphql.WithFieldContext(ctx, fc)
5730 defer func() {
5731 if r := recover(); r != nil {
5732 ec.Error(ctx, ec.Recover(ctx, r))
5733 ret = graphql.Null
5734 }
5735 }()
5736 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5737 ctx = rctx
5738 return ec.resolvers.Errors().E(rctx, obj)
5739 })
5740
5741 if resTmp == nil {
5742 if !graphql.HasFieldError(ctx, fc) {
5743 ec.Errorf(ctx, "must not be null")
5744 }
5745 return graphql.Null
5746 }
5747 res := resTmp.(*Error)
5748 fc.Result = res
5749 return ec.marshalNError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐError(ctx, field.Selections, res)
5750 }
5751
5752 func (ec *executionContext) fieldContext_Errors_e(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5753 fc = &graphql.FieldContext{
5754 Object: "Errors",
5755 Field: field,
5756 IsMethod: true,
5757 IsResolver: true,
5758 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5759 switch field.Name {
5760 case "id":
5761 return ec.fieldContext_Error_id(ctx, field)
5762 case "errorOnNonRequiredField":
5763 return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
5764 case "errorOnRequiredField":
5765 return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
5766 case "nilOnRequiredField":
5767 return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
5768 }
5769 return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
5770 },
5771 }
5772 return fc, nil
5773 }
5774
5775 func (ec *executionContext) _FieldsOrderPayload_firstFieldValue(ctx context.Context, field graphql.CollectedField, obj *FieldsOrderPayload) (ret graphql.Marshaler) {
5776 fc, err := ec.fieldContext_FieldsOrderPayload_firstFieldValue(ctx, field)
5777 if err != nil {
5778 return graphql.Null
5779 }
5780 ctx = graphql.WithFieldContext(ctx, fc)
5781 defer func() {
5782 if r := recover(); r != nil {
5783 ec.Error(ctx, ec.Recover(ctx, r))
5784 ret = graphql.Null
5785 }
5786 }()
5787 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5788 ctx = rctx
5789 return obj.FirstFieldValue, nil
5790 })
5791
5792 if resTmp == nil {
5793 return graphql.Null
5794 }
5795 res := resTmp.(*string)
5796 fc.Result = res
5797 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
5798 }
5799
5800 func (ec *executionContext) fieldContext_FieldsOrderPayload_firstFieldValue(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5801 fc = &graphql.FieldContext{
5802 Object: "FieldsOrderPayload",
5803 Field: field,
5804 IsMethod: false,
5805 IsResolver: false,
5806 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5807 return nil, errors.New("field of type String does not have child fields")
5808 },
5809 }
5810 return fc, nil
5811 }
5812
5813 func (ec *executionContext) _ForcedResolver_field(ctx context.Context, field graphql.CollectedField, obj *ForcedResolver) (ret graphql.Marshaler) {
5814 fc, err := ec.fieldContext_ForcedResolver_field(ctx, field)
5815 if err != nil {
5816 return graphql.Null
5817 }
5818 ctx = graphql.WithFieldContext(ctx, fc)
5819 defer func() {
5820 if r := recover(); r != nil {
5821 ec.Error(ctx, ec.Recover(ctx, r))
5822 ret = graphql.Null
5823 }
5824 }()
5825 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5826 ctx = rctx
5827 return ec.resolvers.ForcedResolver().Field(rctx, obj)
5828 })
5829
5830 if resTmp == nil {
5831 return graphql.Null
5832 }
5833 res := resTmp.(*Circle)
5834 fc.Result = res
5835 return ec.marshalOCircle2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCircle(ctx, field.Selections, res)
5836 }
5837
5838 func (ec *executionContext) fieldContext_ForcedResolver_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5839 fc = &graphql.FieldContext{
5840 Object: "ForcedResolver",
5841 Field: field,
5842 IsMethod: true,
5843 IsResolver: true,
5844 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5845 switch field.Name {
5846 case "radius":
5847 return ec.fieldContext_Circle_radius(ctx, field)
5848 case "area":
5849 return ec.fieldContext_Circle_area(ctx, field)
5850 case "coordinates":
5851 return ec.fieldContext_Circle_coordinates(ctx, field)
5852 }
5853 return nil, fmt.Errorf("no field named %q was found under type Circle", field.Name)
5854 },
5855 }
5856 return fc, nil
5857 }
5858
5859 func (ec *executionContext) _Horse_species(ctx context.Context, field graphql.CollectedField, obj *Horse) (ret graphql.Marshaler) {
5860 fc, err := ec.fieldContext_Horse_species(ctx, field)
5861 if err != nil {
5862 return graphql.Null
5863 }
5864 ctx = graphql.WithFieldContext(ctx, fc)
5865 defer func() {
5866 if r := recover(); r != nil {
5867 ec.Error(ctx, ec.Recover(ctx, r))
5868 ret = graphql.Null
5869 }
5870 }()
5871 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5872 ctx = rctx
5873 return obj.Species, nil
5874 })
5875
5876 if resTmp == nil {
5877 if !graphql.HasFieldError(ctx, fc) {
5878 ec.Errorf(ctx, "must not be null")
5879 }
5880 return graphql.Null
5881 }
5882 res := resTmp.(string)
5883 fc.Result = res
5884 return ec.marshalNString2string(ctx, field.Selections, res)
5885 }
5886
5887 func (ec *executionContext) fieldContext_Horse_species(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5888 fc = &graphql.FieldContext{
5889 Object: "Horse",
5890 Field: field,
5891 IsMethod: false,
5892 IsResolver: false,
5893 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5894 return nil, errors.New("field of type String does not have child fields")
5895 },
5896 }
5897 return fc, nil
5898 }
5899
5900 func (ec *executionContext) _Horse_size(ctx context.Context, field graphql.CollectedField, obj *Horse) (ret graphql.Marshaler) {
5901 fc, err := ec.fieldContext_Horse_size(ctx, field)
5902 if err != nil {
5903 return graphql.Null
5904 }
5905 ctx = graphql.WithFieldContext(ctx, fc)
5906 defer func() {
5907 if r := recover(); r != nil {
5908 ec.Error(ctx, ec.Recover(ctx, r))
5909 ret = graphql.Null
5910 }
5911 }()
5912 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5913 ctx = rctx
5914 return obj.Size, nil
5915 })
5916
5917 if resTmp == nil {
5918 if !graphql.HasFieldError(ctx, fc) {
5919 ec.Errorf(ctx, "must not be null")
5920 }
5921 return graphql.Null
5922 }
5923 res := resTmp.(*Size)
5924 fc.Result = res
5925 return ec.marshalNSize2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐSize(ctx, field.Selections, res)
5926 }
5927
5928 func (ec *executionContext) fieldContext_Horse_size(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5929 fc = &graphql.FieldContext{
5930 Object: "Horse",
5931 Field: field,
5932 IsMethod: false,
5933 IsResolver: false,
5934 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5935 switch field.Name {
5936 case "height":
5937 return ec.fieldContext_Size_height(ctx, field)
5938 case "weight":
5939 return ec.fieldContext_Size_weight(ctx, field)
5940 }
5941 return nil, fmt.Errorf("no field named %q was found under type Size", field.Name)
5942 },
5943 }
5944 return fc, nil
5945 }
5946
5947 func (ec *executionContext) _Horse_horseBreed(ctx context.Context, field graphql.CollectedField, obj *Horse) (ret graphql.Marshaler) {
5948 fc, err := ec.fieldContext_Horse_horseBreed(ctx, field)
5949 if err != nil {
5950 return graphql.Null
5951 }
5952 ctx = graphql.WithFieldContext(ctx, fc)
5953 defer func() {
5954 if r := recover(); r != nil {
5955 ec.Error(ctx, ec.Recover(ctx, r))
5956 ret = graphql.Null
5957 }
5958 }()
5959 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5960 ctx = rctx
5961 return obj.HorseBreed, nil
5962 })
5963
5964 if resTmp == nil {
5965 if !graphql.HasFieldError(ctx, fc) {
5966 ec.Errorf(ctx, "must not be null")
5967 }
5968 return graphql.Null
5969 }
5970 res := resTmp.(string)
5971 fc.Result = res
5972 return ec.marshalNString2string(ctx, field.Selections, res)
5973 }
5974
5975 func (ec *executionContext) fieldContext_Horse_horseBreed(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
5976 fc = &graphql.FieldContext{
5977 Object: "Horse",
5978 Field: field,
5979 IsMethod: false,
5980 IsResolver: false,
5981 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
5982 return nil, errors.New("field of type String does not have child fields")
5983 },
5984 }
5985 return fc, nil
5986 }
5987
5988 func (ec *executionContext) _InnerObject_id(ctx context.Context, field graphql.CollectedField, obj *InnerObject) (ret graphql.Marshaler) {
5989 fc, err := ec.fieldContext_InnerObject_id(ctx, field)
5990 if err != nil {
5991 return graphql.Null
5992 }
5993 ctx = graphql.WithFieldContext(ctx, fc)
5994 defer func() {
5995 if r := recover(); r != nil {
5996 ec.Error(ctx, ec.Recover(ctx, r))
5997 ret = graphql.Null
5998 }
5999 }()
6000 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6001 ctx = rctx
6002 return obj.ID, nil
6003 })
6004
6005 if resTmp == nil {
6006 if !graphql.HasFieldError(ctx, fc) {
6007 ec.Errorf(ctx, "must not be null")
6008 }
6009 return graphql.Null
6010 }
6011 res := resTmp.(int)
6012 fc.Result = res
6013 return ec.marshalNInt2int(ctx, field.Selections, res)
6014 }
6015
6016 func (ec *executionContext) fieldContext_InnerObject_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6017 fc = &graphql.FieldContext{
6018 Object: "InnerObject",
6019 Field: field,
6020 IsMethod: false,
6021 IsResolver: false,
6022 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6023 return nil, errors.New("field of type Int does not have child fields")
6024 },
6025 }
6026 return fc, nil
6027 }
6028
6029 func (ec *executionContext) _InvalidIdentifier_id(ctx context.Context, field graphql.CollectedField, obj *invalid_packagename.InvalidIdentifier) (ret graphql.Marshaler) {
6030 fc, err := ec.fieldContext_InvalidIdentifier_id(ctx, field)
6031 if err != nil {
6032 return graphql.Null
6033 }
6034 ctx = graphql.WithFieldContext(ctx, fc)
6035 defer func() {
6036 if r := recover(); r != nil {
6037 ec.Error(ctx, ec.Recover(ctx, r))
6038 ret = graphql.Null
6039 }
6040 }()
6041 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6042 ctx = rctx
6043 return obj.ID, nil
6044 })
6045
6046 if resTmp == nil {
6047 if !graphql.HasFieldError(ctx, fc) {
6048 ec.Errorf(ctx, "must not be null")
6049 }
6050 return graphql.Null
6051 }
6052 res := resTmp.(int)
6053 fc.Result = res
6054 return ec.marshalNInt2int(ctx, field.Selections, res)
6055 }
6056
6057 func (ec *executionContext) fieldContext_InvalidIdentifier_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6058 fc = &graphql.FieldContext{
6059 Object: "InvalidIdentifier",
6060 Field: field,
6061 IsMethod: false,
6062 IsResolver: false,
6063 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6064 return nil, errors.New("field of type Int does not have child fields")
6065 },
6066 }
6067 return fc, nil
6068 }
6069
6070 func (ec *executionContext) _It_id(ctx context.Context, field graphql.CollectedField, obj *introspection1.It) (ret graphql.Marshaler) {
6071 fc, err := ec.fieldContext_It_id(ctx, field)
6072 if err != nil {
6073 return graphql.Null
6074 }
6075 ctx = graphql.WithFieldContext(ctx, fc)
6076 defer func() {
6077 if r := recover(); r != nil {
6078 ec.Error(ctx, ec.Recover(ctx, r))
6079 ret = graphql.Null
6080 }
6081 }()
6082 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6083 ctx = rctx
6084 return obj.ID, nil
6085 })
6086
6087 if resTmp == nil {
6088 if !graphql.HasFieldError(ctx, fc) {
6089 ec.Errorf(ctx, "must not be null")
6090 }
6091 return graphql.Null
6092 }
6093 res := resTmp.(string)
6094 fc.Result = res
6095 return ec.marshalNID2string(ctx, field.Selections, res)
6096 }
6097
6098 func (ec *executionContext) fieldContext_It_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6099 fc = &graphql.FieldContext{
6100 Object: "It",
6101 Field: field,
6102 IsMethod: false,
6103 IsResolver: false,
6104 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6105 return nil, errors.New("field of type ID does not have child fields")
6106 },
6107 }
6108 return fc, nil
6109 }
6110
6111 func (ec *executionContext) _LoopA_b(ctx context.Context, field graphql.CollectedField, obj *LoopA) (ret graphql.Marshaler) {
6112 fc, err := ec.fieldContext_LoopA_b(ctx, field)
6113 if err != nil {
6114 return graphql.Null
6115 }
6116 ctx = graphql.WithFieldContext(ctx, fc)
6117 defer func() {
6118 if r := recover(); r != nil {
6119 ec.Error(ctx, ec.Recover(ctx, r))
6120 ret = graphql.Null
6121 }
6122 }()
6123 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6124 ctx = rctx
6125 return obj.B, nil
6126 })
6127
6128 if resTmp == nil {
6129 if !graphql.HasFieldError(ctx, fc) {
6130 ec.Errorf(ctx, "must not be null")
6131 }
6132 return graphql.Null
6133 }
6134 res := resTmp.(*LoopB)
6135 fc.Result = res
6136 return ec.marshalNLoopB2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐLoopB(ctx, field.Selections, res)
6137 }
6138
6139 func (ec *executionContext) fieldContext_LoopA_b(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6140 fc = &graphql.FieldContext{
6141 Object: "LoopA",
6142 Field: field,
6143 IsMethod: false,
6144 IsResolver: false,
6145 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6146 switch field.Name {
6147 case "a":
6148 return ec.fieldContext_LoopB_a(ctx, field)
6149 }
6150 return nil, fmt.Errorf("no field named %q was found under type LoopB", field.Name)
6151 },
6152 }
6153 return fc, nil
6154 }
6155
6156 func (ec *executionContext) _LoopB_a(ctx context.Context, field graphql.CollectedField, obj *LoopB) (ret graphql.Marshaler) {
6157 fc, err := ec.fieldContext_LoopB_a(ctx, field)
6158 if err != nil {
6159 return graphql.Null
6160 }
6161 ctx = graphql.WithFieldContext(ctx, fc)
6162 defer func() {
6163 if r := recover(); r != nil {
6164 ec.Error(ctx, ec.Recover(ctx, r))
6165 ret = graphql.Null
6166 }
6167 }()
6168 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6169 ctx = rctx
6170 return obj.A, nil
6171 })
6172
6173 if resTmp == nil {
6174 if !graphql.HasFieldError(ctx, fc) {
6175 ec.Errorf(ctx, "must not be null")
6176 }
6177 return graphql.Null
6178 }
6179 res := resTmp.(*LoopA)
6180 fc.Result = res
6181 return ec.marshalNLoopA2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐLoopA(ctx, field.Selections, res)
6182 }
6183
6184 func (ec *executionContext) fieldContext_LoopB_a(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6185 fc = &graphql.FieldContext{
6186 Object: "LoopB",
6187 Field: field,
6188 IsMethod: false,
6189 IsResolver: false,
6190 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6191 switch field.Name {
6192 case "b":
6193 return ec.fieldContext_LoopA_b(ctx, field)
6194 }
6195 return nil, fmt.Errorf("no field named %q was found under type LoopA", field.Name)
6196 },
6197 }
6198 return fc, nil
6199 }
6200
6201 func (ec *executionContext) _Map_id(ctx context.Context, field graphql.CollectedField, obj *Map) (ret graphql.Marshaler) {
6202 fc, err := ec.fieldContext_Map_id(ctx, field)
6203 if err != nil {
6204 return graphql.Null
6205 }
6206 ctx = graphql.WithFieldContext(ctx, fc)
6207 defer func() {
6208 if r := recover(); r != nil {
6209 ec.Error(ctx, ec.Recover(ctx, r))
6210 ret = graphql.Null
6211 }
6212 }()
6213 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6214 ctx = rctx
6215 return obj.ID, nil
6216 })
6217
6218 if resTmp == nil {
6219 if !graphql.HasFieldError(ctx, fc) {
6220 ec.Errorf(ctx, "must not be null")
6221 }
6222 return graphql.Null
6223 }
6224 res := resTmp.(string)
6225 fc.Result = res
6226 return ec.marshalNID2string(ctx, field.Selections, res)
6227 }
6228
6229 func (ec *executionContext) fieldContext_Map_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6230 fc = &graphql.FieldContext{
6231 Object: "Map",
6232 Field: field,
6233 IsMethod: false,
6234 IsResolver: false,
6235 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6236 return nil, errors.New("field of type ID does not have child fields")
6237 },
6238 }
6239 return fc, nil
6240 }
6241
6242 func (ec *executionContext) _MapNested_value(ctx context.Context, field graphql.CollectedField, obj *MapNested) (ret graphql.Marshaler) {
6243 fc, err := ec.fieldContext_MapNested_value(ctx, field)
6244 if err != nil {
6245 return graphql.Null
6246 }
6247 ctx = graphql.WithFieldContext(ctx, fc)
6248 defer func() {
6249 if r := recover(); r != nil {
6250 ec.Error(ctx, ec.Recover(ctx, r))
6251 ret = graphql.Null
6252 }
6253 }()
6254 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6255 ctx = rctx
6256 return obj.Value, nil
6257 })
6258
6259 if resTmp == nil {
6260 if !graphql.HasFieldError(ctx, fc) {
6261 ec.Errorf(ctx, "must not be null")
6262 }
6263 return graphql.Null
6264 }
6265 res := resTmp.(CustomScalar)
6266 fc.Result = res
6267 return ec.marshalNCustomScalar2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCustomScalar(ctx, field.Selections, res)
6268 }
6269
6270 func (ec *executionContext) fieldContext_MapNested_value(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6271 fc = &graphql.FieldContext{
6272 Object: "MapNested",
6273 Field: field,
6274 IsMethod: false,
6275 IsResolver: false,
6276 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6277 return nil, errors.New("field of type CustomScalar does not have child fields")
6278 },
6279 }
6280 return fc, nil
6281 }
6282
6283 func (ec *executionContext) _MapStringInterfaceType_a(ctx context.Context, field graphql.CollectedField, obj map[string]interface{}) (ret graphql.Marshaler) {
6284 fc, err := ec.fieldContext_MapStringInterfaceType_a(ctx, field)
6285 if err != nil {
6286 return graphql.Null
6287 }
6288 ctx = graphql.WithFieldContext(ctx, fc)
6289 defer func() {
6290 if r := recover(); r != nil {
6291 ec.Error(ctx, ec.Recover(ctx, r))
6292 ret = graphql.Null
6293 }
6294 }()
6295 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6296 ctx = rctx
6297 switch v := obj["a"].(type) {
6298 case *string:
6299 return v, nil
6300 case string:
6301 return &v, nil
6302 case nil:
6303 return (*string)(nil), nil
6304 default:
6305 return nil, fmt.Errorf("unexpected type %T for field %s", v, "a")
6306 }
6307 })
6308
6309 if resTmp == nil {
6310 return graphql.Null
6311 }
6312 res := resTmp.(*string)
6313 fc.Result = res
6314 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
6315 }
6316
6317 func (ec *executionContext) fieldContext_MapStringInterfaceType_a(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6318 fc = &graphql.FieldContext{
6319 Object: "MapStringInterfaceType",
6320 Field: field,
6321 IsMethod: false,
6322 IsResolver: false,
6323 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6324 return nil, errors.New("field of type String does not have child fields")
6325 },
6326 }
6327 return fc, nil
6328 }
6329
6330 func (ec *executionContext) _MapStringInterfaceType_b(ctx context.Context, field graphql.CollectedField, obj map[string]interface{}) (ret graphql.Marshaler) {
6331 fc, err := ec.fieldContext_MapStringInterfaceType_b(ctx, field)
6332 if err != nil {
6333 return graphql.Null
6334 }
6335 ctx = graphql.WithFieldContext(ctx, fc)
6336 defer func() {
6337 if r := recover(); r != nil {
6338 ec.Error(ctx, ec.Recover(ctx, r))
6339 ret = graphql.Null
6340 }
6341 }()
6342 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6343 ctx = rctx
6344 switch v := obj["b"].(type) {
6345 case *int:
6346 return v, nil
6347 case int:
6348 return &v, nil
6349 case nil:
6350 return (*int)(nil), nil
6351 default:
6352 return nil, fmt.Errorf("unexpected type %T for field %s", v, "b")
6353 }
6354 })
6355
6356 if resTmp == nil {
6357 return graphql.Null
6358 }
6359 res := resTmp.(*int)
6360 fc.Result = res
6361 return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
6362 }
6363
6364 func (ec *executionContext) fieldContext_MapStringInterfaceType_b(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6365 fc = &graphql.FieldContext{
6366 Object: "MapStringInterfaceType",
6367 Field: field,
6368 IsMethod: false,
6369 IsResolver: false,
6370 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6371 return nil, errors.New("field of type Int does not have child fields")
6372 },
6373 }
6374 return fc, nil
6375 }
6376
6377 func (ec *executionContext) _MapStringInterfaceType_c(ctx context.Context, field graphql.CollectedField, obj map[string]interface{}) (ret graphql.Marshaler) {
6378 fc, err := ec.fieldContext_MapStringInterfaceType_c(ctx, field)
6379 if err != nil {
6380 return graphql.Null
6381 }
6382 ctx = graphql.WithFieldContext(ctx, fc)
6383 defer func() {
6384 if r := recover(); r != nil {
6385 ec.Error(ctx, ec.Recover(ctx, r))
6386 ret = graphql.Null
6387 }
6388 }()
6389 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6390 ctx = rctx
6391 switch v := obj["c"].(type) {
6392 case *CustomScalar:
6393 return v, nil
6394 case CustomScalar:
6395 return &v, nil
6396 case nil:
6397 return (*CustomScalar)(nil), nil
6398 default:
6399 return nil, fmt.Errorf("unexpected type %T for field %s", v, "c")
6400 }
6401 })
6402
6403 if resTmp == nil {
6404 return graphql.Null
6405 }
6406 res := resTmp.(*CustomScalar)
6407 fc.Result = res
6408 return ec.marshalOCustomScalar2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCustomScalar(ctx, field.Selections, res)
6409 }
6410
6411 func (ec *executionContext) fieldContext_MapStringInterfaceType_c(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6412 fc = &graphql.FieldContext{
6413 Object: "MapStringInterfaceType",
6414 Field: field,
6415 IsMethod: false,
6416 IsResolver: false,
6417 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6418 return nil, errors.New("field of type CustomScalar does not have child fields")
6419 },
6420 }
6421 return fc, nil
6422 }
6423
6424 func (ec *executionContext) _MapStringInterfaceType_nested(ctx context.Context, field graphql.CollectedField, obj map[string]interface{}) (ret graphql.Marshaler) {
6425 fc, err := ec.fieldContext_MapStringInterfaceType_nested(ctx, field)
6426 if err != nil {
6427 return graphql.Null
6428 }
6429 ctx = graphql.WithFieldContext(ctx, fc)
6430 defer func() {
6431 if r := recover(); r != nil {
6432 ec.Error(ctx, ec.Recover(ctx, r))
6433 ret = graphql.Null
6434 }
6435 }()
6436 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6437 ctx = rctx
6438 switch v := obj["nested"].(type) {
6439 case *MapNested:
6440 return v, nil
6441 case MapNested:
6442 return &v, nil
6443 case nil:
6444 return (*MapNested)(nil), nil
6445 default:
6446 return nil, fmt.Errorf("unexpected type %T for field %s", v, "nested")
6447 }
6448 })
6449
6450 if resTmp == nil {
6451 return graphql.Null
6452 }
6453 res := resTmp.(*MapNested)
6454 fc.Result = res
6455 return ec.marshalOMapNested2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐMapNested(ctx, field.Selections, res)
6456 }
6457
6458 func (ec *executionContext) fieldContext_MapStringInterfaceType_nested(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6459 fc = &graphql.FieldContext{
6460 Object: "MapStringInterfaceType",
6461 Field: field,
6462 IsMethod: false,
6463 IsResolver: false,
6464 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6465 switch field.Name {
6466 case "value":
6467 return ec.fieldContext_MapNested_value(ctx, field)
6468 }
6469 return nil, fmt.Errorf("no field named %q was found under type MapNested", field.Name)
6470 },
6471 }
6472 return fc, nil
6473 }
6474
6475 func (ec *executionContext) _ModelMethods_resolverField(ctx context.Context, field graphql.CollectedField, obj *ModelMethods) (ret graphql.Marshaler) {
6476 fc, err := ec.fieldContext_ModelMethods_resolverField(ctx, field)
6477 if err != nil {
6478 return graphql.Null
6479 }
6480 ctx = graphql.WithFieldContext(ctx, fc)
6481 defer func() {
6482 if r := recover(); r != nil {
6483 ec.Error(ctx, ec.Recover(ctx, r))
6484 ret = graphql.Null
6485 }
6486 }()
6487 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6488 ctx = rctx
6489 return ec.resolvers.ModelMethods().ResolverField(rctx, obj)
6490 })
6491
6492 if resTmp == nil {
6493 if !graphql.HasFieldError(ctx, fc) {
6494 ec.Errorf(ctx, "must not be null")
6495 }
6496 return graphql.Null
6497 }
6498 res := resTmp.(bool)
6499 fc.Result = res
6500 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
6501 }
6502
6503 func (ec *executionContext) fieldContext_ModelMethods_resolverField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6504 fc = &graphql.FieldContext{
6505 Object: "ModelMethods",
6506 Field: field,
6507 IsMethod: true,
6508 IsResolver: true,
6509 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6510 return nil, errors.New("field of type Boolean does not have child fields")
6511 },
6512 }
6513 return fc, nil
6514 }
6515
6516 func (ec *executionContext) _ModelMethods_noContext(ctx context.Context, field graphql.CollectedField, obj *ModelMethods) (ret graphql.Marshaler) {
6517 fc, err := ec.fieldContext_ModelMethods_noContext(ctx, field)
6518 if err != nil {
6519 return graphql.Null
6520 }
6521 ctx = graphql.WithFieldContext(ctx, fc)
6522 defer func() {
6523 if r := recover(); r != nil {
6524 ec.Error(ctx, ec.Recover(ctx, r))
6525 ret = graphql.Null
6526 }
6527 }()
6528 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6529 ctx = rctx
6530 return obj.NoContext(), nil
6531 })
6532
6533 if resTmp == nil {
6534 if !graphql.HasFieldError(ctx, fc) {
6535 ec.Errorf(ctx, "must not be null")
6536 }
6537 return graphql.Null
6538 }
6539 res := resTmp.(bool)
6540 fc.Result = res
6541 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
6542 }
6543
6544 func (ec *executionContext) fieldContext_ModelMethods_noContext(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6545 fc = &graphql.FieldContext{
6546 Object: "ModelMethods",
6547 Field: field,
6548 IsMethod: true,
6549 IsResolver: false,
6550 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6551 return nil, errors.New("field of type Boolean does not have child fields")
6552 },
6553 }
6554 return fc, nil
6555 }
6556
6557 func (ec *executionContext) _ModelMethods_withContext(ctx context.Context, field graphql.CollectedField, obj *ModelMethods) (ret graphql.Marshaler) {
6558 fc, err := ec.fieldContext_ModelMethods_withContext(ctx, field)
6559 if err != nil {
6560 return graphql.Null
6561 }
6562 ctx = graphql.WithFieldContext(ctx, fc)
6563 defer func() {
6564 if r := recover(); r != nil {
6565 ec.Error(ctx, ec.Recover(ctx, r))
6566 ret = graphql.Null
6567 }
6568 }()
6569 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6570 ctx = rctx
6571 return obj.WithContext(ctx), nil
6572 })
6573
6574 if resTmp == nil {
6575 if !graphql.HasFieldError(ctx, fc) {
6576 ec.Errorf(ctx, "must not be null")
6577 }
6578 return graphql.Null
6579 }
6580 res := resTmp.(bool)
6581 fc.Result = res
6582 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
6583 }
6584
6585 func (ec *executionContext) fieldContext_ModelMethods_withContext(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6586 fc = &graphql.FieldContext{
6587 Object: "ModelMethods",
6588 Field: field,
6589 IsMethod: true,
6590 IsResolver: false,
6591 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6592 return nil, errors.New("field of type Boolean does not have child fields")
6593 },
6594 }
6595 return fc, nil
6596 }
6597
6598 func (ec *executionContext) _Mutation_defaultInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
6599 fc, err := ec.fieldContext_Mutation_defaultInput(ctx, field)
6600 if err != nil {
6601 return graphql.Null
6602 }
6603 ctx = graphql.WithFieldContext(ctx, fc)
6604 defer func() {
6605 if r := recover(); r != nil {
6606 ec.Error(ctx, ec.Recover(ctx, r))
6607 ret = graphql.Null
6608 }
6609 }()
6610 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6611 ctx = rctx
6612 return ec.resolvers.Mutation().DefaultInput(rctx, fc.Args["input"].(DefaultInput))
6613 })
6614
6615 if resTmp == nil {
6616 if !graphql.HasFieldError(ctx, fc) {
6617 ec.Errorf(ctx, "must not be null")
6618 }
6619 return graphql.Null
6620 }
6621 res := resTmp.(*DefaultParametersMirror)
6622 fc.Result = res
6623 return ec.marshalNDefaultParametersMirror2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐDefaultParametersMirror(ctx, field.Selections, res)
6624 }
6625
6626 func (ec *executionContext) fieldContext_Mutation_defaultInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6627 fc = &graphql.FieldContext{
6628 Object: "Mutation",
6629 Field: field,
6630 IsMethod: true,
6631 IsResolver: true,
6632 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6633 switch field.Name {
6634 case "falsyBoolean":
6635 return ec.fieldContext_DefaultParametersMirror_falsyBoolean(ctx, field)
6636 case "truthyBoolean":
6637 return ec.fieldContext_DefaultParametersMirror_truthyBoolean(ctx, field)
6638 }
6639 return nil, fmt.Errorf("no field named %q was found under type DefaultParametersMirror", field.Name)
6640 },
6641 }
6642 defer func() {
6643 if r := recover(); r != nil {
6644 err = ec.Recover(ctx, r)
6645 ec.Error(ctx, err)
6646 }
6647 }()
6648 ctx = graphql.WithFieldContext(ctx, fc)
6649 if fc.Args, err = ec.field_Mutation_defaultInput_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
6650 ec.Error(ctx, err)
6651 return fc, err
6652 }
6653 return fc, nil
6654 }
6655
6656 func (ec *executionContext) _Mutation_overrideValueViaInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
6657 fc, err := ec.fieldContext_Mutation_overrideValueViaInput(ctx, field)
6658 if err != nil {
6659 return graphql.Null
6660 }
6661 ctx = graphql.WithFieldContext(ctx, fc)
6662 defer func() {
6663 if r := recover(); r != nil {
6664 ec.Error(ctx, ec.Recover(ctx, r))
6665 ret = graphql.Null
6666 }
6667 }()
6668 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6669 ctx = rctx
6670 return ec.resolvers.Mutation().OverrideValueViaInput(rctx, fc.Args["input"].(FieldsOrderInput))
6671 })
6672
6673 if resTmp == nil {
6674 if !graphql.HasFieldError(ctx, fc) {
6675 ec.Errorf(ctx, "must not be null")
6676 }
6677 return graphql.Null
6678 }
6679 res := resTmp.(*FieldsOrderPayload)
6680 fc.Result = res
6681 return ec.marshalNFieldsOrderPayload2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐFieldsOrderPayload(ctx, field.Selections, res)
6682 }
6683
6684 func (ec *executionContext) fieldContext_Mutation_overrideValueViaInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6685 fc = &graphql.FieldContext{
6686 Object: "Mutation",
6687 Field: field,
6688 IsMethod: true,
6689 IsResolver: true,
6690 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6691 switch field.Name {
6692 case "firstFieldValue":
6693 return ec.fieldContext_FieldsOrderPayload_firstFieldValue(ctx, field)
6694 }
6695 return nil, fmt.Errorf("no field named %q was found under type FieldsOrderPayload", field.Name)
6696 },
6697 }
6698 defer func() {
6699 if r := recover(); r != nil {
6700 err = ec.Recover(ctx, r)
6701 ec.Error(ctx, err)
6702 }
6703 }()
6704 ctx = graphql.WithFieldContext(ctx, fc)
6705 if fc.Args, err = ec.field_Mutation_overrideValueViaInput_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
6706 ec.Error(ctx, err)
6707 return fc, err
6708 }
6709 return fc, nil
6710 }
6711
6712 func (ec *executionContext) _Mutation_updateSomething(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
6713 fc, err := ec.fieldContext_Mutation_updateSomething(ctx, field)
6714 if err != nil {
6715 return graphql.Null
6716 }
6717 ctx = graphql.WithFieldContext(ctx, fc)
6718 defer func() {
6719 if r := recover(); r != nil {
6720 ec.Error(ctx, ec.Recover(ctx, r))
6721 ret = graphql.Null
6722 }
6723 }()
6724 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6725 ctx = rctx
6726 return ec.resolvers.Mutation().UpdateSomething(rctx, fc.Args["input"].(SpecialInput))
6727 })
6728
6729 if resTmp == nil {
6730 if !graphql.HasFieldError(ctx, fc) {
6731 ec.Errorf(ctx, "must not be null")
6732 }
6733 return graphql.Null
6734 }
6735 res := resTmp.(string)
6736 fc.Result = res
6737 return ec.marshalNString2string(ctx, field.Selections, res)
6738 }
6739
6740 func (ec *executionContext) fieldContext_Mutation_updateSomething(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6741 fc = &graphql.FieldContext{
6742 Object: "Mutation",
6743 Field: field,
6744 IsMethod: true,
6745 IsResolver: true,
6746 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6747 return nil, errors.New("field of type String does not have child fields")
6748 },
6749 }
6750 defer func() {
6751 if r := recover(); r != nil {
6752 err = ec.Recover(ctx, r)
6753 ec.Error(ctx, err)
6754 }
6755 }()
6756 ctx = graphql.WithFieldContext(ctx, fc)
6757 if fc.Args, err = ec.field_Mutation_updateSomething_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
6758 ec.Error(ctx, err)
6759 return fc, err
6760 }
6761 return fc, nil
6762 }
6763
6764 func (ec *executionContext) _Mutation_updatePtrToPtr(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
6765 fc, err := ec.fieldContext_Mutation_updatePtrToPtr(ctx, field)
6766 if err != nil {
6767 return graphql.Null
6768 }
6769 ctx = graphql.WithFieldContext(ctx, fc)
6770 defer func() {
6771 if r := recover(); r != nil {
6772 ec.Error(ctx, ec.Recover(ctx, r))
6773 ret = graphql.Null
6774 }
6775 }()
6776 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6777 ctx = rctx
6778 return ec.resolvers.Mutation().UpdatePtrToPtr(rctx, fc.Args["input"].(UpdatePtrToPtrOuter))
6779 })
6780
6781 if resTmp == nil {
6782 if !graphql.HasFieldError(ctx, fc) {
6783 ec.Errorf(ctx, "must not be null")
6784 }
6785 return graphql.Null
6786 }
6787 res := resTmp.(*PtrToPtrOuter)
6788 fc.Result = res
6789 return ec.marshalNPtrToPtrOuter2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrOuter(ctx, field.Selections, res)
6790 }
6791
6792 func (ec *executionContext) fieldContext_Mutation_updatePtrToPtr(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6793 fc = &graphql.FieldContext{
6794 Object: "Mutation",
6795 Field: field,
6796 IsMethod: true,
6797 IsResolver: true,
6798 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6799 switch field.Name {
6800 case "name":
6801 return ec.fieldContext_PtrToPtrOuter_name(ctx, field)
6802 case "inner":
6803 return ec.fieldContext_PtrToPtrOuter_inner(ctx, field)
6804 case "stupidInner":
6805 return ec.fieldContext_PtrToPtrOuter_stupidInner(ctx, field)
6806 }
6807 return nil, fmt.Errorf("no field named %q was found under type PtrToPtrOuter", field.Name)
6808 },
6809 }
6810 defer func() {
6811 if r := recover(); r != nil {
6812 err = ec.Recover(ctx, r)
6813 ec.Error(ctx, err)
6814 }
6815 }()
6816 ctx = graphql.WithFieldContext(ctx, fc)
6817 if fc.Args, err = ec.field_Mutation_updatePtrToPtr_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
6818 ec.Error(ctx, err)
6819 return fc, err
6820 }
6821 return fc, nil
6822 }
6823
6824 func (ec *executionContext) _ObjectDirectives_text(ctx context.Context, field graphql.CollectedField, obj *ObjectDirectives) (ret graphql.Marshaler) {
6825 fc, err := ec.fieldContext_ObjectDirectives_text(ctx, field)
6826 if err != nil {
6827 return graphql.Null
6828 }
6829 ctx = graphql.WithFieldContext(ctx, fc)
6830 defer func() {
6831 if r := recover(); r != nil {
6832 ec.Error(ctx, ec.Recover(ctx, r))
6833 ret = graphql.Null
6834 }
6835 }()
6836 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6837 directive0 := func(rctx context.Context) (interface{}, error) {
6838 ctx = rctx
6839 return obj.Text, nil
6840 }
6841 directive1 := func(ctx context.Context) (interface{}, error) {
6842 min, err := ec.unmarshalNInt2int(ctx, 0)
6843 if err != nil {
6844 return nil, err
6845 }
6846 max, err := ec.unmarshalOInt2ᚖint(ctx, 7)
6847 if err != nil {
6848 return nil, err
6849 }
6850 message, err := ec.unmarshalOString2ᚖstring(ctx, "not valid")
6851 if err != nil {
6852 return nil, err
6853 }
6854 if ec.directives.Length == nil {
6855 return nil, errors.New("directive length is not implemented")
6856 }
6857 return ec.directives.Length(ctx, obj, directive0, min, max, message)
6858 }
6859
6860 tmp, err := directive1(rctx)
6861 if err != nil {
6862 return nil, graphql.ErrorOnPath(ctx, err)
6863 }
6864 if tmp == nil {
6865 return nil, nil
6866 }
6867 if data, ok := tmp.(string); ok {
6868 return data, nil
6869 }
6870 return nil, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp)
6871 })
6872
6873 if resTmp == nil {
6874 if !graphql.HasFieldError(ctx, fc) {
6875 ec.Errorf(ctx, "must not be null")
6876 }
6877 return graphql.Null
6878 }
6879 res := resTmp.(string)
6880 fc.Result = res
6881 return ec.marshalNString2string(ctx, field.Selections, res)
6882 }
6883
6884 func (ec *executionContext) fieldContext_ObjectDirectives_text(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6885 fc = &graphql.FieldContext{
6886 Object: "ObjectDirectives",
6887 Field: field,
6888 IsMethod: false,
6889 IsResolver: false,
6890 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6891 return nil, errors.New("field of type String does not have child fields")
6892 },
6893 }
6894 return fc, nil
6895 }
6896
6897 func (ec *executionContext) _ObjectDirectives_nullableText(ctx context.Context, field graphql.CollectedField, obj *ObjectDirectives) (ret graphql.Marshaler) {
6898 fc, err := ec.fieldContext_ObjectDirectives_nullableText(ctx, field)
6899 if err != nil {
6900 return graphql.Null
6901 }
6902 ctx = graphql.WithFieldContext(ctx, fc)
6903 defer func() {
6904 if r := recover(); r != nil {
6905 ec.Error(ctx, ec.Recover(ctx, r))
6906 ret = graphql.Null
6907 }
6908 }()
6909 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6910 directive0 := func(rctx context.Context) (interface{}, error) {
6911 ctx = rctx
6912 return obj.NullableText, nil
6913 }
6914 directive1 := func(ctx context.Context) (interface{}, error) {
6915 if ec.directives.ToNull == nil {
6916 return nil, errors.New("directive toNull is not implemented")
6917 }
6918 return ec.directives.ToNull(ctx, obj, directive0)
6919 }
6920
6921 tmp, err := directive1(rctx)
6922 if err != nil {
6923 return nil, graphql.ErrorOnPath(ctx, err)
6924 }
6925 if tmp == nil {
6926 return nil, nil
6927 }
6928 if data, ok := tmp.(*string); ok {
6929 return data, nil
6930 }
6931 return nil, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp)
6932 })
6933
6934 if resTmp == nil {
6935 return graphql.Null
6936 }
6937 res := resTmp.(*string)
6938 fc.Result = res
6939 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
6940 }
6941
6942 func (ec *executionContext) fieldContext_ObjectDirectives_nullableText(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6943 fc = &graphql.FieldContext{
6944 Object: "ObjectDirectives",
6945 Field: field,
6946 IsMethod: false,
6947 IsResolver: false,
6948 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6949 return nil, errors.New("field of type String does not have child fields")
6950 },
6951 }
6952 return fc, nil
6953 }
6954
6955 func (ec *executionContext) _ObjectDirectives_order(ctx context.Context, field graphql.CollectedField, obj *ObjectDirectives) (ret graphql.Marshaler) {
6956 fc, err := ec.fieldContext_ObjectDirectives_order(ctx, field)
6957 if err != nil {
6958 return graphql.Null
6959 }
6960 ctx = graphql.WithFieldContext(ctx, fc)
6961 defer func() {
6962 if r := recover(); r != nil {
6963 ec.Error(ctx, ec.Recover(ctx, r))
6964 ret = graphql.Null
6965 }
6966 }()
6967 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6968 ctx = rctx
6969 return obj.Order, nil
6970 })
6971
6972 if resTmp == nil {
6973 if !graphql.HasFieldError(ctx, fc) {
6974 ec.Errorf(ctx, "must not be null")
6975 }
6976 return graphql.Null
6977 }
6978 res := resTmp.([]string)
6979 fc.Result = res
6980 return ec.marshalNString2ᚕstringᚄ(ctx, field.Selections, res)
6981 }
6982
6983 func (ec *executionContext) fieldContext_ObjectDirectives_order(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
6984 fc = &graphql.FieldContext{
6985 Object: "ObjectDirectives",
6986 Field: field,
6987 IsMethod: false,
6988 IsResolver: false,
6989 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
6990 return nil, errors.New("field of type String does not have child fields")
6991 },
6992 }
6993 return fc, nil
6994 }
6995
6996 func (ec *executionContext) _ObjectDirectivesWithCustomGoModel_nullableText(ctx context.Context, field graphql.CollectedField, obj *ObjectDirectivesWithCustomGoModel) (ret graphql.Marshaler) {
6997 fc, err := ec.fieldContext_ObjectDirectivesWithCustomGoModel_nullableText(ctx, field)
6998 if err != nil {
6999 return graphql.Null
7000 }
7001 ctx = graphql.WithFieldContext(ctx, fc)
7002 defer func() {
7003 if r := recover(); r != nil {
7004 ec.Error(ctx, ec.Recover(ctx, r))
7005 ret = graphql.Null
7006 }
7007 }()
7008 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7009 directive0 := func(rctx context.Context) (interface{}, error) {
7010 ctx = rctx
7011 return obj.NullableText, nil
7012 }
7013 directive1 := func(ctx context.Context) (interface{}, error) {
7014 if ec.directives.ToNull == nil {
7015 return nil, errors.New("directive toNull is not implemented")
7016 }
7017 return ec.directives.ToNull(ctx, obj, directive0)
7018 }
7019
7020 tmp, err := directive1(rctx)
7021 if err != nil {
7022 return nil, graphql.ErrorOnPath(ctx, err)
7023 }
7024 if tmp == nil {
7025 return nil, nil
7026 }
7027 if data, ok := tmp.(string); ok {
7028 return data, nil
7029 }
7030 return nil, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp)
7031 })
7032
7033 if resTmp == nil {
7034 return graphql.Null
7035 }
7036 res := resTmp.(string)
7037 fc.Result = res
7038 return ec.marshalOString2string(ctx, field.Selections, res)
7039 }
7040
7041 func (ec *executionContext) fieldContext_ObjectDirectivesWithCustomGoModel_nullableText(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7042 fc = &graphql.FieldContext{
7043 Object: "ObjectDirectivesWithCustomGoModel",
7044 Field: field,
7045 IsMethod: false,
7046 IsResolver: false,
7047 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7048 return nil, errors.New("field of type String does not have child fields")
7049 },
7050 }
7051 return fc, nil
7052 }
7053
7054 func (ec *executionContext) _OuterObject_inner(ctx context.Context, field graphql.CollectedField, obj *OuterObject) (ret graphql.Marshaler) {
7055 fc, err := ec.fieldContext_OuterObject_inner(ctx, field)
7056 if err != nil {
7057 return graphql.Null
7058 }
7059 ctx = graphql.WithFieldContext(ctx, fc)
7060 defer func() {
7061 if r := recover(); r != nil {
7062 ec.Error(ctx, ec.Recover(ctx, r))
7063 ret = graphql.Null
7064 }
7065 }()
7066 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7067 ctx = rctx
7068 return obj.Inner, nil
7069 })
7070
7071 if resTmp == nil {
7072 if !graphql.HasFieldError(ctx, fc) {
7073 ec.Errorf(ctx, "must not be null")
7074 }
7075 return graphql.Null
7076 }
7077 res := resTmp.(*InnerObject)
7078 fc.Result = res
7079 return ec.marshalNInnerObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInnerObject(ctx, field.Selections, res)
7080 }
7081
7082 func (ec *executionContext) fieldContext_OuterObject_inner(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7083 fc = &graphql.FieldContext{
7084 Object: "OuterObject",
7085 Field: field,
7086 IsMethod: false,
7087 IsResolver: false,
7088 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7089 switch field.Name {
7090 case "id":
7091 return ec.fieldContext_InnerObject_id(ctx, field)
7092 }
7093 return nil, fmt.Errorf("no field named %q was found under type InnerObject", field.Name)
7094 },
7095 }
7096 return fc, nil
7097 }
7098
7099 func (ec *executionContext) _OverlappingFields_oneFoo(ctx context.Context, field graphql.CollectedField, obj *OverlappingFields) (ret graphql.Marshaler) {
7100 fc, err := ec.fieldContext_OverlappingFields_oneFoo(ctx, field)
7101 if err != nil {
7102 return graphql.Null
7103 }
7104 ctx = graphql.WithFieldContext(ctx, fc)
7105 defer func() {
7106 if r := recover(); r != nil {
7107 ec.Error(ctx, ec.Recover(ctx, r))
7108 ret = graphql.Null
7109 }
7110 }()
7111 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7112 ctx = rctx
7113 return obj.Foo, nil
7114 })
7115
7116 if resTmp == nil {
7117 if !graphql.HasFieldError(ctx, fc) {
7118 ec.Errorf(ctx, "must not be null")
7119 }
7120 return graphql.Null
7121 }
7122 res := resTmp.(int)
7123 fc.Result = res
7124 return ec.marshalNInt2int(ctx, field.Selections, res)
7125 }
7126
7127 func (ec *executionContext) fieldContext_OverlappingFields_oneFoo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7128 fc = &graphql.FieldContext{
7129 Object: "OverlappingFields",
7130 Field: field,
7131 IsMethod: false,
7132 IsResolver: false,
7133 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7134 return nil, errors.New("field of type Int does not have child fields")
7135 },
7136 }
7137 return fc, nil
7138 }
7139
7140 func (ec *executionContext) _OverlappingFields_twoFoo(ctx context.Context, field graphql.CollectedField, obj *OverlappingFields) (ret graphql.Marshaler) {
7141 fc, err := ec.fieldContext_OverlappingFields_twoFoo(ctx, field)
7142 if err != nil {
7143 return graphql.Null
7144 }
7145 ctx = graphql.WithFieldContext(ctx, fc)
7146 defer func() {
7147 if r := recover(); r != nil {
7148 ec.Error(ctx, ec.Recover(ctx, r))
7149 ret = graphql.Null
7150 }
7151 }()
7152 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7153 ctx = rctx
7154 return obj.Foo, nil
7155 })
7156
7157 if resTmp == nil {
7158 if !graphql.HasFieldError(ctx, fc) {
7159 ec.Errorf(ctx, "must not be null")
7160 }
7161 return graphql.Null
7162 }
7163 res := resTmp.(int)
7164 fc.Result = res
7165 return ec.marshalNInt2int(ctx, field.Selections, res)
7166 }
7167
7168 func (ec *executionContext) fieldContext_OverlappingFields_twoFoo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7169 fc = &graphql.FieldContext{
7170 Object: "OverlappingFields",
7171 Field: field,
7172 IsMethod: false,
7173 IsResolver: false,
7174 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7175 return nil, errors.New("field of type Int does not have child fields")
7176 },
7177 }
7178 return fc, nil
7179 }
7180
7181 func (ec *executionContext) _OverlappingFields_oldFoo(ctx context.Context, field graphql.CollectedField, obj *OverlappingFields) (ret graphql.Marshaler) {
7182 fc, err := ec.fieldContext_OverlappingFields_oldFoo(ctx, field)
7183 if err != nil {
7184 return graphql.Null
7185 }
7186 ctx = graphql.WithFieldContext(ctx, fc)
7187 defer func() {
7188 if r := recover(); r != nil {
7189 ec.Error(ctx, ec.Recover(ctx, r))
7190 ret = graphql.Null
7191 }
7192 }()
7193 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7194 ctx = rctx
7195 return ec.resolvers.OverlappingFields().OldFoo(rctx, obj)
7196 })
7197
7198 if resTmp == nil {
7199 if !graphql.HasFieldError(ctx, fc) {
7200 ec.Errorf(ctx, "must not be null")
7201 }
7202 return graphql.Null
7203 }
7204 res := resTmp.(int)
7205 fc.Result = res
7206 return ec.marshalNInt2int(ctx, field.Selections, res)
7207 }
7208
7209 func (ec *executionContext) fieldContext_OverlappingFields_oldFoo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7210 fc = &graphql.FieldContext{
7211 Object: "OverlappingFields",
7212 Field: field,
7213 IsMethod: true,
7214 IsResolver: true,
7215 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7216 return nil, errors.New("field of type Int does not have child fields")
7217 },
7218 }
7219 return fc, nil
7220 }
7221
7222 func (ec *executionContext) _OverlappingFields_newFoo(ctx context.Context, field graphql.CollectedField, obj *OverlappingFields) (ret graphql.Marshaler) {
7223 fc, err := ec.fieldContext_OverlappingFields_newFoo(ctx, field)
7224 if err != nil {
7225 return graphql.Null
7226 }
7227 ctx = graphql.WithFieldContext(ctx, fc)
7228 defer func() {
7229 if r := recover(); r != nil {
7230 ec.Error(ctx, ec.Recover(ctx, r))
7231 ret = graphql.Null
7232 }
7233 }()
7234 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7235 ctx = rctx
7236 return obj.NewFoo, nil
7237 })
7238
7239 if resTmp == nil {
7240 if !graphql.HasFieldError(ctx, fc) {
7241 ec.Errorf(ctx, "must not be null")
7242 }
7243 return graphql.Null
7244 }
7245 res := resTmp.(int)
7246 fc.Result = res
7247 return ec.marshalNInt2int(ctx, field.Selections, res)
7248 }
7249
7250 func (ec *executionContext) fieldContext_OverlappingFields_newFoo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7251 fc = &graphql.FieldContext{
7252 Object: "OverlappingFields",
7253 Field: field,
7254 IsMethod: false,
7255 IsResolver: false,
7256 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7257 return nil, errors.New("field of type Int does not have child fields")
7258 },
7259 }
7260 return fc, nil
7261 }
7262
7263 func (ec *executionContext) _OverlappingFields_new_foo(ctx context.Context, field graphql.CollectedField, obj *OverlappingFields) (ret graphql.Marshaler) {
7264 fc, err := ec.fieldContext_OverlappingFields_new_foo(ctx, field)
7265 if err != nil {
7266 return graphql.Null
7267 }
7268 ctx = graphql.WithFieldContext(ctx, fc)
7269 defer func() {
7270 if r := recover(); r != nil {
7271 ec.Error(ctx, ec.Recover(ctx, r))
7272 ret = graphql.Null
7273 }
7274 }()
7275 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7276 ctx = rctx
7277 return obj.NewFoo, nil
7278 })
7279
7280 if resTmp == nil {
7281 if !graphql.HasFieldError(ctx, fc) {
7282 ec.Errorf(ctx, "must not be null")
7283 }
7284 return graphql.Null
7285 }
7286 res := resTmp.(int)
7287 fc.Result = res
7288 return ec.marshalNInt2int(ctx, field.Selections, res)
7289 }
7290
7291 func (ec *executionContext) fieldContext_OverlappingFields_new_foo(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7292 fc = &graphql.FieldContext{
7293 Object: "OverlappingFields",
7294 Field: field,
7295 IsMethod: false,
7296 IsResolver: false,
7297 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7298 return nil, errors.New("field of type Int does not have child fields")
7299 },
7300 }
7301 return fc, nil
7302 }
7303
7304 func (ec *executionContext) _Panics_fieldScalarMarshal(ctx context.Context, field graphql.CollectedField, obj *Panics) (ret graphql.Marshaler) {
7305 fc, err := ec.fieldContext_Panics_fieldScalarMarshal(ctx, field)
7306 if err != nil {
7307 return graphql.Null
7308 }
7309 ctx = graphql.WithFieldContext(ctx, fc)
7310 defer func() {
7311 if r := recover(); r != nil {
7312 ec.Error(ctx, ec.Recover(ctx, r))
7313 ret = graphql.Null
7314 }
7315 }()
7316 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7317 ctx = rctx
7318 return ec.resolvers.Panics().FieldScalarMarshal(rctx, obj)
7319 })
7320
7321 if resTmp == nil {
7322 if !graphql.HasFieldError(ctx, fc) {
7323 ec.Errorf(ctx, "must not be null")
7324 }
7325 return graphql.Null
7326 }
7327 res := resTmp.([]MarshalPanic)
7328 fc.Result = res
7329 return ec.marshalNMarshalPanic2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐMarshalPanicᚄ(ctx, field.Selections, res)
7330 }
7331
7332 func (ec *executionContext) fieldContext_Panics_fieldScalarMarshal(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7333 fc = &graphql.FieldContext{
7334 Object: "Panics",
7335 Field: field,
7336 IsMethod: true,
7337 IsResolver: true,
7338 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7339 return nil, errors.New("field of type MarshalPanic does not have child fields")
7340 },
7341 }
7342 return fc, nil
7343 }
7344
7345 func (ec *executionContext) _Panics_fieldFuncMarshal(ctx context.Context, field graphql.CollectedField, obj *Panics) (ret graphql.Marshaler) {
7346 fc, err := ec.fieldContext_Panics_fieldFuncMarshal(ctx, field)
7347 if err != nil {
7348 return graphql.Null
7349 }
7350 ctx = graphql.WithFieldContext(ctx, fc)
7351 defer func() {
7352 if r := recover(); r != nil {
7353 ec.Error(ctx, ec.Recover(ctx, r))
7354 ret = graphql.Null
7355 }
7356 }()
7357 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7358 ctx = rctx
7359 return obj.FieldFuncMarshal(ctx, fc.Args["u"].([]MarshalPanic)), nil
7360 })
7361
7362 if resTmp == nil {
7363 if !graphql.HasFieldError(ctx, fc) {
7364 ec.Errorf(ctx, "must not be null")
7365 }
7366 return graphql.Null
7367 }
7368 res := resTmp.([]MarshalPanic)
7369 fc.Result = res
7370 return ec.marshalNMarshalPanic2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐMarshalPanicᚄ(ctx, field.Selections, res)
7371 }
7372
7373 func (ec *executionContext) fieldContext_Panics_fieldFuncMarshal(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7374 fc = &graphql.FieldContext{
7375 Object: "Panics",
7376 Field: field,
7377 IsMethod: true,
7378 IsResolver: false,
7379 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7380 return nil, errors.New("field of type MarshalPanic does not have child fields")
7381 },
7382 }
7383 defer func() {
7384 if r := recover(); r != nil {
7385 err = ec.Recover(ctx, r)
7386 ec.Error(ctx, err)
7387 }
7388 }()
7389 ctx = graphql.WithFieldContext(ctx, fc)
7390 if fc.Args, err = ec.field_Panics_fieldFuncMarshal_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
7391 ec.Error(ctx, err)
7392 return fc, err
7393 }
7394 return fc, nil
7395 }
7396
7397 func (ec *executionContext) _Panics_argUnmarshal(ctx context.Context, field graphql.CollectedField, obj *Panics) (ret graphql.Marshaler) {
7398 fc, err := ec.fieldContext_Panics_argUnmarshal(ctx, field)
7399 if err != nil {
7400 return graphql.Null
7401 }
7402 ctx = graphql.WithFieldContext(ctx, fc)
7403 defer func() {
7404 if r := recover(); r != nil {
7405 ec.Error(ctx, ec.Recover(ctx, r))
7406 ret = graphql.Null
7407 }
7408 }()
7409 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7410 ctx = rctx
7411 return ec.resolvers.Panics().ArgUnmarshal(rctx, obj, fc.Args["u"].([]MarshalPanic))
7412 })
7413
7414 if resTmp == nil {
7415 if !graphql.HasFieldError(ctx, fc) {
7416 ec.Errorf(ctx, "must not be null")
7417 }
7418 return graphql.Null
7419 }
7420 res := resTmp.(bool)
7421 fc.Result = res
7422 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
7423 }
7424
7425 func (ec *executionContext) fieldContext_Panics_argUnmarshal(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7426 fc = &graphql.FieldContext{
7427 Object: "Panics",
7428 Field: field,
7429 IsMethod: true,
7430 IsResolver: true,
7431 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7432 return nil, errors.New("field of type Boolean does not have child fields")
7433 },
7434 }
7435 defer func() {
7436 if r := recover(); r != nil {
7437 err = ec.Recover(ctx, r)
7438 ec.Error(ctx, err)
7439 }
7440 }()
7441 ctx = graphql.WithFieldContext(ctx, fc)
7442 if fc.Args, err = ec.field_Panics_argUnmarshal_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
7443 ec.Error(ctx, err)
7444 return fc, err
7445 }
7446 return fc, nil
7447 }
7448
7449 func (ec *executionContext) _Pet_id(ctx context.Context, field graphql.CollectedField, obj *Pet) (ret graphql.Marshaler) {
7450 fc, err := ec.fieldContext_Pet_id(ctx, field)
7451 if err != nil {
7452 return graphql.Null
7453 }
7454 ctx = graphql.WithFieldContext(ctx, fc)
7455 defer func() {
7456 if r := recover(); r != nil {
7457 ec.Error(ctx, ec.Recover(ctx, r))
7458 ret = graphql.Null
7459 }
7460 }()
7461 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7462 ctx = rctx
7463 return obj.ID, nil
7464 })
7465
7466 if resTmp == nil {
7467 if !graphql.HasFieldError(ctx, fc) {
7468 ec.Errorf(ctx, "must not be null")
7469 }
7470 return graphql.Null
7471 }
7472 res := resTmp.(int)
7473 fc.Result = res
7474 return ec.marshalNInt2int(ctx, field.Selections, res)
7475 }
7476
7477 func (ec *executionContext) fieldContext_Pet_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7478 fc = &graphql.FieldContext{
7479 Object: "Pet",
7480 Field: field,
7481 IsMethod: false,
7482 IsResolver: false,
7483 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7484 return nil, errors.New("field of type Int does not have child fields")
7485 },
7486 }
7487 return fc, nil
7488 }
7489
7490 func (ec *executionContext) _Pet_friends(ctx context.Context, field graphql.CollectedField, obj *Pet) (ret graphql.Marshaler) {
7491 fc, err := ec.fieldContext_Pet_friends(ctx, field)
7492 if err != nil {
7493 return graphql.Null
7494 }
7495 ctx = graphql.WithFieldContext(ctx, fc)
7496 defer func() {
7497 if r := recover(); r != nil {
7498 ec.Error(ctx, ec.Recover(ctx, r))
7499 ret = graphql.Null
7500 }
7501 }()
7502 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7503 ctx = rctx
7504 return ec.resolvers.Pet().Friends(rctx, obj, fc.Args["limit"].(*int))
7505 })
7506
7507 if resTmp == nil {
7508 return graphql.Null
7509 }
7510 res := resTmp.([]*Pet)
7511 fc.Result = res
7512 return ec.marshalOPet2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPetᚄ(ctx, field.Selections, res)
7513 }
7514
7515 func (ec *executionContext) fieldContext_Pet_friends(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7516 fc = &graphql.FieldContext{
7517 Object: "Pet",
7518 Field: field,
7519 IsMethod: true,
7520 IsResolver: true,
7521 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7522 switch field.Name {
7523 case "id":
7524 return ec.fieldContext_Pet_id(ctx, field)
7525 case "friends":
7526 return ec.fieldContext_Pet_friends(ctx, field)
7527 }
7528 return nil, fmt.Errorf("no field named %q was found under type Pet", field.Name)
7529 },
7530 }
7531 defer func() {
7532 if r := recover(); r != nil {
7533 err = ec.Recover(ctx, r)
7534 ec.Error(ctx, err)
7535 }
7536 }()
7537 ctx = graphql.WithFieldContext(ctx, fc)
7538 if fc.Args, err = ec.field_Pet_friends_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
7539 ec.Error(ctx, err)
7540 return fc, err
7541 }
7542 return fc, nil
7543 }
7544
7545 func (ec *executionContext) _Primitive_value(ctx context.Context, field graphql.CollectedField, obj *Primitive) (ret graphql.Marshaler) {
7546 fc, err := ec.fieldContext_Primitive_value(ctx, field)
7547 if err != nil {
7548 return graphql.Null
7549 }
7550 ctx = graphql.WithFieldContext(ctx, fc)
7551 defer func() {
7552 if r := recover(); r != nil {
7553 ec.Error(ctx, ec.Recover(ctx, r))
7554 ret = graphql.Null
7555 }
7556 }()
7557 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7558 ctx = rctx
7559 return ec.resolvers.Primitive().Value(rctx, obj)
7560 })
7561
7562 if resTmp == nil {
7563 if !graphql.HasFieldError(ctx, fc) {
7564 ec.Errorf(ctx, "must not be null")
7565 }
7566 return graphql.Null
7567 }
7568 res := resTmp.(int)
7569 fc.Result = res
7570 return ec.marshalNInt2int(ctx, field.Selections, res)
7571 }
7572
7573 func (ec *executionContext) fieldContext_Primitive_value(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7574 fc = &graphql.FieldContext{
7575 Object: "Primitive",
7576 Field: field,
7577 IsMethod: true,
7578 IsResolver: true,
7579 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7580 return nil, errors.New("field of type Int does not have child fields")
7581 },
7582 }
7583 return fc, nil
7584 }
7585
7586 func (ec *executionContext) _Primitive_squared(ctx context.Context, field graphql.CollectedField, obj *Primitive) (ret graphql.Marshaler) {
7587 fc, err := ec.fieldContext_Primitive_squared(ctx, field)
7588 if err != nil {
7589 return graphql.Null
7590 }
7591 ctx = graphql.WithFieldContext(ctx, fc)
7592 defer func() {
7593 if r := recover(); r != nil {
7594 ec.Error(ctx, ec.Recover(ctx, r))
7595 ret = graphql.Null
7596 }
7597 }()
7598 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7599 ctx = rctx
7600 return obj.Squared(), nil
7601 })
7602
7603 if resTmp == nil {
7604 if !graphql.HasFieldError(ctx, fc) {
7605 ec.Errorf(ctx, "must not be null")
7606 }
7607 return graphql.Null
7608 }
7609 res := resTmp.(int)
7610 fc.Result = res
7611 return ec.marshalNInt2int(ctx, field.Selections, res)
7612 }
7613
7614 func (ec *executionContext) fieldContext_Primitive_squared(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7615 fc = &graphql.FieldContext{
7616 Object: "Primitive",
7617 Field: field,
7618 IsMethod: true,
7619 IsResolver: false,
7620 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7621 return nil, errors.New("field of type Int does not have child fields")
7622 },
7623 }
7624 return fc, nil
7625 }
7626
7627 func (ec *executionContext) _PrimitiveString_value(ctx context.Context, field graphql.CollectedField, obj *PrimitiveString) (ret graphql.Marshaler) {
7628 fc, err := ec.fieldContext_PrimitiveString_value(ctx, field)
7629 if err != nil {
7630 return graphql.Null
7631 }
7632 ctx = graphql.WithFieldContext(ctx, fc)
7633 defer func() {
7634 if r := recover(); r != nil {
7635 ec.Error(ctx, ec.Recover(ctx, r))
7636 ret = graphql.Null
7637 }
7638 }()
7639 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7640 ctx = rctx
7641 return ec.resolvers.PrimitiveString().Value(rctx, obj)
7642 })
7643
7644 if resTmp == nil {
7645 if !graphql.HasFieldError(ctx, fc) {
7646 ec.Errorf(ctx, "must not be null")
7647 }
7648 return graphql.Null
7649 }
7650 res := resTmp.(string)
7651 fc.Result = res
7652 return ec.marshalNString2string(ctx, field.Selections, res)
7653 }
7654
7655 func (ec *executionContext) fieldContext_PrimitiveString_value(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7656 fc = &graphql.FieldContext{
7657 Object: "PrimitiveString",
7658 Field: field,
7659 IsMethod: true,
7660 IsResolver: true,
7661 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7662 return nil, errors.New("field of type String does not have child fields")
7663 },
7664 }
7665 return fc, nil
7666 }
7667
7668 func (ec *executionContext) _PrimitiveString_doubled(ctx context.Context, field graphql.CollectedField, obj *PrimitiveString) (ret graphql.Marshaler) {
7669 fc, err := ec.fieldContext_PrimitiveString_doubled(ctx, field)
7670 if err != nil {
7671 return graphql.Null
7672 }
7673 ctx = graphql.WithFieldContext(ctx, fc)
7674 defer func() {
7675 if r := recover(); r != nil {
7676 ec.Error(ctx, ec.Recover(ctx, r))
7677 ret = graphql.Null
7678 }
7679 }()
7680 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7681 ctx = rctx
7682 return obj.Doubled(), nil
7683 })
7684
7685 if resTmp == nil {
7686 if !graphql.HasFieldError(ctx, fc) {
7687 ec.Errorf(ctx, "must not be null")
7688 }
7689 return graphql.Null
7690 }
7691 res := resTmp.(string)
7692 fc.Result = res
7693 return ec.marshalNString2string(ctx, field.Selections, res)
7694 }
7695
7696 func (ec *executionContext) fieldContext_PrimitiveString_doubled(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7697 fc = &graphql.FieldContext{
7698 Object: "PrimitiveString",
7699 Field: field,
7700 IsMethod: true,
7701 IsResolver: false,
7702 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7703 return nil, errors.New("field of type String does not have child fields")
7704 },
7705 }
7706 return fc, nil
7707 }
7708
7709 func (ec *executionContext) _PrimitiveString_len(ctx context.Context, field graphql.CollectedField, obj *PrimitiveString) (ret graphql.Marshaler) {
7710 fc, err := ec.fieldContext_PrimitiveString_len(ctx, field)
7711 if err != nil {
7712 return graphql.Null
7713 }
7714 ctx = graphql.WithFieldContext(ctx, fc)
7715 defer func() {
7716 if r := recover(); r != nil {
7717 ec.Error(ctx, ec.Recover(ctx, r))
7718 ret = graphql.Null
7719 }
7720 }()
7721 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7722 ctx = rctx
7723 return ec.resolvers.PrimitiveString().Len(rctx, obj)
7724 })
7725
7726 if resTmp == nil {
7727 if !graphql.HasFieldError(ctx, fc) {
7728 ec.Errorf(ctx, "must not be null")
7729 }
7730 return graphql.Null
7731 }
7732 res := resTmp.(int)
7733 fc.Result = res
7734 return ec.marshalNInt2int(ctx, field.Selections, res)
7735 }
7736
7737 func (ec *executionContext) fieldContext_PrimitiveString_len(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7738 fc = &graphql.FieldContext{
7739 Object: "PrimitiveString",
7740 Field: field,
7741 IsMethod: true,
7742 IsResolver: true,
7743 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7744 return nil, errors.New("field of type Int does not have child fields")
7745 },
7746 }
7747 return fc, nil
7748 }
7749
7750 func (ec *executionContext) _PtrToAnyContainer_ptrToAny(ctx context.Context, field graphql.CollectedField, obj *PtrToAnyContainer) (ret graphql.Marshaler) {
7751 fc, err := ec.fieldContext_PtrToAnyContainer_ptrToAny(ctx, field)
7752 if err != nil {
7753 return graphql.Null
7754 }
7755 ctx = graphql.WithFieldContext(ctx, fc)
7756 defer func() {
7757 if r := recover(); r != nil {
7758 ec.Error(ctx, ec.Recover(ctx, r))
7759 ret = graphql.Null
7760 }
7761 }()
7762 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7763 ctx = rctx
7764 return obj.PtrToAny, nil
7765 })
7766
7767 if resTmp == nil {
7768 return graphql.Null
7769 }
7770 res := resTmp.(*any)
7771 fc.Result = res
7772 return ec.marshalOAny2ᚖinterface(ctx, field.Selections, res)
7773 }
7774
7775 func (ec *executionContext) fieldContext_PtrToAnyContainer_ptrToAny(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7776 fc = &graphql.FieldContext{
7777 Object: "PtrToAnyContainer",
7778 Field: field,
7779 IsMethod: false,
7780 IsResolver: false,
7781 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7782 return nil, errors.New("field of type Any does not have child fields")
7783 },
7784 }
7785 return fc, nil
7786 }
7787
7788 func (ec *executionContext) _PtrToAnyContainer_binding(ctx context.Context, field graphql.CollectedField, obj *PtrToAnyContainer) (ret graphql.Marshaler) {
7789 fc, err := ec.fieldContext_PtrToAnyContainer_binding(ctx, field)
7790 if err != nil {
7791 return graphql.Null
7792 }
7793 ctx = graphql.WithFieldContext(ctx, fc)
7794 defer func() {
7795 if r := recover(); r != nil {
7796 ec.Error(ctx, ec.Recover(ctx, r))
7797 ret = graphql.Null
7798 }
7799 }()
7800 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7801 ctx = rctx
7802 return obj.Binding(), nil
7803 })
7804
7805 if resTmp == nil {
7806 return graphql.Null
7807 }
7808 res := resTmp.(*any)
7809 fc.Result = res
7810 return ec.marshalOAny2ᚖinterface(ctx, field.Selections, res)
7811 }
7812
7813 func (ec *executionContext) fieldContext_PtrToAnyContainer_binding(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7814 fc = &graphql.FieldContext{
7815 Object: "PtrToAnyContainer",
7816 Field: field,
7817 IsMethod: true,
7818 IsResolver: false,
7819 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7820 return nil, errors.New("field of type Any does not have child fields")
7821 },
7822 }
7823 return fc, nil
7824 }
7825
7826 func (ec *executionContext) _PtrToPtrInner_key(ctx context.Context, field graphql.CollectedField, obj *PtrToPtrInner) (ret graphql.Marshaler) {
7827 fc, err := ec.fieldContext_PtrToPtrInner_key(ctx, field)
7828 if err != nil {
7829 return graphql.Null
7830 }
7831 ctx = graphql.WithFieldContext(ctx, fc)
7832 defer func() {
7833 if r := recover(); r != nil {
7834 ec.Error(ctx, ec.Recover(ctx, r))
7835 ret = graphql.Null
7836 }
7837 }()
7838 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7839 ctx = rctx
7840 return obj.Key, nil
7841 })
7842
7843 if resTmp == nil {
7844 if !graphql.HasFieldError(ctx, fc) {
7845 ec.Errorf(ctx, "must not be null")
7846 }
7847 return graphql.Null
7848 }
7849 res := resTmp.(string)
7850 fc.Result = res
7851 return ec.marshalNString2string(ctx, field.Selections, res)
7852 }
7853
7854 func (ec *executionContext) fieldContext_PtrToPtrInner_key(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7855 fc = &graphql.FieldContext{
7856 Object: "PtrToPtrInner",
7857 Field: field,
7858 IsMethod: false,
7859 IsResolver: false,
7860 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7861 return nil, errors.New("field of type String does not have child fields")
7862 },
7863 }
7864 return fc, nil
7865 }
7866
7867 func (ec *executionContext) _PtrToPtrInner_value(ctx context.Context, field graphql.CollectedField, obj *PtrToPtrInner) (ret graphql.Marshaler) {
7868 fc, err := ec.fieldContext_PtrToPtrInner_value(ctx, field)
7869 if err != nil {
7870 return graphql.Null
7871 }
7872 ctx = graphql.WithFieldContext(ctx, fc)
7873 defer func() {
7874 if r := recover(); r != nil {
7875 ec.Error(ctx, ec.Recover(ctx, r))
7876 ret = graphql.Null
7877 }
7878 }()
7879 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7880 ctx = rctx
7881 return obj.Value, nil
7882 })
7883
7884 if resTmp == nil {
7885 if !graphql.HasFieldError(ctx, fc) {
7886 ec.Errorf(ctx, "must not be null")
7887 }
7888 return graphql.Null
7889 }
7890 res := resTmp.(string)
7891 fc.Result = res
7892 return ec.marshalNString2string(ctx, field.Selections, res)
7893 }
7894
7895 func (ec *executionContext) fieldContext_PtrToPtrInner_value(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7896 fc = &graphql.FieldContext{
7897 Object: "PtrToPtrInner",
7898 Field: field,
7899 IsMethod: false,
7900 IsResolver: false,
7901 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7902 return nil, errors.New("field of type String does not have child fields")
7903 },
7904 }
7905 return fc, nil
7906 }
7907
7908 func (ec *executionContext) _PtrToPtrOuter_name(ctx context.Context, field graphql.CollectedField, obj *PtrToPtrOuter) (ret graphql.Marshaler) {
7909 fc, err := ec.fieldContext_PtrToPtrOuter_name(ctx, field)
7910 if err != nil {
7911 return graphql.Null
7912 }
7913 ctx = graphql.WithFieldContext(ctx, fc)
7914 defer func() {
7915 if r := recover(); r != nil {
7916 ec.Error(ctx, ec.Recover(ctx, r))
7917 ret = graphql.Null
7918 }
7919 }()
7920 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7921 ctx = rctx
7922 return obj.Name, nil
7923 })
7924
7925 if resTmp == nil {
7926 if !graphql.HasFieldError(ctx, fc) {
7927 ec.Errorf(ctx, "must not be null")
7928 }
7929 return graphql.Null
7930 }
7931 res := resTmp.(string)
7932 fc.Result = res
7933 return ec.marshalNString2string(ctx, field.Selections, res)
7934 }
7935
7936 func (ec *executionContext) fieldContext_PtrToPtrOuter_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7937 fc = &graphql.FieldContext{
7938 Object: "PtrToPtrOuter",
7939 Field: field,
7940 IsMethod: false,
7941 IsResolver: false,
7942 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7943 return nil, errors.New("field of type String does not have child fields")
7944 },
7945 }
7946 return fc, nil
7947 }
7948
7949 func (ec *executionContext) _PtrToPtrOuter_inner(ctx context.Context, field graphql.CollectedField, obj *PtrToPtrOuter) (ret graphql.Marshaler) {
7950 fc, err := ec.fieldContext_PtrToPtrOuter_inner(ctx, field)
7951 if err != nil {
7952 return graphql.Null
7953 }
7954 ctx = graphql.WithFieldContext(ctx, fc)
7955 defer func() {
7956 if r := recover(); r != nil {
7957 ec.Error(ctx, ec.Recover(ctx, r))
7958 ret = graphql.Null
7959 }
7960 }()
7961 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7962 ctx = rctx
7963 return obj.Inner, nil
7964 })
7965
7966 if resTmp == nil {
7967 return graphql.Null
7968 }
7969 res := resTmp.(*PtrToPtrInner)
7970 fc.Result = res
7971 return ec.marshalOPtrToPtrInner2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrInner(ctx, field.Selections, res)
7972 }
7973
7974 func (ec *executionContext) fieldContext_PtrToPtrOuter_inner(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
7975 fc = &graphql.FieldContext{
7976 Object: "PtrToPtrOuter",
7977 Field: field,
7978 IsMethod: false,
7979 IsResolver: false,
7980 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
7981 switch field.Name {
7982 case "key":
7983 return ec.fieldContext_PtrToPtrInner_key(ctx, field)
7984 case "value":
7985 return ec.fieldContext_PtrToPtrInner_value(ctx, field)
7986 }
7987 return nil, fmt.Errorf("no field named %q was found under type PtrToPtrInner", field.Name)
7988 },
7989 }
7990 return fc, nil
7991 }
7992
7993 func (ec *executionContext) _PtrToPtrOuter_stupidInner(ctx context.Context, field graphql.CollectedField, obj *PtrToPtrOuter) (ret graphql.Marshaler) {
7994 fc, err := ec.fieldContext_PtrToPtrOuter_stupidInner(ctx, field)
7995 if err != nil {
7996 return graphql.Null
7997 }
7998 ctx = graphql.WithFieldContext(ctx, fc)
7999 defer func() {
8000 if r := recover(); r != nil {
8001 ec.Error(ctx, ec.Recover(ctx, r))
8002 ret = graphql.Null
8003 }
8004 }()
8005 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8006 ctx = rctx
8007 return obj.StupidInner, nil
8008 })
8009
8010 if resTmp == nil {
8011 return graphql.Null
8012 }
8013 res := resTmp.(*******PtrToPtrInner)
8014 fc.Result = res
8015 return ec.marshalOPtrToPtrInner2ᚖᚖᚖᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrInner(ctx, field.Selections, res)
8016 }
8017
8018 func (ec *executionContext) fieldContext_PtrToPtrOuter_stupidInner(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8019 fc = &graphql.FieldContext{
8020 Object: "PtrToPtrOuter",
8021 Field: field,
8022 IsMethod: false,
8023 IsResolver: false,
8024 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8025 switch field.Name {
8026 case "key":
8027 return ec.fieldContext_PtrToPtrInner_key(ctx, field)
8028 case "value":
8029 return ec.fieldContext_PtrToPtrInner_value(ctx, field)
8030 }
8031 return nil, fmt.Errorf("no field named %q was found under type PtrToPtrInner", field.Name)
8032 },
8033 }
8034 return fc, nil
8035 }
8036
8037 func (ec *executionContext) _PtrToSliceContainer_ptrToSlice(ctx context.Context, field graphql.CollectedField, obj *PtrToSliceContainer) (ret graphql.Marshaler) {
8038 fc, err := ec.fieldContext_PtrToSliceContainer_ptrToSlice(ctx, field)
8039 if err != nil {
8040 return graphql.Null
8041 }
8042 ctx = graphql.WithFieldContext(ctx, fc)
8043 defer func() {
8044 if r := recover(); r != nil {
8045 ec.Error(ctx, ec.Recover(ctx, r))
8046 ret = graphql.Null
8047 }
8048 }()
8049 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8050 ctx = rctx
8051 return obj.PtrToSlice, nil
8052 })
8053
8054 if resTmp == nil {
8055 return graphql.Null
8056 }
8057 res := resTmp.(*[]string)
8058 fc.Result = res
8059 return ec.marshalOString2ᚖᚕstringᚄ(ctx, field.Selections, res)
8060 }
8061
8062 func (ec *executionContext) fieldContext_PtrToSliceContainer_ptrToSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8063 fc = &graphql.FieldContext{
8064 Object: "PtrToSliceContainer",
8065 Field: field,
8066 IsMethod: false,
8067 IsResolver: false,
8068 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8069 return nil, errors.New("field of type String does not have child fields")
8070 },
8071 }
8072 return fc, nil
8073 }
8074
8075 func (ec *executionContext) _Query_invalidIdentifier(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8076 fc, err := ec.fieldContext_Query_invalidIdentifier(ctx, field)
8077 if err != nil {
8078 return graphql.Null
8079 }
8080 ctx = graphql.WithFieldContext(ctx, fc)
8081 defer func() {
8082 if r := recover(); r != nil {
8083 ec.Error(ctx, ec.Recover(ctx, r))
8084 ret = graphql.Null
8085 }
8086 }()
8087 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8088 ctx = rctx
8089 return ec.resolvers.Query().InvalidIdentifier(rctx)
8090 })
8091
8092 if resTmp == nil {
8093 return graphql.Null
8094 }
8095 res := resTmp.(*invalid_packagename.InvalidIdentifier)
8096 fc.Result = res
8097 return ec.marshalOInvalidIdentifier2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚋinvalidᚑpackagenameᚐInvalidIdentifier(ctx, field.Selections, res)
8098 }
8099
8100 func (ec *executionContext) fieldContext_Query_invalidIdentifier(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8101 fc = &graphql.FieldContext{
8102 Object: "Query",
8103 Field: field,
8104 IsMethod: true,
8105 IsResolver: true,
8106 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8107 switch field.Name {
8108 case "id":
8109 return ec.fieldContext_InvalidIdentifier_id(ctx, field)
8110 }
8111 return nil, fmt.Errorf("no field named %q was found under type InvalidIdentifier", field.Name)
8112 },
8113 }
8114 return fc, nil
8115 }
8116
8117 func (ec *executionContext) _Query_collision(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8118 fc, err := ec.fieldContext_Query_collision(ctx, field)
8119 if err != nil {
8120 return graphql.Null
8121 }
8122 ctx = graphql.WithFieldContext(ctx, fc)
8123 defer func() {
8124 if r := recover(); r != nil {
8125 ec.Error(ctx, ec.Recover(ctx, r))
8126 ret = graphql.Null
8127 }
8128 }()
8129 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8130 ctx = rctx
8131 return ec.resolvers.Query().Collision(rctx)
8132 })
8133
8134 if resTmp == nil {
8135 return graphql.Null
8136 }
8137 res := resTmp.(*introspection1.It)
8138 fc.Result = res
8139 return ec.marshalOIt2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚋintrospectionᚐIt(ctx, field.Selections, res)
8140 }
8141
8142 func (ec *executionContext) fieldContext_Query_collision(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8143 fc = &graphql.FieldContext{
8144 Object: "Query",
8145 Field: field,
8146 IsMethod: true,
8147 IsResolver: true,
8148 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8149 switch field.Name {
8150 case "id":
8151 return ec.fieldContext_It_id(ctx, field)
8152 }
8153 return nil, fmt.Errorf("no field named %q was found under type It", field.Name)
8154 },
8155 }
8156 return fc, nil
8157 }
8158
8159 func (ec *executionContext) _Query_mapInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8160 fc, err := ec.fieldContext_Query_mapInput(ctx, field)
8161 if err != nil {
8162 return graphql.Null
8163 }
8164 ctx = graphql.WithFieldContext(ctx, fc)
8165 defer func() {
8166 if r := recover(); r != nil {
8167 ec.Error(ctx, ec.Recover(ctx, r))
8168 ret = graphql.Null
8169 }
8170 }()
8171 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8172 ctx = rctx
8173 return ec.resolvers.Query().MapInput(rctx, fc.Args["input"].(map[string]interface{}))
8174 })
8175
8176 if resTmp == nil {
8177 return graphql.Null
8178 }
8179 res := resTmp.(*bool)
8180 fc.Result = res
8181 return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)
8182 }
8183
8184 func (ec *executionContext) fieldContext_Query_mapInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8185 fc = &graphql.FieldContext{
8186 Object: "Query",
8187 Field: field,
8188 IsMethod: true,
8189 IsResolver: true,
8190 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8191 return nil, errors.New("field of type Boolean does not have child fields")
8192 },
8193 }
8194 defer func() {
8195 if r := recover(); r != nil {
8196 err = ec.Recover(ctx, r)
8197 ec.Error(ctx, err)
8198 }
8199 }()
8200 ctx = graphql.WithFieldContext(ctx, fc)
8201 if fc.Args, err = ec.field_Query_mapInput_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
8202 ec.Error(ctx, err)
8203 return fc, err
8204 }
8205 return fc, nil
8206 }
8207
8208 func (ec *executionContext) _Query_recursive(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8209 fc, err := ec.fieldContext_Query_recursive(ctx, field)
8210 if err != nil {
8211 return graphql.Null
8212 }
8213 ctx = graphql.WithFieldContext(ctx, fc)
8214 defer func() {
8215 if r := recover(); r != nil {
8216 ec.Error(ctx, ec.Recover(ctx, r))
8217 ret = graphql.Null
8218 }
8219 }()
8220 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8221 ctx = rctx
8222 return ec.resolvers.Query().Recursive(rctx, fc.Args["input"].(*RecursiveInputSlice))
8223 })
8224
8225 if resTmp == nil {
8226 return graphql.Null
8227 }
8228 res := resTmp.(*bool)
8229 fc.Result = res
8230 return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)
8231 }
8232
8233 func (ec *executionContext) fieldContext_Query_recursive(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8234 fc = &graphql.FieldContext{
8235 Object: "Query",
8236 Field: field,
8237 IsMethod: true,
8238 IsResolver: true,
8239 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8240 return nil, errors.New("field of type Boolean does not have child fields")
8241 },
8242 }
8243 defer func() {
8244 if r := recover(); r != nil {
8245 err = ec.Recover(ctx, r)
8246 ec.Error(ctx, err)
8247 }
8248 }()
8249 ctx = graphql.WithFieldContext(ctx, fc)
8250 if fc.Args, err = ec.field_Query_recursive_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
8251 ec.Error(ctx, err)
8252 return fc, err
8253 }
8254 return fc, nil
8255 }
8256
8257 func (ec *executionContext) _Query_nestedInputs(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8258 fc, err := ec.fieldContext_Query_nestedInputs(ctx, field)
8259 if err != nil {
8260 return graphql.Null
8261 }
8262 ctx = graphql.WithFieldContext(ctx, fc)
8263 defer func() {
8264 if r := recover(); r != nil {
8265 ec.Error(ctx, ec.Recover(ctx, r))
8266 ret = graphql.Null
8267 }
8268 }()
8269 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8270 ctx = rctx
8271 return ec.resolvers.Query().NestedInputs(rctx, fc.Args["input"].([][]*OuterInput))
8272 })
8273
8274 if resTmp == nil {
8275 return graphql.Null
8276 }
8277 res := resTmp.(*bool)
8278 fc.Result = res
8279 return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)
8280 }
8281
8282 func (ec *executionContext) fieldContext_Query_nestedInputs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8283 fc = &graphql.FieldContext{
8284 Object: "Query",
8285 Field: field,
8286 IsMethod: true,
8287 IsResolver: true,
8288 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8289 return nil, errors.New("field of type Boolean does not have child fields")
8290 },
8291 }
8292 defer func() {
8293 if r := recover(); r != nil {
8294 err = ec.Recover(ctx, r)
8295 ec.Error(ctx, err)
8296 }
8297 }()
8298 ctx = graphql.WithFieldContext(ctx, fc)
8299 if fc.Args, err = ec.field_Query_nestedInputs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
8300 ec.Error(ctx, err)
8301 return fc, err
8302 }
8303 return fc, nil
8304 }
8305
8306 func (ec *executionContext) _Query_nestedOutputs(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8307 fc, err := ec.fieldContext_Query_nestedOutputs(ctx, field)
8308 if err != nil {
8309 return graphql.Null
8310 }
8311 ctx = graphql.WithFieldContext(ctx, fc)
8312 defer func() {
8313 if r := recover(); r != nil {
8314 ec.Error(ctx, ec.Recover(ctx, r))
8315 ret = graphql.Null
8316 }
8317 }()
8318 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8319 ctx = rctx
8320 return ec.resolvers.Query().NestedOutputs(rctx)
8321 })
8322
8323 if resTmp == nil {
8324 return graphql.Null
8325 }
8326 res := resTmp.([][]*OuterObject)
8327 fc.Result = res
8328 return ec.marshalOOuterObject2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOuterObject(ctx, field.Selections, res)
8329 }
8330
8331 func (ec *executionContext) fieldContext_Query_nestedOutputs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8332 fc = &graphql.FieldContext{
8333 Object: "Query",
8334 Field: field,
8335 IsMethod: true,
8336 IsResolver: true,
8337 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8338 switch field.Name {
8339 case "inner":
8340 return ec.fieldContext_OuterObject_inner(ctx, field)
8341 }
8342 return nil, fmt.Errorf("no field named %q was found under type OuterObject", field.Name)
8343 },
8344 }
8345 return fc, nil
8346 }
8347
8348 func (ec *executionContext) _Query_modelMethods(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8349 fc, err := ec.fieldContext_Query_modelMethods(ctx, field)
8350 if err != nil {
8351 return graphql.Null
8352 }
8353 ctx = graphql.WithFieldContext(ctx, fc)
8354 defer func() {
8355 if r := recover(); r != nil {
8356 ec.Error(ctx, ec.Recover(ctx, r))
8357 ret = graphql.Null
8358 }
8359 }()
8360 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8361 ctx = rctx
8362 return ec.resolvers.Query().ModelMethods(rctx)
8363 })
8364
8365 if resTmp == nil {
8366 return graphql.Null
8367 }
8368 res := resTmp.(*ModelMethods)
8369 fc.Result = res
8370 return ec.marshalOModelMethods2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐModelMethods(ctx, field.Selections, res)
8371 }
8372
8373 func (ec *executionContext) fieldContext_Query_modelMethods(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8374 fc = &graphql.FieldContext{
8375 Object: "Query",
8376 Field: field,
8377 IsMethod: true,
8378 IsResolver: true,
8379 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8380 switch field.Name {
8381 case "resolverField":
8382 return ec.fieldContext_ModelMethods_resolverField(ctx, field)
8383 case "noContext":
8384 return ec.fieldContext_ModelMethods_noContext(ctx, field)
8385 case "withContext":
8386 return ec.fieldContext_ModelMethods_withContext(ctx, field)
8387 }
8388 return nil, fmt.Errorf("no field named %q was found under type ModelMethods", field.Name)
8389 },
8390 }
8391 return fc, nil
8392 }
8393
8394 func (ec *executionContext) _Query_user(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8395 fc, err := ec.fieldContext_Query_user(ctx, field)
8396 if err != nil {
8397 return graphql.Null
8398 }
8399 ctx = graphql.WithFieldContext(ctx, fc)
8400 defer func() {
8401 if r := recover(); r != nil {
8402 ec.Error(ctx, ec.Recover(ctx, r))
8403 ret = graphql.Null
8404 }
8405 }()
8406 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8407 ctx = rctx
8408 return ec.resolvers.Query().User(rctx, fc.Args["id"].(int))
8409 })
8410
8411 if resTmp == nil {
8412 if !graphql.HasFieldError(ctx, fc) {
8413 ec.Errorf(ctx, "must not be null")
8414 }
8415 return graphql.Null
8416 }
8417 res := resTmp.(*User)
8418 fc.Result = res
8419 return ec.marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUser(ctx, field.Selections, res)
8420 }
8421
8422 func (ec *executionContext) fieldContext_Query_user(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8423 fc = &graphql.FieldContext{
8424 Object: "Query",
8425 Field: field,
8426 IsMethod: true,
8427 IsResolver: true,
8428 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8429 switch field.Name {
8430 case "id":
8431 return ec.fieldContext_User_id(ctx, field)
8432 case "friends":
8433 return ec.fieldContext_User_friends(ctx, field)
8434 case "created":
8435 return ec.fieldContext_User_created(ctx, field)
8436 case "updated":
8437 return ec.fieldContext_User_updated(ctx, field)
8438 case "pets":
8439 return ec.fieldContext_User_pets(ctx, field)
8440 }
8441 return nil, fmt.Errorf("no field named %q was found under type User", field.Name)
8442 },
8443 }
8444 defer func() {
8445 if r := recover(); r != nil {
8446 err = ec.Recover(ctx, r)
8447 ec.Error(ctx, err)
8448 }
8449 }()
8450 ctx = graphql.WithFieldContext(ctx, fc)
8451 if fc.Args, err = ec.field_Query_user_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
8452 ec.Error(ctx, err)
8453 return fc, err
8454 }
8455 return fc, nil
8456 }
8457
8458 func (ec *executionContext) _Query_nullableArg(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8459 fc, err := ec.fieldContext_Query_nullableArg(ctx, field)
8460 if err != nil {
8461 return graphql.Null
8462 }
8463 ctx = graphql.WithFieldContext(ctx, fc)
8464 defer func() {
8465 if r := recover(); r != nil {
8466 ec.Error(ctx, ec.Recover(ctx, r))
8467 ret = graphql.Null
8468 }
8469 }()
8470 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8471 ctx = rctx
8472 return ec.resolvers.Query().NullableArg(rctx, fc.Args["arg"].(*int))
8473 })
8474
8475 if resTmp == nil {
8476 return graphql.Null
8477 }
8478 res := resTmp.(*string)
8479 fc.Result = res
8480 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
8481 }
8482
8483 func (ec *executionContext) fieldContext_Query_nullableArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8484 fc = &graphql.FieldContext{
8485 Object: "Query",
8486 Field: field,
8487 IsMethod: true,
8488 IsResolver: true,
8489 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8490 return nil, errors.New("field of type String does not have child fields")
8491 },
8492 }
8493 defer func() {
8494 if r := recover(); r != nil {
8495 err = ec.Recover(ctx, r)
8496 ec.Error(ctx, err)
8497 }
8498 }()
8499 ctx = graphql.WithFieldContext(ctx, fc)
8500 if fc.Args, err = ec.field_Query_nullableArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
8501 ec.Error(ctx, err)
8502 return fc, err
8503 }
8504 return fc, nil
8505 }
8506
8507 func (ec *executionContext) _Query_inputSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8508 fc, err := ec.fieldContext_Query_inputSlice(ctx, field)
8509 if err != nil {
8510 return graphql.Null
8511 }
8512 ctx = graphql.WithFieldContext(ctx, fc)
8513 defer func() {
8514 if r := recover(); r != nil {
8515 ec.Error(ctx, ec.Recover(ctx, r))
8516 ret = graphql.Null
8517 }
8518 }()
8519 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8520 ctx = rctx
8521 return ec.resolvers.Query().InputSlice(rctx, fc.Args["arg"].([]string))
8522 })
8523
8524 if resTmp == nil {
8525 if !graphql.HasFieldError(ctx, fc) {
8526 ec.Errorf(ctx, "must not be null")
8527 }
8528 return graphql.Null
8529 }
8530 res := resTmp.(bool)
8531 fc.Result = res
8532 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
8533 }
8534
8535 func (ec *executionContext) fieldContext_Query_inputSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8536 fc = &graphql.FieldContext{
8537 Object: "Query",
8538 Field: field,
8539 IsMethod: true,
8540 IsResolver: true,
8541 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8542 return nil, errors.New("field of type Boolean does not have child fields")
8543 },
8544 }
8545 defer func() {
8546 if r := recover(); r != nil {
8547 err = ec.Recover(ctx, r)
8548 ec.Error(ctx, err)
8549 }
8550 }()
8551 ctx = graphql.WithFieldContext(ctx, fc)
8552 if fc.Args, err = ec.field_Query_inputSlice_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
8553 ec.Error(ctx, err)
8554 return fc, err
8555 }
8556 return fc, nil
8557 }
8558
8559 func (ec *executionContext) _Query_inputNullableSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8560 fc, err := ec.fieldContext_Query_inputNullableSlice(ctx, field)
8561 if err != nil {
8562 return graphql.Null
8563 }
8564 ctx = graphql.WithFieldContext(ctx, fc)
8565 defer func() {
8566 if r := recover(); r != nil {
8567 ec.Error(ctx, ec.Recover(ctx, r))
8568 ret = graphql.Null
8569 }
8570 }()
8571 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8572 ctx = rctx
8573 return ec.resolvers.Query().InputNullableSlice(rctx, fc.Args["arg"].([]string))
8574 })
8575
8576 if resTmp == nil {
8577 if !graphql.HasFieldError(ctx, fc) {
8578 ec.Errorf(ctx, "must not be null")
8579 }
8580 return graphql.Null
8581 }
8582 res := resTmp.(bool)
8583 fc.Result = res
8584 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
8585 }
8586
8587 func (ec *executionContext) fieldContext_Query_inputNullableSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8588 fc = &graphql.FieldContext{
8589 Object: "Query",
8590 Field: field,
8591 IsMethod: true,
8592 IsResolver: true,
8593 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8594 return nil, errors.New("field of type Boolean does not have child fields")
8595 },
8596 }
8597 defer func() {
8598 if r := recover(); r != nil {
8599 err = ec.Recover(ctx, r)
8600 ec.Error(ctx, err)
8601 }
8602 }()
8603 ctx = graphql.WithFieldContext(ctx, fc)
8604 if fc.Args, err = ec.field_Query_inputNullableSlice_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
8605 ec.Error(ctx, err)
8606 return fc, err
8607 }
8608 return fc, nil
8609 }
8610
8611 func (ec *executionContext) _Query_inputOmittable(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8612 fc, err := ec.fieldContext_Query_inputOmittable(ctx, field)
8613 if err != nil {
8614 return graphql.Null
8615 }
8616 ctx = graphql.WithFieldContext(ctx, fc)
8617 defer func() {
8618 if r := recover(); r != nil {
8619 ec.Error(ctx, ec.Recover(ctx, r))
8620 ret = graphql.Null
8621 }
8622 }()
8623 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8624 ctx = rctx
8625 return ec.resolvers.Query().InputOmittable(rctx, fc.Args["arg"].(OmittableInput))
8626 })
8627
8628 if resTmp == nil {
8629 if !graphql.HasFieldError(ctx, fc) {
8630 ec.Errorf(ctx, "must not be null")
8631 }
8632 return graphql.Null
8633 }
8634 res := resTmp.(string)
8635 fc.Result = res
8636 return ec.marshalNString2string(ctx, field.Selections, res)
8637 }
8638
8639 func (ec *executionContext) fieldContext_Query_inputOmittable(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8640 fc = &graphql.FieldContext{
8641 Object: "Query",
8642 Field: field,
8643 IsMethod: true,
8644 IsResolver: true,
8645 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8646 return nil, errors.New("field of type String does not have child fields")
8647 },
8648 }
8649 defer func() {
8650 if r := recover(); r != nil {
8651 err = ec.Recover(ctx, r)
8652 ec.Error(ctx, err)
8653 }
8654 }()
8655 ctx = graphql.WithFieldContext(ctx, fc)
8656 if fc.Args, err = ec.field_Query_inputOmittable_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
8657 ec.Error(ctx, err)
8658 return fc, err
8659 }
8660 return fc, nil
8661 }
8662
8663 func (ec *executionContext) _Query_shapeUnion(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8664 fc, err := ec.fieldContext_Query_shapeUnion(ctx, field)
8665 if err != nil {
8666 return graphql.Null
8667 }
8668 ctx = graphql.WithFieldContext(ctx, fc)
8669 defer func() {
8670 if r := recover(); r != nil {
8671 ec.Error(ctx, ec.Recover(ctx, r))
8672 ret = graphql.Null
8673 }
8674 }()
8675 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8676 ctx = rctx
8677 return ec.resolvers.Query().ShapeUnion(rctx)
8678 })
8679
8680 if resTmp == nil {
8681 if !graphql.HasFieldError(ctx, fc) {
8682 ec.Errorf(ctx, "must not be null")
8683 }
8684 return graphql.Null
8685 }
8686 res := resTmp.(ShapeUnion)
8687 fc.Result = res
8688 return ec.marshalNShapeUnion2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐShapeUnion(ctx, field.Selections, res)
8689 }
8690
8691 func (ec *executionContext) fieldContext_Query_shapeUnion(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8692 fc = &graphql.FieldContext{
8693 Object: "Query",
8694 Field: field,
8695 IsMethod: true,
8696 IsResolver: true,
8697 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8698 return nil, errors.New("field of type ShapeUnion does not have child fields")
8699 },
8700 }
8701 return fc, nil
8702 }
8703
8704 func (ec *executionContext) _Query_autobind(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8705 fc, err := ec.fieldContext_Query_autobind(ctx, field)
8706 if err != nil {
8707 return graphql.Null
8708 }
8709 ctx = graphql.WithFieldContext(ctx, fc)
8710 defer func() {
8711 if r := recover(); r != nil {
8712 ec.Error(ctx, ec.Recover(ctx, r))
8713 ret = graphql.Null
8714 }
8715 }()
8716 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8717 ctx = rctx
8718 return ec.resolvers.Query().Autobind(rctx)
8719 })
8720
8721 if resTmp == nil {
8722 return graphql.Null
8723 }
8724 res := resTmp.(*Autobind)
8725 fc.Result = res
8726 return ec.marshalOAutobind2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐAutobind(ctx, field.Selections, res)
8727 }
8728
8729 func (ec *executionContext) fieldContext_Query_autobind(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8730 fc = &graphql.FieldContext{
8731 Object: "Query",
8732 Field: field,
8733 IsMethod: true,
8734 IsResolver: true,
8735 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8736 switch field.Name {
8737 case "int":
8738 return ec.fieldContext_Autobind_int(ctx, field)
8739 case "int32":
8740 return ec.fieldContext_Autobind_int32(ctx, field)
8741 case "int64":
8742 return ec.fieldContext_Autobind_int64(ctx, field)
8743 case "idStr":
8744 return ec.fieldContext_Autobind_idStr(ctx, field)
8745 case "idInt":
8746 return ec.fieldContext_Autobind_idInt(ctx, field)
8747 }
8748 return nil, fmt.Errorf("no field named %q was found under type Autobind", field.Name)
8749 },
8750 }
8751 return fc, nil
8752 }
8753
8754 func (ec *executionContext) _Query_deprecatedField(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8755 fc, err := ec.fieldContext_Query_deprecatedField(ctx, field)
8756 if err != nil {
8757 return graphql.Null
8758 }
8759 ctx = graphql.WithFieldContext(ctx, fc)
8760 defer func() {
8761 if r := recover(); r != nil {
8762 ec.Error(ctx, ec.Recover(ctx, r))
8763 ret = graphql.Null
8764 }
8765 }()
8766 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8767 ctx = rctx
8768 return ec.resolvers.Query().DeprecatedField(rctx)
8769 })
8770
8771 if resTmp == nil {
8772 if !graphql.HasFieldError(ctx, fc) {
8773 ec.Errorf(ctx, "must not be null")
8774 }
8775 return graphql.Null
8776 }
8777 res := resTmp.(string)
8778 fc.Result = res
8779 return ec.marshalNString2string(ctx, field.Selections, res)
8780 }
8781
8782 func (ec *executionContext) fieldContext_Query_deprecatedField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8783 fc = &graphql.FieldContext{
8784 Object: "Query",
8785 Field: field,
8786 IsMethod: true,
8787 IsResolver: true,
8788 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8789 return nil, errors.New("field of type String does not have child fields")
8790 },
8791 }
8792 return fc, nil
8793 }
8794
8795 func (ec *executionContext) _Query_overlapping(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8796 fc, err := ec.fieldContext_Query_overlapping(ctx, field)
8797 if err != nil {
8798 return graphql.Null
8799 }
8800 ctx = graphql.WithFieldContext(ctx, fc)
8801 defer func() {
8802 if r := recover(); r != nil {
8803 ec.Error(ctx, ec.Recover(ctx, r))
8804 ret = graphql.Null
8805 }
8806 }()
8807 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8808 ctx = rctx
8809 return ec.resolvers.Query().Overlapping(rctx)
8810 })
8811
8812 if resTmp == nil {
8813 return graphql.Null
8814 }
8815 res := resTmp.(*OverlappingFields)
8816 fc.Result = res
8817 return ec.marshalOOverlappingFields2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOverlappingFields(ctx, field.Selections, res)
8818 }
8819
8820 func (ec *executionContext) fieldContext_Query_overlapping(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8821 fc = &graphql.FieldContext{
8822 Object: "Query",
8823 Field: field,
8824 IsMethod: true,
8825 IsResolver: true,
8826 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8827 switch field.Name {
8828 case "oneFoo":
8829 return ec.fieldContext_OverlappingFields_oneFoo(ctx, field)
8830 case "twoFoo":
8831 return ec.fieldContext_OverlappingFields_twoFoo(ctx, field)
8832 case "oldFoo":
8833 return ec.fieldContext_OverlappingFields_oldFoo(ctx, field)
8834 case "newFoo":
8835 return ec.fieldContext_OverlappingFields_newFoo(ctx, field)
8836 case "new_foo":
8837 return ec.fieldContext_OverlappingFields_new_foo(ctx, field)
8838 }
8839 return nil, fmt.Errorf("no field named %q was found under type OverlappingFields", field.Name)
8840 },
8841 }
8842 return fc, nil
8843 }
8844
8845 func (ec *executionContext) _Query_defaultParameters(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8846 fc, err := ec.fieldContext_Query_defaultParameters(ctx, field)
8847 if err != nil {
8848 return graphql.Null
8849 }
8850 ctx = graphql.WithFieldContext(ctx, fc)
8851 defer func() {
8852 if r := recover(); r != nil {
8853 ec.Error(ctx, ec.Recover(ctx, r))
8854 ret = graphql.Null
8855 }
8856 }()
8857 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8858 ctx = rctx
8859 return ec.resolvers.Query().DefaultParameters(rctx, fc.Args["falsyBoolean"].(*bool), fc.Args["truthyBoolean"].(*bool))
8860 })
8861
8862 if resTmp == nil {
8863 if !graphql.HasFieldError(ctx, fc) {
8864 ec.Errorf(ctx, "must not be null")
8865 }
8866 return graphql.Null
8867 }
8868 res := resTmp.(*DefaultParametersMirror)
8869 fc.Result = res
8870 return ec.marshalNDefaultParametersMirror2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐDefaultParametersMirror(ctx, field.Selections, res)
8871 }
8872
8873 func (ec *executionContext) fieldContext_Query_defaultParameters(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8874 fc = &graphql.FieldContext{
8875 Object: "Query",
8876 Field: field,
8877 IsMethod: true,
8878 IsResolver: true,
8879 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8880 switch field.Name {
8881 case "falsyBoolean":
8882 return ec.fieldContext_DefaultParametersMirror_falsyBoolean(ctx, field)
8883 case "truthyBoolean":
8884 return ec.fieldContext_DefaultParametersMirror_truthyBoolean(ctx, field)
8885 }
8886 return nil, fmt.Errorf("no field named %q was found under type DefaultParametersMirror", field.Name)
8887 },
8888 }
8889 defer func() {
8890 if r := recover(); r != nil {
8891 err = ec.Recover(ctx, r)
8892 ec.Error(ctx, err)
8893 }
8894 }()
8895 ctx = graphql.WithFieldContext(ctx, fc)
8896 if fc.Args, err = ec.field_Query_defaultParameters_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
8897 ec.Error(ctx, err)
8898 return fc, err
8899 }
8900 return fc, nil
8901 }
8902
8903 func (ec *executionContext) _Query_deferCase1(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8904 fc, err := ec.fieldContext_Query_deferCase1(ctx, field)
8905 if err != nil {
8906 return graphql.Null
8907 }
8908 ctx = graphql.WithFieldContext(ctx, fc)
8909 defer func() {
8910 if r := recover(); r != nil {
8911 ec.Error(ctx, ec.Recover(ctx, r))
8912 ret = graphql.Null
8913 }
8914 }()
8915 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8916 ctx = rctx
8917 return ec.resolvers.Query().DeferCase1(rctx)
8918 })
8919
8920 if resTmp == nil {
8921 return graphql.Null
8922 }
8923 res := resTmp.(*DeferModel)
8924 fc.Result = res
8925 return ec.marshalODeferModel2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐDeferModel(ctx, field.Selections, res)
8926 }
8927
8928 func (ec *executionContext) fieldContext_Query_deferCase1(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8929 fc = &graphql.FieldContext{
8930 Object: "Query",
8931 Field: field,
8932 IsMethod: true,
8933 IsResolver: true,
8934 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8935 switch field.Name {
8936 case "id":
8937 return ec.fieldContext_DeferModel_id(ctx, field)
8938 case "name":
8939 return ec.fieldContext_DeferModel_name(ctx, field)
8940 case "values":
8941 return ec.fieldContext_DeferModel_values(ctx, field)
8942 }
8943 return nil, fmt.Errorf("no field named %q was found under type DeferModel", field.Name)
8944 },
8945 }
8946 return fc, nil
8947 }
8948
8949 func (ec *executionContext) _Query_deferCase2(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8950 fc, err := ec.fieldContext_Query_deferCase2(ctx, field)
8951 if err != nil {
8952 return graphql.Null
8953 }
8954 ctx = graphql.WithFieldContext(ctx, fc)
8955 defer func() {
8956 if r := recover(); r != nil {
8957 ec.Error(ctx, ec.Recover(ctx, r))
8958 ret = graphql.Null
8959 }
8960 }()
8961 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
8962 ctx = rctx
8963 return ec.resolvers.Query().DeferCase2(rctx)
8964 })
8965
8966 if resTmp == nil {
8967 return graphql.Null
8968 }
8969 res := resTmp.([]*DeferModel)
8970 fc.Result = res
8971 return ec.marshalODeferModel2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐDeferModelᚄ(ctx, field.Selections, res)
8972 }
8973
8974 func (ec *executionContext) fieldContext_Query_deferCase2(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
8975 fc = &graphql.FieldContext{
8976 Object: "Query",
8977 Field: field,
8978 IsMethod: true,
8979 IsResolver: true,
8980 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
8981 switch field.Name {
8982 case "id":
8983 return ec.fieldContext_DeferModel_id(ctx, field)
8984 case "name":
8985 return ec.fieldContext_DeferModel_name(ctx, field)
8986 case "values":
8987 return ec.fieldContext_DeferModel_values(ctx, field)
8988 }
8989 return nil, fmt.Errorf("no field named %q was found under type DeferModel", field.Name)
8990 },
8991 }
8992 return fc, nil
8993 }
8994
8995 func (ec *executionContext) _Query_directiveArg(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
8996 fc, err := ec.fieldContext_Query_directiveArg(ctx, field)
8997 if err != nil {
8998 return graphql.Null
8999 }
9000 ctx = graphql.WithFieldContext(ctx, fc)
9001 defer func() {
9002 if r := recover(); r != nil {
9003 ec.Error(ctx, ec.Recover(ctx, r))
9004 ret = graphql.Null
9005 }
9006 }()
9007 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9008 ctx = rctx
9009 return ec.resolvers.Query().DirectiveArg(rctx, fc.Args["arg"].(string))
9010 })
9011
9012 if resTmp == nil {
9013 return graphql.Null
9014 }
9015 res := resTmp.(*string)
9016 fc.Result = res
9017 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9018 }
9019
9020 func (ec *executionContext) fieldContext_Query_directiveArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9021 fc = &graphql.FieldContext{
9022 Object: "Query",
9023 Field: field,
9024 IsMethod: true,
9025 IsResolver: true,
9026 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9027 return nil, errors.New("field of type String does not have child fields")
9028 },
9029 }
9030 defer func() {
9031 if r := recover(); r != nil {
9032 err = ec.Recover(ctx, r)
9033 ec.Error(ctx, err)
9034 }
9035 }()
9036 ctx = graphql.WithFieldContext(ctx, fc)
9037 if fc.Args, err = ec.field_Query_directiveArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9038 ec.Error(ctx, err)
9039 return fc, err
9040 }
9041 return fc, nil
9042 }
9043
9044 func (ec *executionContext) _Query_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9045 fc, err := ec.fieldContext_Query_directiveNullableArg(ctx, field)
9046 if err != nil {
9047 return graphql.Null
9048 }
9049 ctx = graphql.WithFieldContext(ctx, fc)
9050 defer func() {
9051 if r := recover(); r != nil {
9052 ec.Error(ctx, ec.Recover(ctx, r))
9053 ret = graphql.Null
9054 }
9055 }()
9056 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9057 ctx = rctx
9058 return ec.resolvers.Query().DirectiveNullableArg(rctx, fc.Args["arg"].(*int), fc.Args["arg2"].(*int), fc.Args["arg3"].(*string))
9059 })
9060
9061 if resTmp == nil {
9062 return graphql.Null
9063 }
9064 res := resTmp.(*string)
9065 fc.Result = res
9066 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9067 }
9068
9069 func (ec *executionContext) fieldContext_Query_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9070 fc = &graphql.FieldContext{
9071 Object: "Query",
9072 Field: field,
9073 IsMethod: true,
9074 IsResolver: true,
9075 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9076 return nil, errors.New("field of type String does not have child fields")
9077 },
9078 }
9079 defer func() {
9080 if r := recover(); r != nil {
9081 err = ec.Recover(ctx, r)
9082 ec.Error(ctx, err)
9083 }
9084 }()
9085 ctx = graphql.WithFieldContext(ctx, fc)
9086 if fc.Args, err = ec.field_Query_directiveNullableArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9087 ec.Error(ctx, err)
9088 return fc, err
9089 }
9090 return fc, nil
9091 }
9092
9093 func (ec *executionContext) _Query_directiveInputNullable(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9094 fc, err := ec.fieldContext_Query_directiveInputNullable(ctx, field)
9095 if err != nil {
9096 return graphql.Null
9097 }
9098 ctx = graphql.WithFieldContext(ctx, fc)
9099 defer func() {
9100 if r := recover(); r != nil {
9101 ec.Error(ctx, ec.Recover(ctx, r))
9102 ret = graphql.Null
9103 }
9104 }()
9105 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9106 ctx = rctx
9107 return ec.resolvers.Query().DirectiveInputNullable(rctx, fc.Args["arg"].(*InputDirectives))
9108 })
9109
9110 if resTmp == nil {
9111 return graphql.Null
9112 }
9113 res := resTmp.(*string)
9114 fc.Result = res
9115 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9116 }
9117
9118 func (ec *executionContext) fieldContext_Query_directiveInputNullable(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9119 fc = &graphql.FieldContext{
9120 Object: "Query",
9121 Field: field,
9122 IsMethod: true,
9123 IsResolver: true,
9124 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9125 return nil, errors.New("field of type String does not have child fields")
9126 },
9127 }
9128 defer func() {
9129 if r := recover(); r != nil {
9130 err = ec.Recover(ctx, r)
9131 ec.Error(ctx, err)
9132 }
9133 }()
9134 ctx = graphql.WithFieldContext(ctx, fc)
9135 if fc.Args, err = ec.field_Query_directiveInputNullable_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9136 ec.Error(ctx, err)
9137 return fc, err
9138 }
9139 return fc, nil
9140 }
9141
9142 func (ec *executionContext) _Query_directiveInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9143 fc, err := ec.fieldContext_Query_directiveInput(ctx, field)
9144 if err != nil {
9145 return graphql.Null
9146 }
9147 ctx = graphql.WithFieldContext(ctx, fc)
9148 defer func() {
9149 if r := recover(); r != nil {
9150 ec.Error(ctx, ec.Recover(ctx, r))
9151 ret = graphql.Null
9152 }
9153 }()
9154 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9155 ctx = rctx
9156 return ec.resolvers.Query().DirectiveInput(rctx, fc.Args["arg"].(InputDirectives))
9157 })
9158
9159 if resTmp == nil {
9160 return graphql.Null
9161 }
9162 res := resTmp.(*string)
9163 fc.Result = res
9164 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9165 }
9166
9167 func (ec *executionContext) fieldContext_Query_directiveInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9168 fc = &graphql.FieldContext{
9169 Object: "Query",
9170 Field: field,
9171 IsMethod: true,
9172 IsResolver: true,
9173 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9174 return nil, errors.New("field of type String does not have child fields")
9175 },
9176 }
9177 defer func() {
9178 if r := recover(); r != nil {
9179 err = ec.Recover(ctx, r)
9180 ec.Error(ctx, err)
9181 }
9182 }()
9183 ctx = graphql.WithFieldContext(ctx, fc)
9184 if fc.Args, err = ec.field_Query_directiveInput_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9185 ec.Error(ctx, err)
9186 return fc, err
9187 }
9188 return fc, nil
9189 }
9190
9191 func (ec *executionContext) _Query_directiveInputType(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9192 fc, err := ec.fieldContext_Query_directiveInputType(ctx, field)
9193 if err != nil {
9194 return graphql.Null
9195 }
9196 ctx = graphql.WithFieldContext(ctx, fc)
9197 defer func() {
9198 if r := recover(); r != nil {
9199 ec.Error(ctx, ec.Recover(ctx, r))
9200 ret = graphql.Null
9201 }
9202 }()
9203 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9204 ctx = rctx
9205 return ec.resolvers.Query().DirectiveInputType(rctx, fc.Args["arg"].(InnerInput))
9206 })
9207
9208 if resTmp == nil {
9209 return graphql.Null
9210 }
9211 res := resTmp.(*string)
9212 fc.Result = res
9213 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9214 }
9215
9216 func (ec *executionContext) fieldContext_Query_directiveInputType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9217 fc = &graphql.FieldContext{
9218 Object: "Query",
9219 Field: field,
9220 IsMethod: true,
9221 IsResolver: true,
9222 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9223 return nil, errors.New("field of type String does not have child fields")
9224 },
9225 }
9226 defer func() {
9227 if r := recover(); r != nil {
9228 err = ec.Recover(ctx, r)
9229 ec.Error(ctx, err)
9230 }
9231 }()
9232 ctx = graphql.WithFieldContext(ctx, fc)
9233 if fc.Args, err = ec.field_Query_directiveInputType_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9234 ec.Error(ctx, err)
9235 return fc, err
9236 }
9237 return fc, nil
9238 }
9239
9240 func (ec *executionContext) _Query_directiveObject(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9241 fc, err := ec.fieldContext_Query_directiveObject(ctx, field)
9242 if err != nil {
9243 return graphql.Null
9244 }
9245 ctx = graphql.WithFieldContext(ctx, fc)
9246 defer func() {
9247 if r := recover(); r != nil {
9248 ec.Error(ctx, ec.Recover(ctx, r))
9249 ret = graphql.Null
9250 }
9251 }()
9252 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9253 directive0 := func(rctx context.Context) (interface{}, error) {
9254 ctx = rctx
9255 return ec.resolvers.Query().DirectiveObject(rctx)
9256 }
9257 directive1 := func(ctx context.Context) (interface{}, error) {
9258 location, err := ec.unmarshalNString2string(ctx, "order1_1")
9259 if err != nil {
9260 return nil, err
9261 }
9262 if ec.directives.Order1 == nil {
9263 return nil, errors.New("directive order1 is not implemented")
9264 }
9265 return ec.directives.Order1(ctx, nil, directive0, location)
9266 }
9267 directive2 := func(ctx context.Context) (interface{}, error) {
9268 location, err := ec.unmarshalNString2string(ctx, "order1_2")
9269 if err != nil {
9270 return nil, err
9271 }
9272 if ec.directives.Order1 == nil {
9273 return nil, errors.New("directive order1 is not implemented")
9274 }
9275 return ec.directives.Order1(ctx, nil, directive1, location)
9276 }
9277 directive3 := func(ctx context.Context) (interface{}, error) {
9278 location, err := ec.unmarshalNString2string(ctx, "order2_1")
9279 if err != nil {
9280 return nil, err
9281 }
9282 if ec.directives.Order2 == nil {
9283 return nil, errors.New("directive order2 is not implemented")
9284 }
9285 return ec.directives.Order2(ctx, nil, directive2, location)
9286 }
9287 directive4 := func(ctx context.Context) (interface{}, error) {
9288 location, err := ec.unmarshalNString2string(ctx, "Query_field")
9289 if err != nil {
9290 return nil, err
9291 }
9292 if ec.directives.Order1 == nil {
9293 return nil, errors.New("directive order1 is not implemented")
9294 }
9295 return ec.directives.Order1(ctx, nil, directive3, location)
9296 }
9297
9298 tmp, err := directive4(rctx)
9299 if err != nil {
9300 return nil, graphql.ErrorOnPath(ctx, err)
9301 }
9302 if tmp == nil {
9303 return nil, nil
9304 }
9305 if data, ok := tmp.(*ObjectDirectives); ok {
9306 return data, nil
9307 }
9308 return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/99designs/gqlgen/codegen/testserver/singlefile.ObjectDirectives`, tmp)
9309 })
9310
9311 if resTmp == nil {
9312 return graphql.Null
9313 }
9314 res := resTmp.(*ObjectDirectives)
9315 fc.Result = res
9316 return ec.marshalOObjectDirectives2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐObjectDirectives(ctx, field.Selections, res)
9317 }
9318
9319 func (ec *executionContext) fieldContext_Query_directiveObject(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9320 fc = &graphql.FieldContext{
9321 Object: "Query",
9322 Field: field,
9323 IsMethod: true,
9324 IsResolver: true,
9325 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9326 switch field.Name {
9327 case "text":
9328 return ec.fieldContext_ObjectDirectives_text(ctx, field)
9329 case "nullableText":
9330 return ec.fieldContext_ObjectDirectives_nullableText(ctx, field)
9331 case "order":
9332 return ec.fieldContext_ObjectDirectives_order(ctx, field)
9333 }
9334 return nil, fmt.Errorf("no field named %q was found under type ObjectDirectives", field.Name)
9335 },
9336 }
9337 return fc, nil
9338 }
9339
9340 func (ec *executionContext) _Query_directiveObjectWithCustomGoModel(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9341 fc, err := ec.fieldContext_Query_directiveObjectWithCustomGoModel(ctx, field)
9342 if err != nil {
9343 return graphql.Null
9344 }
9345 ctx = graphql.WithFieldContext(ctx, fc)
9346 defer func() {
9347 if r := recover(); r != nil {
9348 ec.Error(ctx, ec.Recover(ctx, r))
9349 ret = graphql.Null
9350 }
9351 }()
9352 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9353 ctx = rctx
9354 return ec.resolvers.Query().DirectiveObjectWithCustomGoModel(rctx)
9355 })
9356
9357 if resTmp == nil {
9358 return graphql.Null
9359 }
9360 res := resTmp.(*ObjectDirectivesWithCustomGoModel)
9361 fc.Result = res
9362 return ec.marshalOObjectDirectivesWithCustomGoModel2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐObjectDirectivesWithCustomGoModel(ctx, field.Selections, res)
9363 }
9364
9365 func (ec *executionContext) fieldContext_Query_directiveObjectWithCustomGoModel(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9366 fc = &graphql.FieldContext{
9367 Object: "Query",
9368 Field: field,
9369 IsMethod: true,
9370 IsResolver: true,
9371 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9372 switch field.Name {
9373 case "nullableText":
9374 return ec.fieldContext_ObjectDirectivesWithCustomGoModel_nullableText(ctx, field)
9375 }
9376 return nil, fmt.Errorf("no field named %q was found under type ObjectDirectivesWithCustomGoModel", field.Name)
9377 },
9378 }
9379 return fc, nil
9380 }
9381
9382 func (ec *executionContext) _Query_directiveFieldDef(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9383 fc, err := ec.fieldContext_Query_directiveFieldDef(ctx, field)
9384 if err != nil {
9385 return graphql.Null
9386 }
9387 ctx = graphql.WithFieldContext(ctx, fc)
9388 defer func() {
9389 if r := recover(); r != nil {
9390 ec.Error(ctx, ec.Recover(ctx, r))
9391 ret = graphql.Null
9392 }
9393 }()
9394 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9395 directive0 := func(rctx context.Context) (interface{}, error) {
9396 ctx = rctx
9397 return ec.resolvers.Query().DirectiveFieldDef(rctx, fc.Args["ret"].(string))
9398 }
9399 directive1 := func(ctx context.Context) (interface{}, error) {
9400 min, err := ec.unmarshalNInt2int(ctx, 1)
9401 if err != nil {
9402 return nil, err
9403 }
9404 message, err := ec.unmarshalOString2ᚖstring(ctx, "not valid")
9405 if err != nil {
9406 return nil, err
9407 }
9408 if ec.directives.Length == nil {
9409 return nil, errors.New("directive length is not implemented")
9410 }
9411 return ec.directives.Length(ctx, nil, directive0, min, nil, message)
9412 }
9413
9414 tmp, err := directive1(rctx)
9415 if err != nil {
9416 return nil, graphql.ErrorOnPath(ctx, err)
9417 }
9418 if tmp == nil {
9419 return nil, nil
9420 }
9421 if data, ok := tmp.(string); ok {
9422 return data, nil
9423 }
9424 return nil, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp)
9425 })
9426
9427 if resTmp == nil {
9428 if !graphql.HasFieldError(ctx, fc) {
9429 ec.Errorf(ctx, "must not be null")
9430 }
9431 return graphql.Null
9432 }
9433 res := resTmp.(string)
9434 fc.Result = res
9435 return ec.marshalNString2string(ctx, field.Selections, res)
9436 }
9437
9438 func (ec *executionContext) fieldContext_Query_directiveFieldDef(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9439 fc = &graphql.FieldContext{
9440 Object: "Query",
9441 Field: field,
9442 IsMethod: true,
9443 IsResolver: true,
9444 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9445 return nil, errors.New("field of type String does not have child fields")
9446 },
9447 }
9448 defer func() {
9449 if r := recover(); r != nil {
9450 err = ec.Recover(ctx, r)
9451 ec.Error(ctx, err)
9452 }
9453 }()
9454 ctx = graphql.WithFieldContext(ctx, fc)
9455 if fc.Args, err = ec.field_Query_directiveFieldDef_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9456 ec.Error(ctx, err)
9457 return fc, err
9458 }
9459 return fc, nil
9460 }
9461
9462 func (ec *executionContext) _Query_directiveField(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9463 fc, err := ec.fieldContext_Query_directiveField(ctx, field)
9464 if err != nil {
9465 return graphql.Null
9466 }
9467 ctx = graphql.WithFieldContext(ctx, fc)
9468 defer func() {
9469 if r := recover(); r != nil {
9470 ec.Error(ctx, ec.Recover(ctx, r))
9471 ret = graphql.Null
9472 }
9473 }()
9474 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9475 ctx = rctx
9476 return ec.resolvers.Query().DirectiveField(rctx)
9477 })
9478
9479 if resTmp == nil {
9480 return graphql.Null
9481 }
9482 res := resTmp.(*string)
9483 fc.Result = res
9484 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9485 }
9486
9487 func (ec *executionContext) fieldContext_Query_directiveField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9488 fc = &graphql.FieldContext{
9489 Object: "Query",
9490 Field: field,
9491 IsMethod: true,
9492 IsResolver: true,
9493 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9494 return nil, errors.New("field of type String does not have child fields")
9495 },
9496 }
9497 return fc, nil
9498 }
9499
9500 func (ec *executionContext) _Query_directiveDouble(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9501 fc, err := ec.fieldContext_Query_directiveDouble(ctx, field)
9502 if err != nil {
9503 return graphql.Null
9504 }
9505 ctx = graphql.WithFieldContext(ctx, fc)
9506 defer func() {
9507 if r := recover(); r != nil {
9508 ec.Error(ctx, ec.Recover(ctx, r))
9509 ret = graphql.Null
9510 }
9511 }()
9512 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9513 directive0 := func(rctx context.Context) (interface{}, error) {
9514 ctx = rctx
9515 return ec.resolvers.Query().DirectiveDouble(rctx)
9516 }
9517 directive1 := func(ctx context.Context) (interface{}, error) {
9518 if ec.directives.Directive1 == nil {
9519 return nil, errors.New("directive directive1 is not implemented")
9520 }
9521 return ec.directives.Directive1(ctx, nil, directive0)
9522 }
9523 directive2 := func(ctx context.Context) (interface{}, error) {
9524 if ec.directives.Directive2 == nil {
9525 return nil, errors.New("directive directive2 is not implemented")
9526 }
9527 return ec.directives.Directive2(ctx, nil, directive1)
9528 }
9529
9530 tmp, err := directive2(rctx)
9531 if err != nil {
9532 return nil, graphql.ErrorOnPath(ctx, err)
9533 }
9534 if tmp == nil {
9535 return nil, nil
9536 }
9537 if data, ok := tmp.(*string); ok {
9538 return data, nil
9539 }
9540 return nil, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp)
9541 })
9542
9543 if resTmp == nil {
9544 return graphql.Null
9545 }
9546 res := resTmp.(*string)
9547 fc.Result = res
9548 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9549 }
9550
9551 func (ec *executionContext) fieldContext_Query_directiveDouble(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9552 fc = &graphql.FieldContext{
9553 Object: "Query",
9554 Field: field,
9555 IsMethod: true,
9556 IsResolver: true,
9557 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9558 return nil, errors.New("field of type String does not have child fields")
9559 },
9560 }
9561 return fc, nil
9562 }
9563
9564 func (ec *executionContext) _Query_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9565 fc, err := ec.fieldContext_Query_directiveUnimplemented(ctx, field)
9566 if err != nil {
9567 return graphql.Null
9568 }
9569 ctx = graphql.WithFieldContext(ctx, fc)
9570 defer func() {
9571 if r := recover(); r != nil {
9572 ec.Error(ctx, ec.Recover(ctx, r))
9573 ret = graphql.Null
9574 }
9575 }()
9576 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9577 directive0 := func(rctx context.Context) (interface{}, error) {
9578 ctx = rctx
9579 return ec.resolvers.Query().DirectiveUnimplemented(rctx)
9580 }
9581 directive1 := func(ctx context.Context) (interface{}, error) {
9582 if ec.directives.Unimplemented == nil {
9583 return nil, errors.New("directive unimplemented is not implemented")
9584 }
9585 return ec.directives.Unimplemented(ctx, nil, directive0)
9586 }
9587
9588 tmp, err := directive1(rctx)
9589 if err != nil {
9590 return nil, graphql.ErrorOnPath(ctx, err)
9591 }
9592 if tmp == nil {
9593 return nil, nil
9594 }
9595 if data, ok := tmp.(*string); ok {
9596 return data, nil
9597 }
9598 return nil, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp)
9599 })
9600
9601 if resTmp == nil {
9602 return graphql.Null
9603 }
9604 res := resTmp.(*string)
9605 fc.Result = res
9606 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
9607 }
9608
9609 func (ec *executionContext) fieldContext_Query_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9610 fc = &graphql.FieldContext{
9611 Object: "Query",
9612 Field: field,
9613 IsMethod: true,
9614 IsResolver: true,
9615 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9616 return nil, errors.New("field of type String does not have child fields")
9617 },
9618 }
9619 return fc, nil
9620 }
9621
9622 func (ec *executionContext) _Query_embeddedCase1(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9623 fc, err := ec.fieldContext_Query_embeddedCase1(ctx, field)
9624 if err != nil {
9625 return graphql.Null
9626 }
9627 ctx = graphql.WithFieldContext(ctx, fc)
9628 defer func() {
9629 if r := recover(); r != nil {
9630 ec.Error(ctx, ec.Recover(ctx, r))
9631 ret = graphql.Null
9632 }
9633 }()
9634 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9635 ctx = rctx
9636 return ec.resolvers.Query().EmbeddedCase1(rctx)
9637 })
9638
9639 if resTmp == nil {
9640 return graphql.Null
9641 }
9642 res := resTmp.(*EmbeddedCase1)
9643 fc.Result = res
9644 return ec.marshalOEmbeddedCase12ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐEmbeddedCase1(ctx, field.Selections, res)
9645 }
9646
9647 func (ec *executionContext) fieldContext_Query_embeddedCase1(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9648 fc = &graphql.FieldContext{
9649 Object: "Query",
9650 Field: field,
9651 IsMethod: true,
9652 IsResolver: true,
9653 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9654 switch field.Name {
9655 case "exportedEmbeddedPointerExportedMethod":
9656 return ec.fieldContext_EmbeddedCase1_exportedEmbeddedPointerExportedMethod(ctx, field)
9657 }
9658 return nil, fmt.Errorf("no field named %q was found under type EmbeddedCase1", field.Name)
9659 },
9660 }
9661 return fc, nil
9662 }
9663
9664 func (ec *executionContext) _Query_embeddedCase2(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9665 fc, err := ec.fieldContext_Query_embeddedCase2(ctx, field)
9666 if err != nil {
9667 return graphql.Null
9668 }
9669 ctx = graphql.WithFieldContext(ctx, fc)
9670 defer func() {
9671 if r := recover(); r != nil {
9672 ec.Error(ctx, ec.Recover(ctx, r))
9673 ret = graphql.Null
9674 }
9675 }()
9676 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9677 ctx = rctx
9678 return ec.resolvers.Query().EmbeddedCase2(rctx)
9679 })
9680
9681 if resTmp == nil {
9682 return graphql.Null
9683 }
9684 res := resTmp.(*EmbeddedCase2)
9685 fc.Result = res
9686 return ec.marshalOEmbeddedCase22ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐEmbeddedCase2(ctx, field.Selections, res)
9687 }
9688
9689 func (ec *executionContext) fieldContext_Query_embeddedCase2(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9690 fc = &graphql.FieldContext{
9691 Object: "Query",
9692 Field: field,
9693 IsMethod: true,
9694 IsResolver: true,
9695 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9696 switch field.Name {
9697 case "unexportedEmbeddedPointerExportedMethod":
9698 return ec.fieldContext_EmbeddedCase2_unexportedEmbeddedPointerExportedMethod(ctx, field)
9699 }
9700 return nil, fmt.Errorf("no field named %q was found under type EmbeddedCase2", field.Name)
9701 },
9702 }
9703 return fc, nil
9704 }
9705
9706 func (ec *executionContext) _Query_embeddedCase3(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9707 fc, err := ec.fieldContext_Query_embeddedCase3(ctx, field)
9708 if err != nil {
9709 return graphql.Null
9710 }
9711 ctx = graphql.WithFieldContext(ctx, fc)
9712 defer func() {
9713 if r := recover(); r != nil {
9714 ec.Error(ctx, ec.Recover(ctx, r))
9715 ret = graphql.Null
9716 }
9717 }()
9718 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9719 ctx = rctx
9720 return ec.resolvers.Query().EmbeddedCase3(rctx)
9721 })
9722
9723 if resTmp == nil {
9724 return graphql.Null
9725 }
9726 res := resTmp.(*EmbeddedCase3)
9727 fc.Result = res
9728 return ec.marshalOEmbeddedCase32ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐEmbeddedCase3(ctx, field.Selections, res)
9729 }
9730
9731 func (ec *executionContext) fieldContext_Query_embeddedCase3(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9732 fc = &graphql.FieldContext{
9733 Object: "Query",
9734 Field: field,
9735 IsMethod: true,
9736 IsResolver: true,
9737 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9738 switch field.Name {
9739 case "unexportedEmbeddedInterfaceExportedMethod":
9740 return ec.fieldContext_EmbeddedCase3_unexportedEmbeddedInterfaceExportedMethod(ctx, field)
9741 }
9742 return nil, fmt.Errorf("no field named %q was found under type EmbeddedCase3", field.Name)
9743 },
9744 }
9745 return fc, nil
9746 }
9747
9748 func (ec *executionContext) _Query_enumInInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9749 fc, err := ec.fieldContext_Query_enumInInput(ctx, field)
9750 if err != nil {
9751 return graphql.Null
9752 }
9753 ctx = graphql.WithFieldContext(ctx, fc)
9754 defer func() {
9755 if r := recover(); r != nil {
9756 ec.Error(ctx, ec.Recover(ctx, r))
9757 ret = graphql.Null
9758 }
9759 }()
9760 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9761 ctx = rctx
9762 return ec.resolvers.Query().EnumInInput(rctx, fc.Args["input"].(*InputWithEnumValue))
9763 })
9764
9765 if resTmp == nil {
9766 if !graphql.HasFieldError(ctx, fc) {
9767 ec.Errorf(ctx, "must not be null")
9768 }
9769 return graphql.Null
9770 }
9771 res := resTmp.(EnumTest)
9772 fc.Result = res
9773 return ec.marshalNEnumTest2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐEnumTest(ctx, field.Selections, res)
9774 }
9775
9776 func (ec *executionContext) fieldContext_Query_enumInInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9777 fc = &graphql.FieldContext{
9778 Object: "Query",
9779 Field: field,
9780 IsMethod: true,
9781 IsResolver: true,
9782 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9783 return nil, errors.New("field of type EnumTest does not have child fields")
9784 },
9785 }
9786 defer func() {
9787 if r := recover(); r != nil {
9788 err = ec.Recover(ctx, r)
9789 ec.Error(ctx, err)
9790 }
9791 }()
9792 ctx = graphql.WithFieldContext(ctx, fc)
9793 if fc.Args, err = ec.field_Query_enumInInput_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
9794 ec.Error(ctx, err)
9795 return fc, err
9796 }
9797 return fc, nil
9798 }
9799
9800 func (ec *executionContext) _Query_shapes(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9801 fc, err := ec.fieldContext_Query_shapes(ctx, field)
9802 if err != nil {
9803 return graphql.Null
9804 }
9805 ctx = graphql.WithFieldContext(ctx, fc)
9806 defer func() {
9807 if r := recover(); r != nil {
9808 ec.Error(ctx, ec.Recover(ctx, r))
9809 ret = graphql.Null
9810 }
9811 }()
9812 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9813 ctx = rctx
9814 return ec.resolvers.Query().Shapes(rctx)
9815 })
9816
9817 if resTmp == nil {
9818 return graphql.Null
9819 }
9820 res := resTmp.([]Shape)
9821 fc.Result = res
9822 return ec.marshalOShape2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐShape(ctx, field.Selections, res)
9823 }
9824
9825 func (ec *executionContext) fieldContext_Query_shapes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9826 fc = &graphql.FieldContext{
9827 Object: "Query",
9828 Field: field,
9829 IsMethod: true,
9830 IsResolver: true,
9831 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9832 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
9833 },
9834 }
9835 return fc, nil
9836 }
9837
9838 func (ec *executionContext) _Query_noShape(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9839 fc, err := ec.fieldContext_Query_noShape(ctx, field)
9840 if err != nil {
9841 return graphql.Null
9842 }
9843 ctx = graphql.WithFieldContext(ctx, fc)
9844 defer func() {
9845 if r := recover(); r != nil {
9846 ec.Error(ctx, ec.Recover(ctx, r))
9847 ret = graphql.Null
9848 }
9849 }()
9850 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9851 directive0 := func(rctx context.Context) (interface{}, error) {
9852 ctx = rctx
9853 return ec.resolvers.Query().NoShape(rctx)
9854 }
9855 directive1 := func(ctx context.Context) (interface{}, error) {
9856 if ec.directives.MakeNil == nil {
9857 return nil, errors.New("directive makeNil is not implemented")
9858 }
9859 return ec.directives.MakeNil(ctx, nil, directive0)
9860 }
9861
9862 tmp, err := directive1(rctx)
9863 if err != nil {
9864 return nil, graphql.ErrorOnPath(ctx, err)
9865 }
9866 if tmp == nil {
9867 return nil, nil
9868 }
9869 if data, ok := tmp.(Shape); ok {
9870 return data, nil
9871 }
9872 return nil, fmt.Errorf(`unexpected type %T from directive, should be github.com/99designs/gqlgen/codegen/testserver/singlefile.Shape`, tmp)
9873 })
9874
9875 if resTmp == nil {
9876 return graphql.Null
9877 }
9878 res := resTmp.(Shape)
9879 fc.Result = res
9880 return ec.marshalOShape2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐShape(ctx, field.Selections, res)
9881 }
9882
9883 func (ec *executionContext) fieldContext_Query_noShape(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9884 fc = &graphql.FieldContext{
9885 Object: "Query",
9886 Field: field,
9887 IsMethod: true,
9888 IsResolver: true,
9889 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9890 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
9891 },
9892 }
9893 return fc, nil
9894 }
9895
9896 func (ec *executionContext) _Query_node(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9897 fc, err := ec.fieldContext_Query_node(ctx, field)
9898 if err != nil {
9899 return graphql.Null
9900 }
9901 ctx = graphql.WithFieldContext(ctx, fc)
9902 defer func() {
9903 if r := recover(); r != nil {
9904 ec.Error(ctx, ec.Recover(ctx, r))
9905 ret = graphql.Null
9906 }
9907 }()
9908 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9909 ctx = rctx
9910 return ec.resolvers.Query().Node(rctx)
9911 })
9912
9913 if resTmp == nil {
9914 if !graphql.HasFieldError(ctx, fc) {
9915 ec.Errorf(ctx, "must not be null")
9916 }
9917 return graphql.Null
9918 }
9919 res := resTmp.(Node)
9920 fc.Result = res
9921 return ec.marshalNNode2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐNode(ctx, field.Selections, res)
9922 }
9923
9924 func (ec *executionContext) fieldContext_Query_node(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9925 fc = &graphql.FieldContext{
9926 Object: "Query",
9927 Field: field,
9928 IsMethod: true,
9929 IsResolver: true,
9930 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9931 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
9932 },
9933 }
9934 return fc, nil
9935 }
9936
9937 func (ec *executionContext) _Query_noShapeTypedNil(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9938 fc, err := ec.fieldContext_Query_noShapeTypedNil(ctx, field)
9939 if err != nil {
9940 return graphql.Null
9941 }
9942 ctx = graphql.WithFieldContext(ctx, fc)
9943 defer func() {
9944 if r := recover(); r != nil {
9945 ec.Error(ctx, ec.Recover(ctx, r))
9946 ret = graphql.Null
9947 }
9948 }()
9949 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
9950 directive0 := func(rctx context.Context) (interface{}, error) {
9951 ctx = rctx
9952 return ec.resolvers.Query().NoShapeTypedNil(rctx)
9953 }
9954 directive1 := func(ctx context.Context) (interface{}, error) {
9955 if ec.directives.MakeTypedNil == nil {
9956 return nil, errors.New("directive makeTypedNil is not implemented")
9957 }
9958 return ec.directives.MakeTypedNil(ctx, nil, directive0)
9959 }
9960
9961 tmp, err := directive1(rctx)
9962 if err != nil {
9963 return nil, graphql.ErrorOnPath(ctx, err)
9964 }
9965 if tmp == nil {
9966 return nil, nil
9967 }
9968 if data, ok := tmp.(Shape); ok {
9969 return data, nil
9970 }
9971 return nil, fmt.Errorf(`unexpected type %T from directive, should be github.com/99designs/gqlgen/codegen/testserver/singlefile.Shape`, tmp)
9972 })
9973
9974 if resTmp == nil {
9975 return graphql.Null
9976 }
9977 res := resTmp.(Shape)
9978 fc.Result = res
9979 return ec.marshalOShape2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐShape(ctx, field.Selections, res)
9980 }
9981
9982 func (ec *executionContext) fieldContext_Query_noShapeTypedNil(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
9983 fc = &graphql.FieldContext{
9984 Object: "Query",
9985 Field: field,
9986 IsMethod: true,
9987 IsResolver: true,
9988 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
9989 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
9990 },
9991 }
9992 return fc, nil
9993 }
9994
9995 func (ec *executionContext) _Query_animal(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
9996 fc, err := ec.fieldContext_Query_animal(ctx, field)
9997 if err != nil {
9998 return graphql.Null
9999 }
10000 ctx = graphql.WithFieldContext(ctx, fc)
10001 defer func() {
10002 if r := recover(); r != nil {
10003 ec.Error(ctx, ec.Recover(ctx, r))
10004 ret = graphql.Null
10005 }
10006 }()
10007 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10008 directive0 := func(rctx context.Context) (interface{}, error) {
10009 ctx = rctx
10010 return ec.resolvers.Query().Animal(rctx)
10011 }
10012 directive1 := func(ctx context.Context) (interface{}, error) {
10013 if ec.directives.MakeTypedNil == nil {
10014 return nil, errors.New("directive makeTypedNil is not implemented")
10015 }
10016 return ec.directives.MakeTypedNil(ctx, nil, directive0)
10017 }
10018
10019 tmp, err := directive1(rctx)
10020 if err != nil {
10021 return nil, graphql.ErrorOnPath(ctx, err)
10022 }
10023 if tmp == nil {
10024 return nil, nil
10025 }
10026 if data, ok := tmp.(Animal); ok {
10027 return data, nil
10028 }
10029 return nil, fmt.Errorf(`unexpected type %T from directive, should be github.com/99designs/gqlgen/codegen/testserver/singlefile.Animal`, tmp)
10030 })
10031
10032 if resTmp == nil {
10033 return graphql.Null
10034 }
10035 res := resTmp.(Animal)
10036 fc.Result = res
10037 return ec.marshalOAnimal2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐAnimal(ctx, field.Selections, res)
10038 }
10039
10040 func (ec *executionContext) fieldContext_Query_animal(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10041 fc = &graphql.FieldContext{
10042 Object: "Query",
10043 Field: field,
10044 IsMethod: true,
10045 IsResolver: true,
10046 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10047 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
10048 },
10049 }
10050 return fc, nil
10051 }
10052
10053 func (ec *executionContext) _Query_notAnInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10054 fc, err := ec.fieldContext_Query_notAnInterface(ctx, field)
10055 if err != nil {
10056 return graphql.Null
10057 }
10058 ctx = graphql.WithFieldContext(ctx, fc)
10059 defer func() {
10060 if r := recover(); r != nil {
10061 ec.Error(ctx, ec.Recover(ctx, r))
10062 ret = graphql.Null
10063 }
10064 }()
10065 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10066 ctx = rctx
10067 return ec.resolvers.Query().NotAnInterface(rctx)
10068 })
10069
10070 if resTmp == nil {
10071 return graphql.Null
10072 }
10073 res := resTmp.(BackedByInterface)
10074 fc.Result = res
10075 return ec.marshalOBackedByInterface2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐBackedByInterface(ctx, field.Selections, res)
10076 }
10077
10078 func (ec *executionContext) fieldContext_Query_notAnInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10079 fc = &graphql.FieldContext{
10080 Object: "Query",
10081 Field: field,
10082 IsMethod: true,
10083 IsResolver: true,
10084 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10085 switch field.Name {
10086 case "id":
10087 return ec.fieldContext_BackedByInterface_id(ctx, field)
10088 case "thisShouldBind":
10089 return ec.fieldContext_BackedByInterface_thisShouldBind(ctx, field)
10090 case "thisShouldBindWithError":
10091 return ec.fieldContext_BackedByInterface_thisShouldBindWithError(ctx, field)
10092 }
10093 return nil, fmt.Errorf("no field named %q was found under type BackedByInterface", field.Name)
10094 },
10095 }
10096 return fc, nil
10097 }
10098
10099 func (ec *executionContext) _Query_dog(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10100 fc, err := ec.fieldContext_Query_dog(ctx, field)
10101 if err != nil {
10102 return graphql.Null
10103 }
10104 ctx = graphql.WithFieldContext(ctx, fc)
10105 defer func() {
10106 if r := recover(); r != nil {
10107 ec.Error(ctx, ec.Recover(ctx, r))
10108 ret = graphql.Null
10109 }
10110 }()
10111 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10112 ctx = rctx
10113 return ec.resolvers.Query().Dog(rctx)
10114 })
10115
10116 if resTmp == nil {
10117 return graphql.Null
10118 }
10119 res := resTmp.(*Dog)
10120 fc.Result = res
10121 return ec.marshalODog2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐDog(ctx, field.Selections, res)
10122 }
10123
10124 func (ec *executionContext) fieldContext_Query_dog(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10125 fc = &graphql.FieldContext{
10126 Object: "Query",
10127 Field: field,
10128 IsMethod: true,
10129 IsResolver: true,
10130 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10131 switch field.Name {
10132 case "species":
10133 return ec.fieldContext_Dog_species(ctx, field)
10134 case "size":
10135 return ec.fieldContext_Dog_size(ctx, field)
10136 case "dogBreed":
10137 return ec.fieldContext_Dog_dogBreed(ctx, field)
10138 }
10139 return nil, fmt.Errorf("no field named %q was found under type Dog", field.Name)
10140 },
10141 }
10142 return fc, nil
10143 }
10144
10145 func (ec *executionContext) _Query_issue896a(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10146 fc, err := ec.fieldContext_Query_issue896a(ctx, field)
10147 if err != nil {
10148 return graphql.Null
10149 }
10150 ctx = graphql.WithFieldContext(ctx, fc)
10151 defer func() {
10152 if r := recover(); r != nil {
10153 ec.Error(ctx, ec.Recover(ctx, r))
10154 ret = graphql.Null
10155 }
10156 }()
10157 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10158 ctx = rctx
10159 return ec.resolvers.Query().Issue896a(rctx)
10160 })
10161
10162 if resTmp == nil {
10163 return graphql.Null
10164 }
10165 res := resTmp.([]*CheckIssue896)
10166 fc.Result = res
10167 return ec.marshalOCheckIssue8962ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCheckIssue896ᚄ(ctx, field.Selections, res)
10168 }
10169
10170 func (ec *executionContext) fieldContext_Query_issue896a(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10171 fc = &graphql.FieldContext{
10172 Object: "Query",
10173 Field: field,
10174 IsMethod: true,
10175 IsResolver: true,
10176 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10177 switch field.Name {
10178 case "id":
10179 return ec.fieldContext_CheckIssue896_id(ctx, field)
10180 }
10181 return nil, fmt.Errorf("no field named %q was found under type CheckIssue896", field.Name)
10182 },
10183 }
10184 return fc, nil
10185 }
10186
10187 func (ec *executionContext) _Query_mapStringInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10188 fc, err := ec.fieldContext_Query_mapStringInterface(ctx, field)
10189 if err != nil {
10190 return graphql.Null
10191 }
10192 ctx = graphql.WithFieldContext(ctx, fc)
10193 defer func() {
10194 if r := recover(); r != nil {
10195 ec.Error(ctx, ec.Recover(ctx, r))
10196 ret = graphql.Null
10197 }
10198 }()
10199 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10200 ctx = rctx
10201 return ec.resolvers.Query().MapStringInterface(rctx, fc.Args["in"].(map[string]interface{}))
10202 })
10203
10204 if resTmp == nil {
10205 return graphql.Null
10206 }
10207 res := resTmp.(map[string]interface{})
10208 fc.Result = res
10209 return ec.marshalOMapStringInterfaceType2map(ctx, field.Selections, res)
10210 }
10211
10212 func (ec *executionContext) fieldContext_Query_mapStringInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10213 fc = &graphql.FieldContext{
10214 Object: "Query",
10215 Field: field,
10216 IsMethod: true,
10217 IsResolver: true,
10218 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10219 switch field.Name {
10220 case "a":
10221 return ec.fieldContext_MapStringInterfaceType_a(ctx, field)
10222 case "b":
10223 return ec.fieldContext_MapStringInterfaceType_b(ctx, field)
10224 case "c":
10225 return ec.fieldContext_MapStringInterfaceType_c(ctx, field)
10226 case "nested":
10227 return ec.fieldContext_MapStringInterfaceType_nested(ctx, field)
10228 }
10229 return nil, fmt.Errorf("no field named %q was found under type MapStringInterfaceType", field.Name)
10230 },
10231 }
10232 defer func() {
10233 if r := recover(); r != nil {
10234 err = ec.Recover(ctx, r)
10235 ec.Error(ctx, err)
10236 }
10237 }()
10238 ctx = graphql.WithFieldContext(ctx, fc)
10239 if fc.Args, err = ec.field_Query_mapStringInterface_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
10240 ec.Error(ctx, err)
10241 return fc, err
10242 }
10243 return fc, nil
10244 }
10245
10246 func (ec *executionContext) _Query_mapNestedStringInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10247 fc, err := ec.fieldContext_Query_mapNestedStringInterface(ctx, field)
10248 if err != nil {
10249 return graphql.Null
10250 }
10251 ctx = graphql.WithFieldContext(ctx, fc)
10252 defer func() {
10253 if r := recover(); r != nil {
10254 ec.Error(ctx, ec.Recover(ctx, r))
10255 ret = graphql.Null
10256 }
10257 }()
10258 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10259 ctx = rctx
10260 return ec.resolvers.Query().MapNestedStringInterface(rctx, fc.Args["in"].(*NestedMapInput))
10261 })
10262
10263 if resTmp == nil {
10264 return graphql.Null
10265 }
10266 res := resTmp.(map[string]interface{})
10267 fc.Result = res
10268 return ec.marshalOMapStringInterfaceType2map(ctx, field.Selections, res)
10269 }
10270
10271 func (ec *executionContext) fieldContext_Query_mapNestedStringInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10272 fc = &graphql.FieldContext{
10273 Object: "Query",
10274 Field: field,
10275 IsMethod: true,
10276 IsResolver: true,
10277 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10278 switch field.Name {
10279 case "a":
10280 return ec.fieldContext_MapStringInterfaceType_a(ctx, field)
10281 case "b":
10282 return ec.fieldContext_MapStringInterfaceType_b(ctx, field)
10283 case "c":
10284 return ec.fieldContext_MapStringInterfaceType_c(ctx, field)
10285 case "nested":
10286 return ec.fieldContext_MapStringInterfaceType_nested(ctx, field)
10287 }
10288 return nil, fmt.Errorf("no field named %q was found under type MapStringInterfaceType", field.Name)
10289 },
10290 }
10291 defer func() {
10292 if r := recover(); r != nil {
10293 err = ec.Recover(ctx, r)
10294 ec.Error(ctx, err)
10295 }
10296 }()
10297 ctx = graphql.WithFieldContext(ctx, fc)
10298 if fc.Args, err = ec.field_Query_mapNestedStringInterface_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
10299 ec.Error(ctx, err)
10300 return fc, err
10301 }
10302 return fc, nil
10303 }
10304
10305 func (ec *executionContext) _Query_errorBubble(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10306 fc, err := ec.fieldContext_Query_errorBubble(ctx, field)
10307 if err != nil {
10308 return graphql.Null
10309 }
10310 ctx = graphql.WithFieldContext(ctx, fc)
10311 defer func() {
10312 if r := recover(); r != nil {
10313 ec.Error(ctx, ec.Recover(ctx, r))
10314 ret = graphql.Null
10315 }
10316 }()
10317 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10318 ctx = rctx
10319 return ec.resolvers.Query().ErrorBubble(rctx)
10320 })
10321
10322 if resTmp == nil {
10323 return graphql.Null
10324 }
10325 res := resTmp.(*Error)
10326 fc.Result = res
10327 return ec.marshalOError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐError(ctx, field.Selections, res)
10328 }
10329
10330 func (ec *executionContext) fieldContext_Query_errorBubble(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10331 fc = &graphql.FieldContext{
10332 Object: "Query",
10333 Field: field,
10334 IsMethod: true,
10335 IsResolver: true,
10336 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10337 switch field.Name {
10338 case "id":
10339 return ec.fieldContext_Error_id(ctx, field)
10340 case "errorOnNonRequiredField":
10341 return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
10342 case "errorOnRequiredField":
10343 return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
10344 case "nilOnRequiredField":
10345 return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
10346 }
10347 return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
10348 },
10349 }
10350 return fc, nil
10351 }
10352
10353 func (ec *executionContext) _Query_errorBubbleList(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10354 fc, err := ec.fieldContext_Query_errorBubbleList(ctx, field)
10355 if err != nil {
10356 return graphql.Null
10357 }
10358 ctx = graphql.WithFieldContext(ctx, fc)
10359 defer func() {
10360 if r := recover(); r != nil {
10361 ec.Error(ctx, ec.Recover(ctx, r))
10362 ret = graphql.Null
10363 }
10364 }()
10365 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10366 ctx = rctx
10367 return ec.resolvers.Query().ErrorBubbleList(rctx)
10368 })
10369
10370 if resTmp == nil {
10371 return graphql.Null
10372 }
10373 res := resTmp.([]*Error)
10374 fc.Result = res
10375 return ec.marshalOError2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐErrorᚄ(ctx, field.Selections, res)
10376 }
10377
10378 func (ec *executionContext) fieldContext_Query_errorBubbleList(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10379 fc = &graphql.FieldContext{
10380 Object: "Query",
10381 Field: field,
10382 IsMethod: true,
10383 IsResolver: true,
10384 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10385 switch field.Name {
10386 case "id":
10387 return ec.fieldContext_Error_id(ctx, field)
10388 case "errorOnNonRequiredField":
10389 return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
10390 case "errorOnRequiredField":
10391 return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
10392 case "nilOnRequiredField":
10393 return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
10394 }
10395 return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
10396 },
10397 }
10398 return fc, nil
10399 }
10400
10401 func (ec *executionContext) _Query_errorList(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10402 fc, err := ec.fieldContext_Query_errorList(ctx, field)
10403 if err != nil {
10404 return graphql.Null
10405 }
10406 ctx = graphql.WithFieldContext(ctx, fc)
10407 defer func() {
10408 if r := recover(); r != nil {
10409 ec.Error(ctx, ec.Recover(ctx, r))
10410 ret = graphql.Null
10411 }
10412 }()
10413 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10414 ctx = rctx
10415 return ec.resolvers.Query().ErrorList(rctx)
10416 })
10417
10418 if resTmp == nil {
10419 return graphql.Null
10420 }
10421 res := resTmp.([]*Error)
10422 fc.Result = res
10423 return ec.marshalOError2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐError(ctx, field.Selections, res)
10424 }
10425
10426 func (ec *executionContext) fieldContext_Query_errorList(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10427 fc = &graphql.FieldContext{
10428 Object: "Query",
10429 Field: field,
10430 IsMethod: true,
10431 IsResolver: true,
10432 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10433 switch field.Name {
10434 case "id":
10435 return ec.fieldContext_Error_id(ctx, field)
10436 case "errorOnNonRequiredField":
10437 return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
10438 case "errorOnRequiredField":
10439 return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
10440 case "nilOnRequiredField":
10441 return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
10442 }
10443 return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
10444 },
10445 }
10446 return fc, nil
10447 }
10448
10449 func (ec *executionContext) _Query_errors(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10450 fc, err := ec.fieldContext_Query_errors(ctx, field)
10451 if err != nil {
10452 return graphql.Null
10453 }
10454 ctx = graphql.WithFieldContext(ctx, fc)
10455 defer func() {
10456 if r := recover(); r != nil {
10457 ec.Error(ctx, ec.Recover(ctx, r))
10458 ret = graphql.Null
10459 }
10460 }()
10461 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10462 ctx = rctx
10463 return ec.resolvers.Query().Errors(rctx)
10464 })
10465
10466 if resTmp == nil {
10467 return graphql.Null
10468 }
10469 res := resTmp.(*Errors)
10470 fc.Result = res
10471 return ec.marshalOErrors2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐErrors(ctx, field.Selections, res)
10472 }
10473
10474 func (ec *executionContext) fieldContext_Query_errors(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10475 fc = &graphql.FieldContext{
10476 Object: "Query",
10477 Field: field,
10478 IsMethod: true,
10479 IsResolver: true,
10480 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10481 switch field.Name {
10482 case "a":
10483 return ec.fieldContext_Errors_a(ctx, field)
10484 case "b":
10485 return ec.fieldContext_Errors_b(ctx, field)
10486 case "c":
10487 return ec.fieldContext_Errors_c(ctx, field)
10488 case "d":
10489 return ec.fieldContext_Errors_d(ctx, field)
10490 case "e":
10491 return ec.fieldContext_Errors_e(ctx, field)
10492 }
10493 return nil, fmt.Errorf("no field named %q was found under type Errors", field.Name)
10494 },
10495 }
10496 return fc, nil
10497 }
10498
10499 func (ec *executionContext) _Query_valid(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10500 fc, err := ec.fieldContext_Query_valid(ctx, field)
10501 if err != nil {
10502 return graphql.Null
10503 }
10504 ctx = graphql.WithFieldContext(ctx, fc)
10505 defer func() {
10506 if r := recover(); r != nil {
10507 ec.Error(ctx, ec.Recover(ctx, r))
10508 ret = graphql.Null
10509 }
10510 }()
10511 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10512 ctx = rctx
10513 return ec.resolvers.Query().Valid(rctx)
10514 })
10515
10516 if resTmp == nil {
10517 if !graphql.HasFieldError(ctx, fc) {
10518 ec.Errorf(ctx, "must not be null")
10519 }
10520 return graphql.Null
10521 }
10522 res := resTmp.(string)
10523 fc.Result = res
10524 return ec.marshalNString2string(ctx, field.Selections, res)
10525 }
10526
10527 func (ec *executionContext) fieldContext_Query_valid(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10528 fc = &graphql.FieldContext{
10529 Object: "Query",
10530 Field: field,
10531 IsMethod: true,
10532 IsResolver: true,
10533 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10534 return nil, errors.New("field of type String does not have child fields")
10535 },
10536 }
10537 return fc, nil
10538 }
10539
10540 func (ec *executionContext) _Query_invalid(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10541 fc, err := ec.fieldContext_Query_invalid(ctx, field)
10542 if err != nil {
10543 return graphql.Null
10544 }
10545 ctx = graphql.WithFieldContext(ctx, fc)
10546 defer func() {
10547 if r := recover(); r != nil {
10548 ec.Error(ctx, ec.Recover(ctx, r))
10549 ret = graphql.Null
10550 }
10551 }()
10552 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10553 ctx = rctx
10554 return ec.resolvers.Query().Invalid(rctx)
10555 })
10556
10557 if resTmp == nil {
10558 if !graphql.HasFieldError(ctx, fc) {
10559 ec.Errorf(ctx, "must not be null")
10560 }
10561 return graphql.Null
10562 }
10563 res := resTmp.(string)
10564 fc.Result = res
10565 return ec.marshalNString2string(ctx, field.Selections, res)
10566 }
10567
10568 func (ec *executionContext) fieldContext_Query_invalid(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10569 fc = &graphql.FieldContext{
10570 Object: "Query",
10571 Field: field,
10572 IsMethod: true,
10573 IsResolver: true,
10574 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10575 return nil, errors.New("field of type String does not have child fields")
10576 },
10577 }
10578 return fc, nil
10579 }
10580
10581 func (ec *executionContext) _Query_panics(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10582 fc, err := ec.fieldContext_Query_panics(ctx, field)
10583 if err != nil {
10584 return graphql.Null
10585 }
10586 ctx = graphql.WithFieldContext(ctx, fc)
10587 defer func() {
10588 if r := recover(); r != nil {
10589 ec.Error(ctx, ec.Recover(ctx, r))
10590 ret = graphql.Null
10591 }
10592 }()
10593 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10594 ctx = rctx
10595 return ec.resolvers.Query().Panics(rctx)
10596 })
10597
10598 if resTmp == nil {
10599 return graphql.Null
10600 }
10601 res := resTmp.(*Panics)
10602 fc.Result = res
10603 return ec.marshalOPanics2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPanics(ctx, field.Selections, res)
10604 }
10605
10606 func (ec *executionContext) fieldContext_Query_panics(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10607 fc = &graphql.FieldContext{
10608 Object: "Query",
10609 Field: field,
10610 IsMethod: true,
10611 IsResolver: true,
10612 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10613 switch field.Name {
10614 case "fieldScalarMarshal":
10615 return ec.fieldContext_Panics_fieldScalarMarshal(ctx, field)
10616 case "fieldFuncMarshal":
10617 return ec.fieldContext_Panics_fieldFuncMarshal(ctx, field)
10618 case "argUnmarshal":
10619 return ec.fieldContext_Panics_argUnmarshal(ctx, field)
10620 }
10621 return nil, fmt.Errorf("no field named %q was found under type Panics", field.Name)
10622 },
10623 }
10624 return fc, nil
10625 }
10626
10627 func (ec *executionContext) _Query_primitiveObject(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10628 fc, err := ec.fieldContext_Query_primitiveObject(ctx, field)
10629 if err != nil {
10630 return graphql.Null
10631 }
10632 ctx = graphql.WithFieldContext(ctx, fc)
10633 defer func() {
10634 if r := recover(); r != nil {
10635 ec.Error(ctx, ec.Recover(ctx, r))
10636 ret = graphql.Null
10637 }
10638 }()
10639 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10640 ctx = rctx
10641 return ec.resolvers.Query().PrimitiveObject(rctx)
10642 })
10643
10644 if resTmp == nil {
10645 if !graphql.HasFieldError(ctx, fc) {
10646 ec.Errorf(ctx, "must not be null")
10647 }
10648 return graphql.Null
10649 }
10650 res := resTmp.([]Primitive)
10651 fc.Result = res
10652 return ec.marshalNPrimitive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPrimitiveᚄ(ctx, field.Selections, res)
10653 }
10654
10655 func (ec *executionContext) fieldContext_Query_primitiveObject(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10656 fc = &graphql.FieldContext{
10657 Object: "Query",
10658 Field: field,
10659 IsMethod: true,
10660 IsResolver: true,
10661 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10662 switch field.Name {
10663 case "value":
10664 return ec.fieldContext_Primitive_value(ctx, field)
10665 case "squared":
10666 return ec.fieldContext_Primitive_squared(ctx, field)
10667 }
10668 return nil, fmt.Errorf("no field named %q was found under type Primitive", field.Name)
10669 },
10670 }
10671 return fc, nil
10672 }
10673
10674 func (ec *executionContext) _Query_primitiveStringObject(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10675 fc, err := ec.fieldContext_Query_primitiveStringObject(ctx, field)
10676 if err != nil {
10677 return graphql.Null
10678 }
10679 ctx = graphql.WithFieldContext(ctx, fc)
10680 defer func() {
10681 if r := recover(); r != nil {
10682 ec.Error(ctx, ec.Recover(ctx, r))
10683 ret = graphql.Null
10684 }
10685 }()
10686 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10687 ctx = rctx
10688 return ec.resolvers.Query().PrimitiveStringObject(rctx)
10689 })
10690
10691 if resTmp == nil {
10692 if !graphql.HasFieldError(ctx, fc) {
10693 ec.Errorf(ctx, "must not be null")
10694 }
10695 return graphql.Null
10696 }
10697 res := resTmp.([]PrimitiveString)
10698 fc.Result = res
10699 return ec.marshalNPrimitiveString2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPrimitiveStringᚄ(ctx, field.Selections, res)
10700 }
10701
10702 func (ec *executionContext) fieldContext_Query_primitiveStringObject(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10703 fc = &graphql.FieldContext{
10704 Object: "Query",
10705 Field: field,
10706 IsMethod: true,
10707 IsResolver: true,
10708 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10709 switch field.Name {
10710 case "value":
10711 return ec.fieldContext_PrimitiveString_value(ctx, field)
10712 case "doubled":
10713 return ec.fieldContext_PrimitiveString_doubled(ctx, field)
10714 case "len":
10715 return ec.fieldContext_PrimitiveString_len(ctx, field)
10716 }
10717 return nil, fmt.Errorf("no field named %q was found under type PrimitiveString", field.Name)
10718 },
10719 }
10720 return fc, nil
10721 }
10722
10723 func (ec *executionContext) _Query_ptrToAnyContainer(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10724 fc, err := ec.fieldContext_Query_ptrToAnyContainer(ctx, field)
10725 if err != nil {
10726 return graphql.Null
10727 }
10728 ctx = graphql.WithFieldContext(ctx, fc)
10729 defer func() {
10730 if r := recover(); r != nil {
10731 ec.Error(ctx, ec.Recover(ctx, r))
10732 ret = graphql.Null
10733 }
10734 }()
10735 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10736 ctx = rctx
10737 return ec.resolvers.Query().PtrToAnyContainer(rctx)
10738 })
10739
10740 if resTmp == nil {
10741 if !graphql.HasFieldError(ctx, fc) {
10742 ec.Errorf(ctx, "must not be null")
10743 }
10744 return graphql.Null
10745 }
10746 res := resTmp.(*PtrToAnyContainer)
10747 fc.Result = res
10748 return ec.marshalNPtrToAnyContainer2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToAnyContainer(ctx, field.Selections, res)
10749 }
10750
10751 func (ec *executionContext) fieldContext_Query_ptrToAnyContainer(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10752 fc = &graphql.FieldContext{
10753 Object: "Query",
10754 Field: field,
10755 IsMethod: true,
10756 IsResolver: true,
10757 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10758 switch field.Name {
10759 case "ptrToAny":
10760 return ec.fieldContext_PtrToAnyContainer_ptrToAny(ctx, field)
10761 case "binding":
10762 return ec.fieldContext_PtrToAnyContainer_binding(ctx, field)
10763 }
10764 return nil, fmt.Errorf("no field named %q was found under type PtrToAnyContainer", field.Name)
10765 },
10766 }
10767 return fc, nil
10768 }
10769
10770 func (ec *executionContext) _Query_ptrToSliceContainer(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10771 fc, err := ec.fieldContext_Query_ptrToSliceContainer(ctx, field)
10772 if err != nil {
10773 return graphql.Null
10774 }
10775 ctx = graphql.WithFieldContext(ctx, fc)
10776 defer func() {
10777 if r := recover(); r != nil {
10778 ec.Error(ctx, ec.Recover(ctx, r))
10779 ret = graphql.Null
10780 }
10781 }()
10782 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10783 ctx = rctx
10784 return ec.resolvers.Query().PtrToSliceContainer(rctx)
10785 })
10786
10787 if resTmp == nil {
10788 if !graphql.HasFieldError(ctx, fc) {
10789 ec.Errorf(ctx, "must not be null")
10790 }
10791 return graphql.Null
10792 }
10793 res := resTmp.(*PtrToSliceContainer)
10794 fc.Result = res
10795 return ec.marshalNPtrToSliceContainer2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToSliceContainer(ctx, field.Selections, res)
10796 }
10797
10798 func (ec *executionContext) fieldContext_Query_ptrToSliceContainer(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10799 fc = &graphql.FieldContext{
10800 Object: "Query",
10801 Field: field,
10802 IsMethod: true,
10803 IsResolver: true,
10804 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10805 switch field.Name {
10806 case "ptrToSlice":
10807 return ec.fieldContext_PtrToSliceContainer_ptrToSlice(ctx, field)
10808 }
10809 return nil, fmt.Errorf("no field named %q was found under type PtrToSliceContainer", field.Name)
10810 },
10811 }
10812 return fc, nil
10813 }
10814
10815 func (ec *executionContext) _Query_infinity(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10816 fc, err := ec.fieldContext_Query_infinity(ctx, field)
10817 if err != nil {
10818 return graphql.Null
10819 }
10820 ctx = graphql.WithFieldContext(ctx, fc)
10821 defer func() {
10822 if r := recover(); r != nil {
10823 ec.Error(ctx, ec.Recover(ctx, r))
10824 ret = graphql.Null
10825 }
10826 }()
10827 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10828 ctx = rctx
10829 return ec.resolvers.Query().Infinity(rctx)
10830 })
10831
10832 if resTmp == nil {
10833 if !graphql.HasFieldError(ctx, fc) {
10834 ec.Errorf(ctx, "must not be null")
10835 }
10836 return graphql.Null
10837 }
10838 res := resTmp.(float64)
10839 fc.Result = res
10840 return ec.marshalNFloat2float64(ctx, field.Selections, res)
10841 }
10842
10843 func (ec *executionContext) fieldContext_Query_infinity(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10844 fc = &graphql.FieldContext{
10845 Object: "Query",
10846 Field: field,
10847 IsMethod: true,
10848 IsResolver: true,
10849 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10850 return nil, errors.New("field of type Float does not have child fields")
10851 },
10852 }
10853 return fc, nil
10854 }
10855
10856 func (ec *executionContext) _Query_stringFromContextInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10857 fc, err := ec.fieldContext_Query_stringFromContextInterface(ctx, field)
10858 if err != nil {
10859 return graphql.Null
10860 }
10861 ctx = graphql.WithFieldContext(ctx, fc)
10862 defer func() {
10863 if r := recover(); r != nil {
10864 ec.Error(ctx, ec.Recover(ctx, r))
10865 ret = graphql.Null
10866 }
10867 }()
10868 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10869 ctx = rctx
10870 return ec.resolvers.Query().StringFromContextInterface(rctx)
10871 })
10872
10873 if resTmp == nil {
10874 if !graphql.HasFieldError(ctx, fc) {
10875 ec.Errorf(ctx, "must not be null")
10876 }
10877 return graphql.Null
10878 }
10879 res := resTmp.(*StringFromContextInterface)
10880 fc.Result = res
10881 return ec.marshalNStringFromContextInterface2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐStringFromContextInterface(ctx, field.Selections, res)
10882 }
10883
10884 func (ec *executionContext) fieldContext_Query_stringFromContextInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10885 fc = &graphql.FieldContext{
10886 Object: "Query",
10887 Field: field,
10888 IsMethod: true,
10889 IsResolver: true,
10890 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10891 return nil, errors.New("field of type StringFromContextInterface does not have child fields")
10892 },
10893 }
10894 return fc, nil
10895 }
10896
10897 func (ec *executionContext) _Query_stringFromContextFunction(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10898 fc, err := ec.fieldContext_Query_stringFromContextFunction(ctx, field)
10899 if err != nil {
10900 return graphql.Null
10901 }
10902 ctx = graphql.WithFieldContext(ctx, fc)
10903 defer func() {
10904 if r := recover(); r != nil {
10905 ec.Error(ctx, ec.Recover(ctx, r))
10906 ret = graphql.Null
10907 }
10908 }()
10909 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10910 ctx = rctx
10911 return ec.resolvers.Query().StringFromContextFunction(rctx)
10912 })
10913
10914 if resTmp == nil {
10915 if !graphql.HasFieldError(ctx, fc) {
10916 ec.Errorf(ctx, "must not be null")
10917 }
10918 return graphql.Null
10919 }
10920 res := resTmp.(string)
10921 fc.Result = res
10922 return ec.marshalNStringFromContextFunction2string(ctx, field.Selections, res)
10923 }
10924
10925 func (ec *executionContext) fieldContext_Query_stringFromContextFunction(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10926 fc = &graphql.FieldContext{
10927 Object: "Query",
10928 Field: field,
10929 IsMethod: true,
10930 IsResolver: true,
10931 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10932 return nil, errors.New("field of type StringFromContextFunction does not have child fields")
10933 },
10934 }
10935 return fc, nil
10936 }
10937
10938 func (ec *executionContext) _Query_defaultScalar(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10939 fc, err := ec.fieldContext_Query_defaultScalar(ctx, field)
10940 if err != nil {
10941 return graphql.Null
10942 }
10943 ctx = graphql.WithFieldContext(ctx, fc)
10944 defer func() {
10945 if r := recover(); r != nil {
10946 ec.Error(ctx, ec.Recover(ctx, r))
10947 ret = graphql.Null
10948 }
10949 }()
10950 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
10951 ctx = rctx
10952 return ec.resolvers.Query().DefaultScalar(rctx, fc.Args["arg"].(string))
10953 })
10954
10955 if resTmp == nil {
10956 if !graphql.HasFieldError(ctx, fc) {
10957 ec.Errorf(ctx, "must not be null")
10958 }
10959 return graphql.Null
10960 }
10961 res := resTmp.(string)
10962 fc.Result = res
10963 return ec.marshalNDefaultScalarImplementation2string(ctx, field.Selections, res)
10964 }
10965
10966 func (ec *executionContext) fieldContext_Query_defaultScalar(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
10967 fc = &graphql.FieldContext{
10968 Object: "Query",
10969 Field: field,
10970 IsMethod: true,
10971 IsResolver: true,
10972 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
10973 return nil, errors.New("field of type DefaultScalarImplementation does not have child fields")
10974 },
10975 }
10976 defer func() {
10977 if r := recover(); r != nil {
10978 err = ec.Recover(ctx, r)
10979 ec.Error(ctx, err)
10980 }
10981 }()
10982 ctx = graphql.WithFieldContext(ctx, fc)
10983 if fc.Args, err = ec.field_Query_defaultScalar_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
10984 ec.Error(ctx, err)
10985 return fc, err
10986 }
10987 return fc, nil
10988 }
10989
10990 func (ec *executionContext) _Query_slices(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
10991 fc, err := ec.fieldContext_Query_slices(ctx, field)
10992 if err != nil {
10993 return graphql.Null
10994 }
10995 ctx = graphql.WithFieldContext(ctx, fc)
10996 defer func() {
10997 if r := recover(); r != nil {
10998 ec.Error(ctx, ec.Recover(ctx, r))
10999 ret = graphql.Null
11000 }
11001 }()
11002 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
11003 ctx = rctx
11004 return ec.resolvers.Query().Slices(rctx)
11005 })
11006
11007 if resTmp == nil {
11008 return graphql.Null
11009 }
11010 res := resTmp.(*Slices)
11011 fc.Result = res
11012 return ec.marshalOSlices2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐSlices(ctx, field.Selections, res)
11013 }
11014
11015 func (ec *executionContext) fieldContext_Query_slices(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11016 fc = &graphql.FieldContext{
11017 Object: "Query",
11018 Field: field,
11019 IsMethod: true,
11020 IsResolver: true,
11021 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11022 switch field.Name {
11023 case "test1":
11024 return ec.fieldContext_Slices_test1(ctx, field)
11025 case "test2":
11026 return ec.fieldContext_Slices_test2(ctx, field)
11027 case "test3":
11028 return ec.fieldContext_Slices_test3(ctx, field)
11029 case "test4":
11030 return ec.fieldContext_Slices_test4(ctx, field)
11031 }
11032 return nil, fmt.Errorf("no field named %q was found under type Slices", field.Name)
11033 },
11034 }
11035 return fc, nil
11036 }
11037
11038 func (ec *executionContext) _Query_scalarSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
11039 fc, err := ec.fieldContext_Query_scalarSlice(ctx, field)
11040 if err != nil {
11041 return graphql.Null
11042 }
11043 ctx = graphql.WithFieldContext(ctx, fc)
11044 defer func() {
11045 if r := recover(); r != nil {
11046 ec.Error(ctx, ec.Recover(ctx, r))
11047 ret = graphql.Null
11048 }
11049 }()
11050 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
11051 ctx = rctx
11052 return ec.resolvers.Query().ScalarSlice(rctx)
11053 })
11054
11055 if resTmp == nil {
11056 if !graphql.HasFieldError(ctx, fc) {
11057 ec.Errorf(ctx, "must not be null")
11058 }
11059 return graphql.Null
11060 }
11061 res := resTmp.([]byte)
11062 fc.Result = res
11063 return ec.marshalNBytes2ᚕbyte(ctx, field.Selections, res)
11064 }
11065
11066 func (ec *executionContext) fieldContext_Query_scalarSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11067 fc = &graphql.FieldContext{
11068 Object: "Query",
11069 Field: field,
11070 IsMethod: true,
11071 IsResolver: true,
11072 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11073 return nil, errors.New("field of type Bytes does not have child fields")
11074 },
11075 }
11076 return fc, nil
11077 }
11078
11079 func (ec *executionContext) _Query_fallback(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
11080 fc, err := ec.fieldContext_Query_fallback(ctx, field)
11081 if err != nil {
11082 return graphql.Null
11083 }
11084 ctx = graphql.WithFieldContext(ctx, fc)
11085 defer func() {
11086 if r := recover(); r != nil {
11087 ec.Error(ctx, ec.Recover(ctx, r))
11088 ret = graphql.Null
11089 }
11090 }()
11091 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
11092 ctx = rctx
11093 return ec.resolvers.Query().Fallback(rctx, fc.Args["arg"].(FallbackToStringEncoding))
11094 })
11095
11096 if resTmp == nil {
11097 if !graphql.HasFieldError(ctx, fc) {
11098 ec.Errorf(ctx, "must not be null")
11099 }
11100 return graphql.Null
11101 }
11102 res := resTmp.(FallbackToStringEncoding)
11103 fc.Result = res
11104 return ec.marshalNFallbackToStringEncoding2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐFallbackToStringEncoding(ctx, field.Selections, res)
11105 }
11106
11107 func (ec *executionContext) fieldContext_Query_fallback(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11108 fc = &graphql.FieldContext{
11109 Object: "Query",
11110 Field: field,
11111 IsMethod: true,
11112 IsResolver: true,
11113 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11114 return nil, errors.New("field of type FallbackToStringEncoding does not have child fields")
11115 },
11116 }
11117 defer func() {
11118 if r := recover(); r != nil {
11119 err = ec.Recover(ctx, r)
11120 ec.Error(ctx, err)
11121 }
11122 }()
11123 ctx = graphql.WithFieldContext(ctx, fc)
11124 if fc.Args, err = ec.field_Query_fallback_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
11125 ec.Error(ctx, err)
11126 return fc, err
11127 }
11128 return fc, nil
11129 }
11130
11131 func (ec *executionContext) _Query_optionalUnion(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
11132 fc, err := ec.fieldContext_Query_optionalUnion(ctx, field)
11133 if err != nil {
11134 return graphql.Null
11135 }
11136 ctx = graphql.WithFieldContext(ctx, fc)
11137 defer func() {
11138 if r := recover(); r != nil {
11139 ec.Error(ctx, ec.Recover(ctx, r))
11140 ret = graphql.Null
11141 }
11142 }()
11143 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
11144 ctx = rctx
11145 return ec.resolvers.Query().OptionalUnion(rctx)
11146 })
11147
11148 if resTmp == nil {
11149 return graphql.Null
11150 }
11151 res := resTmp.(TestUnion)
11152 fc.Result = res
11153 return ec.marshalOTestUnion2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐTestUnion(ctx, field.Selections, res)
11154 }
11155
11156 func (ec *executionContext) fieldContext_Query_optionalUnion(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11157 fc = &graphql.FieldContext{
11158 Object: "Query",
11159 Field: field,
11160 IsMethod: true,
11161 IsResolver: true,
11162 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11163 return nil, errors.New("field of type TestUnion does not have child fields")
11164 },
11165 }
11166 return fc, nil
11167 }
11168
11169 func (ec *executionContext) _Query_vOkCaseValue(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
11170 fc, err := ec.fieldContext_Query_vOkCaseValue(ctx, field)
11171 if err != nil {
11172 return graphql.Null
11173 }
11174 ctx = graphql.WithFieldContext(ctx, fc)
11175 defer func() {
11176 if r := recover(); r != nil {
11177 ec.Error(ctx, ec.Recover(ctx, r))
11178 ret = graphql.Null
11179 }
11180 }()
11181 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
11182 ctx = rctx
11183 return ec.resolvers.Query().VOkCaseValue(rctx)
11184 })
11185
11186 if resTmp == nil {
11187 return graphql.Null
11188 }
11189 res := resTmp.(*VOkCaseValue)
11190 fc.Result = res
11191 return ec.marshalOVOkCaseValue2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐVOkCaseValue(ctx, field.Selections, res)
11192 }
11193
11194 func (ec *executionContext) fieldContext_Query_vOkCaseValue(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11195 fc = &graphql.FieldContext{
11196 Object: "Query",
11197 Field: field,
11198 IsMethod: true,
11199 IsResolver: true,
11200 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11201 switch field.Name {
11202 case "value":
11203 return ec.fieldContext_VOkCaseValue_value(ctx, field)
11204 }
11205 return nil, fmt.Errorf("no field named %q was found under type VOkCaseValue", field.Name)
11206 },
11207 }
11208 return fc, nil
11209 }
11210
11211 func (ec *executionContext) _Query_vOkCaseNil(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
11212 fc, err := ec.fieldContext_Query_vOkCaseNil(ctx, field)
11213 if err != nil {
11214 return graphql.Null
11215 }
11216 ctx = graphql.WithFieldContext(ctx, fc)
11217 defer func() {
11218 if r := recover(); r != nil {
11219 ec.Error(ctx, ec.Recover(ctx, r))
11220 ret = graphql.Null
11221 }
11222 }()
11223 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
11224 ctx = rctx
11225 return ec.resolvers.Query().VOkCaseNil(rctx)
11226 })
11227
11228 if resTmp == nil {
11229 return graphql.Null
11230 }
11231 res := resTmp.(*VOkCaseNil)
11232 fc.Result = res
11233 return ec.marshalOVOkCaseNil2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐVOkCaseNil(ctx, field.Selections, res)
11234 }
11235
11236 func (ec *executionContext) fieldContext_Query_vOkCaseNil(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11237 fc = &graphql.FieldContext{
11238 Object: "Query",
11239 Field: field,
11240 IsMethod: true,
11241 IsResolver: true,
11242 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11243 switch field.Name {
11244 case "value":
11245 return ec.fieldContext_VOkCaseNil_value(ctx, field)
11246 }
11247 return nil, fmt.Errorf("no field named %q was found under type VOkCaseNil", field.Name)
11248 },
11249 }
11250 return fc, nil
11251 }
11252
11253 func (ec *executionContext) _Query_validType(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
11254 fc, err := ec.fieldContext_Query_validType(ctx, field)
11255 if err != nil {
11256 return graphql.Null
11257 }
11258 ctx = graphql.WithFieldContext(ctx, fc)
11259 defer func() {
11260 if r := recover(); r != nil {
11261 ec.Error(ctx, ec.Recover(ctx, r))
11262 ret = graphql.Null
11263 }
11264 }()
11265 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
11266 ctx = rctx
11267 return ec.resolvers.Query().ValidType(rctx)
11268 })
11269
11270 if resTmp == nil {
11271 return graphql.Null
11272 }
11273 res := resTmp.(*ValidType)
11274 fc.Result = res
11275 return ec.marshalOValidType2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐValidType(ctx, field.Selections, res)
11276 }
11277
11278 func (ec *executionContext) fieldContext_Query_validType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11279 fc = &graphql.FieldContext{
11280 Object: "Query",
11281 Field: field,
11282 IsMethod: true,
11283 IsResolver: true,
11284 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11285 switch field.Name {
11286 case "differentCase":
11287 return ec.fieldContext_ValidType_differentCase(ctx, field)
11288 case "different_case":
11289 return ec.fieldContext_ValidType_different_case(ctx, field)
11290 case "validInputKeywords":
11291 return ec.fieldContext_ValidType_validInputKeywords(ctx, field)
11292 case "validArgs":
11293 return ec.fieldContext_ValidType_validArgs(ctx, field)
11294 }
11295 return nil, fmt.Errorf("no field named %q was found under type ValidType", field.Name)
11296 },
11297 }
11298 return fc, nil
11299 }
11300
11301 func (ec *executionContext) _Query_variadicModel(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
11302 fc, err := ec.fieldContext_Query_variadicModel(ctx, field)
11303 if err != nil {
11304 return graphql.Null
11305 }
11306 ctx = graphql.WithFieldContext(ctx, fc)
11307 defer func() {
11308 if r := recover(); r != nil {
11309 ec.Error(ctx, ec.Recover(ctx, r))
11310 ret = graphql.Null
11311 }
11312 }()
11313 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
11314 ctx = rctx
11315 return ec.resolvers.Query().VariadicModel(rctx)
11316 })
11317
11318 if resTmp == nil {
11319 return graphql.Null
11320 }
11321 res := resTmp.(*VariadicModel)
11322 fc.Result = res
11323 return ec.marshalOVariadicModel2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐVariadicModel(ctx, field.Selections, res)
11324 }
11325
11326 func (ec *executionContext) fieldContext_Query_variadicModel(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11327 fc = &graphql.FieldContext{
11328 Object: "Query",
11329 Field: field,
11330 IsMethod: true,
11331 IsResolver: true,
11332 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11333 switch field.Name {
11334 case "value":
11335 return ec.fieldContext_VariadicModel_value(ctx, field)
11336 }
11337 return nil, fmt.Errorf("no field named %q was found under type VariadicModel", field.Name)
11338 },
11339 }
11340 return fc, nil
11341 }
11342
11343 func (ec *executionContext) _Query_wrappedStruct(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
11344 fc, err := ec.fieldContext_Query_wrappedStruct(ctx, field)
11345 if err != nil {
11346 return graphql.Null
11347 }
11348 ctx = graphql.WithFieldContext(ctx, fc)
11349 defer func() {
11350 if r := recover(); r != nil {
11351 ec.Error(ctx, ec.Recover(ctx, r))
11352 ret = graphql.Null
11353 }
11354 }()
11355 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
11356 ctx = rctx
11357 return ec.resolvers.Query().WrappedStruct(rctx)
11358 })
11359
11360 if resTmp == nil {
11361 if !graphql.HasFieldError(ctx, fc) {
11362 ec.Errorf(ctx, "must not be null")
11363 }
11364 return graphql.Null
11365 }
11366 res := resTmp.(*WrappedStruct)
11367 fc.Result = res
11368 return ec.marshalNWrappedStruct2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐWrappedStruct(ctx, field.Selections, res)
11369 }
11370
11371 func (ec *executionContext) fieldContext_Query_wrappedStruct(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11372 fc = &graphql.FieldContext{
11373 Object: "Query",
11374 Field: field,
11375 IsMethod: true,
11376 IsResolver: true,
11377 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11378 switch field.Name {
11379 case "name":
11380 return ec.fieldContext_WrappedStruct_name(ctx, field)
11381 case "desc":
11382 return ec.fieldContext_WrappedStruct_desc(ctx, field)
11383 }
11384 return nil, fmt.Errorf("no field named %q was found under type WrappedStruct", field.Name)
11385 },
11386 }
11387 return fc, nil
11388 }
11389
11390 func (ec *executionContext) _Query_wrappedScalar(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
11391 fc, err := ec.fieldContext_Query_wrappedScalar(ctx, field)
11392 if err != nil {
11393 return graphql.Null
11394 }
11395 ctx = graphql.WithFieldContext(ctx, fc)
11396 defer func() {
11397 if r := recover(); r != nil {
11398 ec.Error(ctx, ec.Recover(ctx, r))
11399 ret = graphql.Null
11400 }
11401 }()
11402 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
11403 ctx = rctx
11404 return ec.resolvers.Query().WrappedScalar(rctx)
11405 })
11406
11407 if resTmp == nil {
11408 if !graphql.HasFieldError(ctx, fc) {
11409 ec.Errorf(ctx, "must not be null")
11410 }
11411 return graphql.Null
11412 }
11413 res := resTmp.(otherpkg.Scalar)
11414 fc.Result = res
11415 return ec.marshalNWrappedScalar2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚋotherpkgᚐScalar(ctx, field.Selections, res)
11416 }
11417
11418 func (ec *executionContext) fieldContext_Query_wrappedScalar(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11419 fc = &graphql.FieldContext{
11420 Object: "Query",
11421 Field: field,
11422 IsMethod: true,
11423 IsResolver: true,
11424 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11425 return nil, errors.New("field of type WrappedScalar does not have child fields")
11426 },
11427 }
11428 return fc, nil
11429 }
11430
11431 func (ec *executionContext) _Query_wrappedMap(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
11432 fc, err := ec.fieldContext_Query_wrappedMap(ctx, field)
11433 if err != nil {
11434 return graphql.Null
11435 }
11436 ctx = graphql.WithFieldContext(ctx, fc)
11437 defer func() {
11438 if r := recover(); r != nil {
11439 ec.Error(ctx, ec.Recover(ctx, r))
11440 ret = graphql.Null
11441 }
11442 }()
11443 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
11444 ctx = rctx
11445 return ec.resolvers.Query().WrappedMap(rctx)
11446 })
11447
11448 if resTmp == nil {
11449 if !graphql.HasFieldError(ctx, fc) {
11450 ec.Errorf(ctx, "must not be null")
11451 }
11452 return graphql.Null
11453 }
11454 res := resTmp.(WrappedMap)
11455 fc.Result = res
11456 return ec.marshalNWrappedMap2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐWrappedMap(ctx, field.Selections, res)
11457 }
11458
11459 func (ec *executionContext) fieldContext_Query_wrappedMap(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11460 fc = &graphql.FieldContext{
11461 Object: "Query",
11462 Field: field,
11463 IsMethod: true,
11464 IsResolver: true,
11465 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11466 switch field.Name {
11467 case "get":
11468 return ec.fieldContext_WrappedMap_get(ctx, field)
11469 }
11470 return nil, fmt.Errorf("no field named %q was found under type WrappedMap", field.Name)
11471 },
11472 }
11473 return fc, nil
11474 }
11475
11476 func (ec *executionContext) _Query_wrappedSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
11477 fc, err := ec.fieldContext_Query_wrappedSlice(ctx, field)
11478 if err != nil {
11479 return graphql.Null
11480 }
11481 ctx = graphql.WithFieldContext(ctx, fc)
11482 defer func() {
11483 if r := recover(); r != nil {
11484 ec.Error(ctx, ec.Recover(ctx, r))
11485 ret = graphql.Null
11486 }
11487 }()
11488 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
11489 ctx = rctx
11490 return ec.resolvers.Query().WrappedSlice(rctx)
11491 })
11492
11493 if resTmp == nil {
11494 if !graphql.HasFieldError(ctx, fc) {
11495 ec.Errorf(ctx, "must not be null")
11496 }
11497 return graphql.Null
11498 }
11499 res := resTmp.(WrappedSlice)
11500 fc.Result = res
11501 return ec.marshalNWrappedSlice2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐWrappedSlice(ctx, field.Selections, res)
11502 }
11503
11504 func (ec *executionContext) fieldContext_Query_wrappedSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11505 fc = &graphql.FieldContext{
11506 Object: "Query",
11507 Field: field,
11508 IsMethod: true,
11509 IsResolver: true,
11510 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11511 switch field.Name {
11512 case "get":
11513 return ec.fieldContext_WrappedSlice_get(ctx, field)
11514 }
11515 return nil, fmt.Errorf("no field named %q was found under type WrappedSlice", field.Name)
11516 },
11517 }
11518 return fc, nil
11519 }
11520
11521 func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
11522 fc, err := ec.fieldContext_Query___type(ctx, field)
11523 if err != nil {
11524 return graphql.Null
11525 }
11526 ctx = graphql.WithFieldContext(ctx, fc)
11527 defer func() {
11528 if r := recover(); r != nil {
11529 ec.Error(ctx, ec.Recover(ctx, r))
11530 ret = graphql.Null
11531 }
11532 }()
11533 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
11534 ctx = rctx
11535 return ec.introspectType(fc.Args["name"].(string))
11536 })
11537
11538 if resTmp == nil {
11539 return graphql.Null
11540 }
11541 res := resTmp.(*introspection.Type)
11542 fc.Result = res
11543 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
11544 }
11545
11546 func (ec *executionContext) fieldContext_Query___type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11547 fc = &graphql.FieldContext{
11548 Object: "Query",
11549 Field: field,
11550 IsMethod: true,
11551 IsResolver: false,
11552 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11553 switch field.Name {
11554 case "kind":
11555 return ec.fieldContext___Type_kind(ctx, field)
11556 case "name":
11557 return ec.fieldContext___Type_name(ctx, field)
11558 case "description":
11559 return ec.fieldContext___Type_description(ctx, field)
11560 case "fields":
11561 return ec.fieldContext___Type_fields(ctx, field)
11562 case "interfaces":
11563 return ec.fieldContext___Type_interfaces(ctx, field)
11564 case "possibleTypes":
11565 return ec.fieldContext___Type_possibleTypes(ctx, field)
11566 case "enumValues":
11567 return ec.fieldContext___Type_enumValues(ctx, field)
11568 case "inputFields":
11569 return ec.fieldContext___Type_inputFields(ctx, field)
11570 case "ofType":
11571 return ec.fieldContext___Type_ofType(ctx, field)
11572 case "specifiedByURL":
11573 return ec.fieldContext___Type_specifiedByURL(ctx, field)
11574 }
11575 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
11576 },
11577 }
11578 defer func() {
11579 if r := recover(); r != nil {
11580 err = ec.Recover(ctx, r)
11581 ec.Error(ctx, err)
11582 }
11583 }()
11584 ctx = graphql.WithFieldContext(ctx, fc)
11585 if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
11586 ec.Error(ctx, err)
11587 return fc, err
11588 }
11589 return fc, nil
11590 }
11591
11592 func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
11593 fc, err := ec.fieldContext_Query___schema(ctx, field)
11594 if err != nil {
11595 return graphql.Null
11596 }
11597 ctx = graphql.WithFieldContext(ctx, fc)
11598 defer func() {
11599 if r := recover(); r != nil {
11600 ec.Error(ctx, ec.Recover(ctx, r))
11601 ret = graphql.Null
11602 }
11603 }()
11604 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
11605 ctx = rctx
11606 return ec.introspectSchema()
11607 })
11608
11609 if resTmp == nil {
11610 return graphql.Null
11611 }
11612 res := resTmp.(*introspection.Schema)
11613 fc.Result = res
11614 return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
11615 }
11616
11617 func (ec *executionContext) fieldContext_Query___schema(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11618 fc = &graphql.FieldContext{
11619 Object: "Query",
11620 Field: field,
11621 IsMethod: true,
11622 IsResolver: false,
11623 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11624 switch field.Name {
11625 case "description":
11626 return ec.fieldContext___Schema_description(ctx, field)
11627 case "types":
11628 return ec.fieldContext___Schema_types(ctx, field)
11629 case "queryType":
11630 return ec.fieldContext___Schema_queryType(ctx, field)
11631 case "mutationType":
11632 return ec.fieldContext___Schema_mutationType(ctx, field)
11633 case "subscriptionType":
11634 return ec.fieldContext___Schema_subscriptionType(ctx, field)
11635 case "directives":
11636 return ec.fieldContext___Schema_directives(ctx, field)
11637 }
11638 return nil, fmt.Errorf("no field named %q was found under type __Schema", field.Name)
11639 },
11640 }
11641 return fc, nil
11642 }
11643
11644 func (ec *executionContext) _Rectangle_length(ctx context.Context, field graphql.CollectedField, obj *Rectangle) (ret graphql.Marshaler) {
11645 fc, err := ec.fieldContext_Rectangle_length(ctx, field)
11646 if err != nil {
11647 return graphql.Null
11648 }
11649 ctx = graphql.WithFieldContext(ctx, fc)
11650 defer func() {
11651 if r := recover(); r != nil {
11652 ec.Error(ctx, ec.Recover(ctx, r))
11653 ret = graphql.Null
11654 }
11655 }()
11656 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
11657 ctx = rctx
11658 return obj.Length, nil
11659 })
11660
11661 if resTmp == nil {
11662 return graphql.Null
11663 }
11664 res := resTmp.(float64)
11665 fc.Result = res
11666 return ec.marshalOFloat2float64(ctx, field.Selections, res)
11667 }
11668
11669 func (ec *executionContext) fieldContext_Rectangle_length(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11670 fc = &graphql.FieldContext{
11671 Object: "Rectangle",
11672 Field: field,
11673 IsMethod: false,
11674 IsResolver: false,
11675 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11676 return nil, errors.New("field of type Float does not have child fields")
11677 },
11678 }
11679 return fc, nil
11680 }
11681
11682 func (ec *executionContext) _Rectangle_width(ctx context.Context, field graphql.CollectedField, obj *Rectangle) (ret graphql.Marshaler) {
11683 fc, err := ec.fieldContext_Rectangle_width(ctx, field)
11684 if err != nil {
11685 return graphql.Null
11686 }
11687 ctx = graphql.WithFieldContext(ctx, fc)
11688 defer func() {
11689 if r := recover(); r != nil {
11690 ec.Error(ctx, ec.Recover(ctx, r))
11691 ret = graphql.Null
11692 }
11693 }()
11694 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
11695 ctx = rctx
11696 return obj.Width, nil
11697 })
11698
11699 if resTmp == nil {
11700 return graphql.Null
11701 }
11702 res := resTmp.(float64)
11703 fc.Result = res
11704 return ec.marshalOFloat2float64(ctx, field.Selections, res)
11705 }
11706
11707 func (ec *executionContext) fieldContext_Rectangle_width(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11708 fc = &graphql.FieldContext{
11709 Object: "Rectangle",
11710 Field: field,
11711 IsMethod: false,
11712 IsResolver: false,
11713 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11714 return nil, errors.New("field of type Float does not have child fields")
11715 },
11716 }
11717 return fc, nil
11718 }
11719
11720 func (ec *executionContext) _Rectangle_area(ctx context.Context, field graphql.CollectedField, obj *Rectangle) (ret graphql.Marshaler) {
11721 fc, err := ec.fieldContext_Rectangle_area(ctx, field)
11722 if err != nil {
11723 return graphql.Null
11724 }
11725 ctx = graphql.WithFieldContext(ctx, fc)
11726 defer func() {
11727 if r := recover(); r != nil {
11728 ec.Error(ctx, ec.Recover(ctx, r))
11729 ret = graphql.Null
11730 }
11731 }()
11732 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
11733 ctx = rctx
11734 return obj.Area(), nil
11735 })
11736
11737 if resTmp == nil {
11738 return graphql.Null
11739 }
11740 res := resTmp.(float64)
11741 fc.Result = res
11742 return ec.marshalOFloat2float64(ctx, field.Selections, res)
11743 }
11744
11745 func (ec *executionContext) fieldContext_Rectangle_area(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11746 fc = &graphql.FieldContext{
11747 Object: "Rectangle",
11748 Field: field,
11749 IsMethod: true,
11750 IsResolver: false,
11751 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11752 return nil, errors.New("field of type Float does not have child fields")
11753 },
11754 }
11755 return fc, nil
11756 }
11757
11758 func (ec *executionContext) _Rectangle_coordinates(ctx context.Context, field graphql.CollectedField, obj *Rectangle) (ret graphql.Marshaler) {
11759 fc, err := ec.fieldContext_Rectangle_coordinates(ctx, field)
11760 if err != nil {
11761 return graphql.Null
11762 }
11763 ctx = graphql.WithFieldContext(ctx, fc)
11764 defer func() {
11765 if r := recover(); r != nil {
11766 ec.Error(ctx, ec.Recover(ctx, r))
11767 ret = graphql.Null
11768 }
11769 }()
11770 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
11771 ctx = rctx
11772 return obj.Coordinates, nil
11773 })
11774
11775 if resTmp == nil {
11776 return graphql.Null
11777 }
11778 res := resTmp.(Coordinates)
11779 fc.Result = res
11780 return ec.marshalOCoordinates2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCoordinates(ctx, field.Selections, res)
11781 }
11782
11783 func (ec *executionContext) fieldContext_Rectangle_coordinates(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11784 fc = &graphql.FieldContext{
11785 Object: "Rectangle",
11786 Field: field,
11787 IsMethod: false,
11788 IsResolver: false,
11789 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11790 switch field.Name {
11791 case "x":
11792 return ec.fieldContext_Coordinates_x(ctx, field)
11793 case "y":
11794 return ec.fieldContext_Coordinates_y(ctx, field)
11795 }
11796 return nil, fmt.Errorf("no field named %q was found under type Coordinates", field.Name)
11797 },
11798 }
11799 return fc, nil
11800 }
11801
11802 func (ec *executionContext) _Size_height(ctx context.Context, field graphql.CollectedField, obj *Size) (ret graphql.Marshaler) {
11803 fc, err := ec.fieldContext_Size_height(ctx, field)
11804 if err != nil {
11805 return graphql.Null
11806 }
11807 ctx = graphql.WithFieldContext(ctx, fc)
11808 defer func() {
11809 if r := recover(); r != nil {
11810 ec.Error(ctx, ec.Recover(ctx, r))
11811 ret = graphql.Null
11812 }
11813 }()
11814 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
11815 ctx = rctx
11816 return obj.Height, nil
11817 })
11818
11819 if resTmp == nil {
11820 if !graphql.HasFieldError(ctx, fc) {
11821 ec.Errorf(ctx, "must not be null")
11822 }
11823 return graphql.Null
11824 }
11825 res := resTmp.(int)
11826 fc.Result = res
11827 return ec.marshalNInt2int(ctx, field.Selections, res)
11828 }
11829
11830 func (ec *executionContext) fieldContext_Size_height(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11831 fc = &graphql.FieldContext{
11832 Object: "Size",
11833 Field: field,
11834 IsMethod: false,
11835 IsResolver: false,
11836 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11837 return nil, errors.New("field of type Int does not have child fields")
11838 },
11839 }
11840 return fc, nil
11841 }
11842
11843 func (ec *executionContext) _Size_weight(ctx context.Context, field graphql.CollectedField, obj *Size) (ret graphql.Marshaler) {
11844 fc, err := ec.fieldContext_Size_weight(ctx, field)
11845 if err != nil {
11846 return graphql.Null
11847 }
11848 ctx = graphql.WithFieldContext(ctx, fc)
11849 defer func() {
11850 if r := recover(); r != nil {
11851 ec.Error(ctx, ec.Recover(ctx, r))
11852 ret = graphql.Null
11853 }
11854 }()
11855 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
11856 ctx = rctx
11857 return obj.Weight, nil
11858 })
11859
11860 if resTmp == nil {
11861 if !graphql.HasFieldError(ctx, fc) {
11862 ec.Errorf(ctx, "must not be null")
11863 }
11864 return graphql.Null
11865 }
11866 res := resTmp.(int)
11867 fc.Result = res
11868 return ec.marshalNInt2int(ctx, field.Selections, res)
11869 }
11870
11871 func (ec *executionContext) fieldContext_Size_weight(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11872 fc = &graphql.FieldContext{
11873 Object: "Size",
11874 Field: field,
11875 IsMethod: false,
11876 IsResolver: false,
11877 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11878 return nil, errors.New("field of type Int does not have child fields")
11879 },
11880 }
11881 return fc, nil
11882 }
11883
11884 func (ec *executionContext) _Slices_test1(ctx context.Context, field graphql.CollectedField, obj *Slices) (ret graphql.Marshaler) {
11885 fc, err := ec.fieldContext_Slices_test1(ctx, field)
11886 if err != nil {
11887 return graphql.Null
11888 }
11889 ctx = graphql.WithFieldContext(ctx, fc)
11890 defer func() {
11891 if r := recover(); r != nil {
11892 ec.Error(ctx, ec.Recover(ctx, r))
11893 ret = graphql.Null
11894 }
11895 }()
11896 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
11897 ctx = rctx
11898 return obj.Test1, nil
11899 })
11900
11901 if resTmp == nil {
11902 return graphql.Null
11903 }
11904 res := resTmp.([]*string)
11905 fc.Result = res
11906 return ec.marshalOString2ᚕᚖstring(ctx, field.Selections, res)
11907 }
11908
11909 func (ec *executionContext) fieldContext_Slices_test1(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11910 fc = &graphql.FieldContext{
11911 Object: "Slices",
11912 Field: field,
11913 IsMethod: false,
11914 IsResolver: false,
11915 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11916 return nil, errors.New("field of type String does not have child fields")
11917 },
11918 }
11919 return fc, nil
11920 }
11921
11922 func (ec *executionContext) _Slices_test2(ctx context.Context, field graphql.CollectedField, obj *Slices) (ret graphql.Marshaler) {
11923 fc, err := ec.fieldContext_Slices_test2(ctx, field)
11924 if err != nil {
11925 return graphql.Null
11926 }
11927 ctx = graphql.WithFieldContext(ctx, fc)
11928 defer func() {
11929 if r := recover(); r != nil {
11930 ec.Error(ctx, ec.Recover(ctx, r))
11931 ret = graphql.Null
11932 }
11933 }()
11934 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
11935 ctx = rctx
11936 return obj.Test2, nil
11937 })
11938
11939 if resTmp == nil {
11940 return graphql.Null
11941 }
11942 res := resTmp.([]string)
11943 fc.Result = res
11944 return ec.marshalOString2ᚕstringᚄ(ctx, field.Selections, res)
11945 }
11946
11947 func (ec *executionContext) fieldContext_Slices_test2(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11948 fc = &graphql.FieldContext{
11949 Object: "Slices",
11950 Field: field,
11951 IsMethod: false,
11952 IsResolver: false,
11953 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11954 return nil, errors.New("field of type String does not have child fields")
11955 },
11956 }
11957 return fc, nil
11958 }
11959
11960 func (ec *executionContext) _Slices_test3(ctx context.Context, field graphql.CollectedField, obj *Slices) (ret graphql.Marshaler) {
11961 fc, err := ec.fieldContext_Slices_test3(ctx, field)
11962 if err != nil {
11963 return graphql.Null
11964 }
11965 ctx = graphql.WithFieldContext(ctx, fc)
11966 defer func() {
11967 if r := recover(); r != nil {
11968 ec.Error(ctx, ec.Recover(ctx, r))
11969 ret = graphql.Null
11970 }
11971 }()
11972 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
11973 ctx = rctx
11974 return obj.Test3, nil
11975 })
11976
11977 if resTmp == nil {
11978 if !graphql.HasFieldError(ctx, fc) {
11979 ec.Errorf(ctx, "must not be null")
11980 }
11981 return graphql.Null
11982 }
11983 res := resTmp.([]*string)
11984 fc.Result = res
11985 return ec.marshalNString2ᚕᚖstring(ctx, field.Selections, res)
11986 }
11987
11988 func (ec *executionContext) fieldContext_Slices_test3(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
11989 fc = &graphql.FieldContext{
11990 Object: "Slices",
11991 Field: field,
11992 IsMethod: false,
11993 IsResolver: false,
11994 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
11995 return nil, errors.New("field of type String does not have child fields")
11996 },
11997 }
11998 return fc, nil
11999 }
12000
12001 func (ec *executionContext) _Slices_test4(ctx context.Context, field graphql.CollectedField, obj *Slices) (ret graphql.Marshaler) {
12002 fc, err := ec.fieldContext_Slices_test4(ctx, field)
12003 if err != nil {
12004 return graphql.Null
12005 }
12006 ctx = graphql.WithFieldContext(ctx, fc)
12007 defer func() {
12008 if r := recover(); r != nil {
12009 ec.Error(ctx, ec.Recover(ctx, r))
12010 ret = graphql.Null
12011 }
12012 }()
12013 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
12014 ctx = rctx
12015 return obj.Test4, nil
12016 })
12017
12018 if resTmp == nil {
12019 if !graphql.HasFieldError(ctx, fc) {
12020 ec.Errorf(ctx, "must not be null")
12021 }
12022 return graphql.Null
12023 }
12024 res := resTmp.([]string)
12025 fc.Result = res
12026 return ec.marshalNString2ᚕstringᚄ(ctx, field.Selections, res)
12027 }
12028
12029 func (ec *executionContext) fieldContext_Slices_test4(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12030 fc = &graphql.FieldContext{
12031 Object: "Slices",
12032 Field: field,
12033 IsMethod: false,
12034 IsResolver: false,
12035 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12036 return nil, errors.New("field of type String does not have child fields")
12037 },
12038 }
12039 return fc, nil
12040 }
12041
12042 func (ec *executionContext) _Subscription_updated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
12043 fc, err := ec.fieldContext_Subscription_updated(ctx, field)
12044 if err != nil {
12045 return nil
12046 }
12047 ctx = graphql.WithFieldContext(ctx, fc)
12048 defer func() {
12049 if r := recover(); r != nil {
12050 ec.Error(ctx, ec.Recover(ctx, r))
12051 ret = nil
12052 }
12053 }()
12054 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
12055 ctx = rctx
12056 return ec.resolvers.Subscription().Updated(rctx)
12057 })
12058
12059 if resTmp == nil {
12060 if !graphql.HasFieldError(ctx, fc) {
12061 ec.Errorf(ctx, "must not be null")
12062 }
12063 return nil
12064 }
12065 return func(ctx context.Context) graphql.Marshaler {
12066 select {
12067 case res, ok := <-resTmp.(<-chan string):
12068 if !ok {
12069 return nil
12070 }
12071 return graphql.WriterFunc(func(w io.Writer) {
12072 w.Write([]byte{'{'})
12073 graphql.MarshalString(field.Alias).MarshalGQL(w)
12074 w.Write([]byte{':'})
12075 ec.marshalNString2string(ctx, field.Selections, res).MarshalGQL(w)
12076 w.Write([]byte{'}'})
12077 })
12078 case <-ctx.Done():
12079 return nil
12080 }
12081 }
12082 }
12083
12084 func (ec *executionContext) fieldContext_Subscription_updated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12085 fc = &graphql.FieldContext{
12086 Object: "Subscription",
12087 Field: field,
12088 IsMethod: true,
12089 IsResolver: true,
12090 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12091 return nil, errors.New("field of type String does not have child fields")
12092 },
12093 }
12094 return fc, nil
12095 }
12096
12097 func (ec *executionContext) _Subscription_initPayload(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
12098 fc, err := ec.fieldContext_Subscription_initPayload(ctx, field)
12099 if err != nil {
12100 return nil
12101 }
12102 ctx = graphql.WithFieldContext(ctx, fc)
12103 defer func() {
12104 if r := recover(); r != nil {
12105 ec.Error(ctx, ec.Recover(ctx, r))
12106 ret = nil
12107 }
12108 }()
12109 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
12110 ctx = rctx
12111 return ec.resolvers.Subscription().InitPayload(rctx)
12112 })
12113
12114 if resTmp == nil {
12115 if !graphql.HasFieldError(ctx, fc) {
12116 ec.Errorf(ctx, "must not be null")
12117 }
12118 return nil
12119 }
12120 return func(ctx context.Context) graphql.Marshaler {
12121 select {
12122 case res, ok := <-resTmp.(<-chan string):
12123 if !ok {
12124 return nil
12125 }
12126 return graphql.WriterFunc(func(w io.Writer) {
12127 w.Write([]byte{'{'})
12128 graphql.MarshalString(field.Alias).MarshalGQL(w)
12129 w.Write([]byte{':'})
12130 ec.marshalNString2string(ctx, field.Selections, res).MarshalGQL(w)
12131 w.Write([]byte{'}'})
12132 })
12133 case <-ctx.Done():
12134 return nil
12135 }
12136 }
12137 }
12138
12139 func (ec *executionContext) fieldContext_Subscription_initPayload(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12140 fc = &graphql.FieldContext{
12141 Object: "Subscription",
12142 Field: field,
12143 IsMethod: true,
12144 IsResolver: true,
12145 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12146 return nil, errors.New("field of type String does not have child fields")
12147 },
12148 }
12149 return fc, nil
12150 }
12151
12152 func (ec *executionContext) _Subscription_directiveArg(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
12153 fc, err := ec.fieldContext_Subscription_directiveArg(ctx, field)
12154 if err != nil {
12155 return nil
12156 }
12157 ctx = graphql.WithFieldContext(ctx, fc)
12158 defer func() {
12159 if r := recover(); r != nil {
12160 ec.Error(ctx, ec.Recover(ctx, r))
12161 ret = nil
12162 }
12163 }()
12164 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
12165 ctx = rctx
12166 return ec.resolvers.Subscription().DirectiveArg(rctx, fc.Args["arg"].(string))
12167 })
12168
12169 if resTmp == nil {
12170 return nil
12171 }
12172 return func(ctx context.Context) graphql.Marshaler {
12173 select {
12174 case res, ok := <-resTmp.(<-chan *string):
12175 if !ok {
12176 return nil
12177 }
12178 return graphql.WriterFunc(func(w io.Writer) {
12179 w.Write([]byte{'{'})
12180 graphql.MarshalString(field.Alias).MarshalGQL(w)
12181 w.Write([]byte{':'})
12182 ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w)
12183 w.Write([]byte{'}'})
12184 })
12185 case <-ctx.Done():
12186 return nil
12187 }
12188 }
12189 }
12190
12191 func (ec *executionContext) fieldContext_Subscription_directiveArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12192 fc = &graphql.FieldContext{
12193 Object: "Subscription",
12194 Field: field,
12195 IsMethod: true,
12196 IsResolver: true,
12197 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12198 return nil, errors.New("field of type String does not have child fields")
12199 },
12200 }
12201 defer func() {
12202 if r := recover(); r != nil {
12203 err = ec.Recover(ctx, r)
12204 ec.Error(ctx, err)
12205 }
12206 }()
12207 ctx = graphql.WithFieldContext(ctx, fc)
12208 if fc.Args, err = ec.field_Subscription_directiveArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
12209 ec.Error(ctx, err)
12210 return fc, err
12211 }
12212 return fc, nil
12213 }
12214
12215 func (ec *executionContext) _Subscription_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
12216 fc, err := ec.fieldContext_Subscription_directiveNullableArg(ctx, field)
12217 if err != nil {
12218 return nil
12219 }
12220 ctx = graphql.WithFieldContext(ctx, fc)
12221 defer func() {
12222 if r := recover(); r != nil {
12223 ec.Error(ctx, ec.Recover(ctx, r))
12224 ret = nil
12225 }
12226 }()
12227 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
12228 ctx = rctx
12229 return ec.resolvers.Subscription().DirectiveNullableArg(rctx, fc.Args["arg"].(*int), fc.Args["arg2"].(*int), fc.Args["arg3"].(*string))
12230 })
12231
12232 if resTmp == nil {
12233 return nil
12234 }
12235 return func(ctx context.Context) graphql.Marshaler {
12236 select {
12237 case res, ok := <-resTmp.(<-chan *string):
12238 if !ok {
12239 return nil
12240 }
12241 return graphql.WriterFunc(func(w io.Writer) {
12242 w.Write([]byte{'{'})
12243 graphql.MarshalString(field.Alias).MarshalGQL(w)
12244 w.Write([]byte{':'})
12245 ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w)
12246 w.Write([]byte{'}'})
12247 })
12248 case <-ctx.Done():
12249 return nil
12250 }
12251 }
12252 }
12253
12254 func (ec *executionContext) fieldContext_Subscription_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12255 fc = &graphql.FieldContext{
12256 Object: "Subscription",
12257 Field: field,
12258 IsMethod: true,
12259 IsResolver: true,
12260 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12261 return nil, errors.New("field of type String does not have child fields")
12262 },
12263 }
12264 defer func() {
12265 if r := recover(); r != nil {
12266 err = ec.Recover(ctx, r)
12267 ec.Error(ctx, err)
12268 }
12269 }()
12270 ctx = graphql.WithFieldContext(ctx, fc)
12271 if fc.Args, err = ec.field_Subscription_directiveNullableArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
12272 ec.Error(ctx, err)
12273 return fc, err
12274 }
12275 return fc, nil
12276 }
12277
12278 func (ec *executionContext) _Subscription_directiveDouble(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
12279 fc, err := ec.fieldContext_Subscription_directiveDouble(ctx, field)
12280 if err != nil {
12281 return nil
12282 }
12283 ctx = graphql.WithFieldContext(ctx, fc)
12284 defer func() {
12285 if r := recover(); r != nil {
12286 ec.Error(ctx, ec.Recover(ctx, r))
12287 ret = nil
12288 }
12289 }()
12290 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
12291 directive0 := func(rctx context.Context) (interface{}, error) {
12292 ctx = rctx
12293 return ec.resolvers.Subscription().DirectiveDouble(rctx)
12294 }
12295 directive1 := func(ctx context.Context) (interface{}, error) {
12296 if ec.directives.Directive1 == nil {
12297 return nil, errors.New("directive directive1 is not implemented")
12298 }
12299 return ec.directives.Directive1(ctx, nil, directive0)
12300 }
12301 directive2 := func(ctx context.Context) (interface{}, error) {
12302 if ec.directives.Directive2 == nil {
12303 return nil, errors.New("directive directive2 is not implemented")
12304 }
12305 return ec.directives.Directive2(ctx, nil, directive1)
12306 }
12307
12308 tmp, err := directive2(rctx)
12309 if err != nil {
12310 return nil, graphql.ErrorOnPath(ctx, err)
12311 }
12312 if tmp == nil {
12313 return nil, nil
12314 }
12315 if data, ok := tmp.(<-chan *string); ok {
12316 return data, nil
12317 }
12318 return nil, fmt.Errorf(`unexpected type %T from directive, should be <-chan *string`, tmp)
12319 })
12320
12321 if resTmp == nil {
12322 return nil
12323 }
12324 return func(ctx context.Context) graphql.Marshaler {
12325 select {
12326 case res, ok := <-resTmp.(<-chan *string):
12327 if !ok {
12328 return nil
12329 }
12330 return graphql.WriterFunc(func(w io.Writer) {
12331 w.Write([]byte{'{'})
12332 graphql.MarshalString(field.Alias).MarshalGQL(w)
12333 w.Write([]byte{':'})
12334 ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w)
12335 w.Write([]byte{'}'})
12336 })
12337 case <-ctx.Done():
12338 return nil
12339 }
12340 }
12341 }
12342
12343 func (ec *executionContext) fieldContext_Subscription_directiveDouble(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12344 fc = &graphql.FieldContext{
12345 Object: "Subscription",
12346 Field: field,
12347 IsMethod: true,
12348 IsResolver: true,
12349 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12350 return nil, errors.New("field of type String does not have child fields")
12351 },
12352 }
12353 return fc, nil
12354 }
12355
12356 func (ec *executionContext) _Subscription_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
12357 fc, err := ec.fieldContext_Subscription_directiveUnimplemented(ctx, field)
12358 if err != nil {
12359 return nil
12360 }
12361 ctx = graphql.WithFieldContext(ctx, fc)
12362 defer func() {
12363 if r := recover(); r != nil {
12364 ec.Error(ctx, ec.Recover(ctx, r))
12365 ret = nil
12366 }
12367 }()
12368 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
12369 directive0 := func(rctx context.Context) (interface{}, error) {
12370 ctx = rctx
12371 return ec.resolvers.Subscription().DirectiveUnimplemented(rctx)
12372 }
12373 directive1 := func(ctx context.Context) (interface{}, error) {
12374 if ec.directives.Unimplemented == nil {
12375 return nil, errors.New("directive unimplemented is not implemented")
12376 }
12377 return ec.directives.Unimplemented(ctx, nil, directive0)
12378 }
12379
12380 tmp, err := directive1(rctx)
12381 if err != nil {
12382 return nil, graphql.ErrorOnPath(ctx, err)
12383 }
12384 if tmp == nil {
12385 return nil, nil
12386 }
12387 if data, ok := tmp.(<-chan *string); ok {
12388 return data, nil
12389 }
12390 return nil, fmt.Errorf(`unexpected type %T from directive, should be <-chan *string`, tmp)
12391 })
12392
12393 if resTmp == nil {
12394 return nil
12395 }
12396 return func(ctx context.Context) graphql.Marshaler {
12397 select {
12398 case res, ok := <-resTmp.(<-chan *string):
12399 if !ok {
12400 return nil
12401 }
12402 return graphql.WriterFunc(func(w io.Writer) {
12403 w.Write([]byte{'{'})
12404 graphql.MarshalString(field.Alias).MarshalGQL(w)
12405 w.Write([]byte{':'})
12406 ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w)
12407 w.Write([]byte{'}'})
12408 })
12409 case <-ctx.Done():
12410 return nil
12411 }
12412 }
12413 }
12414
12415 func (ec *executionContext) fieldContext_Subscription_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12416 fc = &graphql.FieldContext{
12417 Object: "Subscription",
12418 Field: field,
12419 IsMethod: true,
12420 IsResolver: true,
12421 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12422 return nil, errors.New("field of type String does not have child fields")
12423 },
12424 }
12425 return fc, nil
12426 }
12427
12428 func (ec *executionContext) _Subscription_issue896b(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
12429 fc, err := ec.fieldContext_Subscription_issue896b(ctx, field)
12430 if err != nil {
12431 return nil
12432 }
12433 ctx = graphql.WithFieldContext(ctx, fc)
12434 defer func() {
12435 if r := recover(); r != nil {
12436 ec.Error(ctx, ec.Recover(ctx, r))
12437 ret = nil
12438 }
12439 }()
12440 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
12441 ctx = rctx
12442 return ec.resolvers.Subscription().Issue896b(rctx)
12443 })
12444
12445 if resTmp == nil {
12446 return nil
12447 }
12448 return func(ctx context.Context) graphql.Marshaler {
12449 select {
12450 case res, ok := <-resTmp.(<-chan []*CheckIssue896):
12451 if !ok {
12452 return nil
12453 }
12454 return graphql.WriterFunc(func(w io.Writer) {
12455 w.Write([]byte{'{'})
12456 graphql.MarshalString(field.Alias).MarshalGQL(w)
12457 w.Write([]byte{':'})
12458 ec.marshalOCheckIssue8962ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCheckIssue896(ctx, field.Selections, res).MarshalGQL(w)
12459 w.Write([]byte{'}'})
12460 })
12461 case <-ctx.Done():
12462 return nil
12463 }
12464 }
12465 }
12466
12467 func (ec *executionContext) fieldContext_Subscription_issue896b(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12468 fc = &graphql.FieldContext{
12469 Object: "Subscription",
12470 Field: field,
12471 IsMethod: true,
12472 IsResolver: true,
12473 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12474 switch field.Name {
12475 case "id":
12476 return ec.fieldContext_CheckIssue896_id(ctx, field)
12477 }
12478 return nil, fmt.Errorf("no field named %q was found under type CheckIssue896", field.Name)
12479 },
12480 }
12481 return fc, nil
12482 }
12483
12484 func (ec *executionContext) _Subscription_errorRequired(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) {
12485 fc, err := ec.fieldContext_Subscription_errorRequired(ctx, field)
12486 if err != nil {
12487 return nil
12488 }
12489 ctx = graphql.WithFieldContext(ctx, fc)
12490 defer func() {
12491 if r := recover(); r != nil {
12492 ec.Error(ctx, ec.Recover(ctx, r))
12493 ret = nil
12494 }
12495 }()
12496 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
12497 ctx = rctx
12498 return ec.resolvers.Subscription().ErrorRequired(rctx)
12499 })
12500
12501 if resTmp == nil {
12502 if !graphql.HasFieldError(ctx, fc) {
12503 ec.Errorf(ctx, "must not be null")
12504 }
12505 return nil
12506 }
12507 return func(ctx context.Context) graphql.Marshaler {
12508 select {
12509 case res, ok := <-resTmp.(<-chan *Error):
12510 if !ok {
12511 return nil
12512 }
12513 return graphql.WriterFunc(func(w io.Writer) {
12514 w.Write([]byte{'{'})
12515 graphql.MarshalString(field.Alias).MarshalGQL(w)
12516 w.Write([]byte{':'})
12517 ec.marshalNError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐError(ctx, field.Selections, res).MarshalGQL(w)
12518 w.Write([]byte{'}'})
12519 })
12520 case <-ctx.Done():
12521 return nil
12522 }
12523 }
12524 }
12525
12526 func (ec *executionContext) fieldContext_Subscription_errorRequired(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12527 fc = &graphql.FieldContext{
12528 Object: "Subscription",
12529 Field: field,
12530 IsMethod: true,
12531 IsResolver: true,
12532 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12533 switch field.Name {
12534 case "id":
12535 return ec.fieldContext_Error_id(ctx, field)
12536 case "errorOnNonRequiredField":
12537 return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field)
12538 case "errorOnRequiredField":
12539 return ec.fieldContext_Error_errorOnRequiredField(ctx, field)
12540 case "nilOnRequiredField":
12541 return ec.fieldContext_Error_nilOnRequiredField(ctx, field)
12542 }
12543 return nil, fmt.Errorf("no field named %q was found under type Error", field.Name)
12544 },
12545 }
12546 return fc, nil
12547 }
12548
12549 func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
12550 fc, err := ec.fieldContext_User_id(ctx, field)
12551 if err != nil {
12552 return graphql.Null
12553 }
12554 ctx = graphql.WithFieldContext(ctx, fc)
12555 defer func() {
12556 if r := recover(); r != nil {
12557 ec.Error(ctx, ec.Recover(ctx, r))
12558 ret = graphql.Null
12559 }
12560 }()
12561 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
12562 ctx = rctx
12563 return obj.ID, nil
12564 })
12565
12566 if resTmp == nil {
12567 if !graphql.HasFieldError(ctx, fc) {
12568 ec.Errorf(ctx, "must not be null")
12569 }
12570 return graphql.Null
12571 }
12572 res := resTmp.(int)
12573 fc.Result = res
12574 return ec.marshalNInt2int(ctx, field.Selections, res)
12575 }
12576
12577 func (ec *executionContext) fieldContext_User_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12578 fc = &graphql.FieldContext{
12579 Object: "User",
12580 Field: field,
12581 IsMethod: false,
12582 IsResolver: false,
12583 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12584 return nil, errors.New("field of type Int does not have child fields")
12585 },
12586 }
12587 return fc, nil
12588 }
12589
12590 func (ec *executionContext) _User_friends(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
12591 fc, err := ec.fieldContext_User_friends(ctx, field)
12592 if err != nil {
12593 return graphql.Null
12594 }
12595 ctx = graphql.WithFieldContext(ctx, fc)
12596 defer func() {
12597 if r := recover(); r != nil {
12598 ec.Error(ctx, ec.Recover(ctx, r))
12599 ret = graphql.Null
12600 }
12601 }()
12602 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
12603 ctx = rctx
12604 return ec.resolvers.User().Friends(rctx, obj)
12605 })
12606
12607 if resTmp == nil {
12608 if !graphql.HasFieldError(ctx, fc) {
12609 ec.Errorf(ctx, "must not be null")
12610 }
12611 return graphql.Null
12612 }
12613 res := resTmp.([]*User)
12614 fc.Result = res
12615 return ec.marshalNUser2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUserᚄ(ctx, field.Selections, res)
12616 }
12617
12618 func (ec *executionContext) fieldContext_User_friends(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12619 fc = &graphql.FieldContext{
12620 Object: "User",
12621 Field: field,
12622 IsMethod: true,
12623 IsResolver: true,
12624 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12625 switch field.Name {
12626 case "id":
12627 return ec.fieldContext_User_id(ctx, field)
12628 case "friends":
12629 return ec.fieldContext_User_friends(ctx, field)
12630 case "created":
12631 return ec.fieldContext_User_created(ctx, field)
12632 case "updated":
12633 return ec.fieldContext_User_updated(ctx, field)
12634 case "pets":
12635 return ec.fieldContext_User_pets(ctx, field)
12636 }
12637 return nil, fmt.Errorf("no field named %q was found under type User", field.Name)
12638 },
12639 }
12640 return fc, nil
12641 }
12642
12643 func (ec *executionContext) _User_created(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
12644 fc, err := ec.fieldContext_User_created(ctx, field)
12645 if err != nil {
12646 return graphql.Null
12647 }
12648 ctx = graphql.WithFieldContext(ctx, fc)
12649 defer func() {
12650 if r := recover(); r != nil {
12651 ec.Error(ctx, ec.Recover(ctx, r))
12652 ret = graphql.Null
12653 }
12654 }()
12655 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
12656 ctx = rctx
12657 return obj.Created, nil
12658 })
12659
12660 if resTmp == nil {
12661 if !graphql.HasFieldError(ctx, fc) {
12662 ec.Errorf(ctx, "must not be null")
12663 }
12664 return graphql.Null
12665 }
12666 res := resTmp.(time.Time)
12667 fc.Result = res
12668 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
12669 }
12670
12671 func (ec *executionContext) fieldContext_User_created(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12672 fc = &graphql.FieldContext{
12673 Object: "User",
12674 Field: field,
12675 IsMethod: false,
12676 IsResolver: false,
12677 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12678 return nil, errors.New("field of type Time does not have child fields")
12679 },
12680 }
12681 return fc, nil
12682 }
12683
12684 func (ec *executionContext) _User_updated(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
12685 fc, err := ec.fieldContext_User_updated(ctx, field)
12686 if err != nil {
12687 return graphql.Null
12688 }
12689 ctx = graphql.WithFieldContext(ctx, fc)
12690 defer func() {
12691 if r := recover(); r != nil {
12692 ec.Error(ctx, ec.Recover(ctx, r))
12693 ret = graphql.Null
12694 }
12695 }()
12696 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
12697 ctx = rctx
12698 return obj.Updated, nil
12699 })
12700
12701 if resTmp == nil {
12702 return graphql.Null
12703 }
12704 res := resTmp.(*time.Time)
12705 fc.Result = res
12706 return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res)
12707 }
12708
12709 func (ec *executionContext) fieldContext_User_updated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12710 fc = &graphql.FieldContext{
12711 Object: "User",
12712 Field: field,
12713 IsMethod: false,
12714 IsResolver: false,
12715 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12716 return nil, errors.New("field of type Time does not have child fields")
12717 },
12718 }
12719 return fc, nil
12720 }
12721
12722 func (ec *executionContext) _User_pets(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) {
12723 fc, err := ec.fieldContext_User_pets(ctx, field)
12724 if err != nil {
12725 return graphql.Null
12726 }
12727 ctx = graphql.WithFieldContext(ctx, fc)
12728 defer func() {
12729 if r := recover(); r != nil {
12730 ec.Error(ctx, ec.Recover(ctx, r))
12731 ret = graphql.Null
12732 }
12733 }()
12734 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
12735 ctx = rctx
12736 return ec.resolvers.User().Pets(rctx, obj, fc.Args["limit"].(*int))
12737 })
12738
12739 if resTmp == nil {
12740 return graphql.Null
12741 }
12742 res := resTmp.([]*Pet)
12743 fc.Result = res
12744 return ec.marshalOPet2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPetᚄ(ctx, field.Selections, res)
12745 }
12746
12747 func (ec *executionContext) fieldContext_User_pets(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12748 fc = &graphql.FieldContext{
12749 Object: "User",
12750 Field: field,
12751 IsMethod: true,
12752 IsResolver: true,
12753 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12754 switch field.Name {
12755 case "id":
12756 return ec.fieldContext_Pet_id(ctx, field)
12757 case "friends":
12758 return ec.fieldContext_Pet_friends(ctx, field)
12759 }
12760 return nil, fmt.Errorf("no field named %q was found under type Pet", field.Name)
12761 },
12762 }
12763 defer func() {
12764 if r := recover(); r != nil {
12765 err = ec.Recover(ctx, r)
12766 ec.Error(ctx, err)
12767 }
12768 }()
12769 ctx = graphql.WithFieldContext(ctx, fc)
12770 if fc.Args, err = ec.field_User_pets_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
12771 ec.Error(ctx, err)
12772 return fc, err
12773 }
12774 return fc, nil
12775 }
12776
12777 func (ec *executionContext) _VOkCaseNil_value(ctx context.Context, field graphql.CollectedField, obj *VOkCaseNil) (ret graphql.Marshaler) {
12778 fc, err := ec.fieldContext_VOkCaseNil_value(ctx, field)
12779 if err != nil {
12780 return graphql.Null
12781 }
12782 ctx = graphql.WithFieldContext(ctx, fc)
12783 defer func() {
12784 if r := recover(); r != nil {
12785 ec.Error(ctx, ec.Recover(ctx, r))
12786 ret = graphql.Null
12787 }
12788 }()
12789 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
12790 ctx = rctx
12791 v, ok := obj.Value()
12792 if !ok {
12793 return nil, nil
12794 }
12795 return v, nil
12796 })
12797
12798 if resTmp == nil {
12799 return graphql.Null
12800 }
12801 res := resTmp.(string)
12802 fc.Result = res
12803 return ec.marshalOString2string(ctx, field.Selections, res)
12804 }
12805
12806 func (ec *executionContext) fieldContext_VOkCaseNil_value(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12807 fc = &graphql.FieldContext{
12808 Object: "VOkCaseNil",
12809 Field: field,
12810 IsMethod: true,
12811 IsResolver: false,
12812 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12813 return nil, errors.New("field of type String does not have child fields")
12814 },
12815 }
12816 return fc, nil
12817 }
12818
12819 func (ec *executionContext) _VOkCaseValue_value(ctx context.Context, field graphql.CollectedField, obj *VOkCaseValue) (ret graphql.Marshaler) {
12820 fc, err := ec.fieldContext_VOkCaseValue_value(ctx, field)
12821 if err != nil {
12822 return graphql.Null
12823 }
12824 ctx = graphql.WithFieldContext(ctx, fc)
12825 defer func() {
12826 if r := recover(); r != nil {
12827 ec.Error(ctx, ec.Recover(ctx, r))
12828 ret = graphql.Null
12829 }
12830 }()
12831 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
12832 ctx = rctx
12833 v, ok := obj.Value()
12834 if !ok {
12835 return nil, nil
12836 }
12837 return v, nil
12838 })
12839
12840 if resTmp == nil {
12841 return graphql.Null
12842 }
12843 res := resTmp.(string)
12844 fc.Result = res
12845 return ec.marshalOString2string(ctx, field.Selections, res)
12846 }
12847
12848 func (ec *executionContext) fieldContext_VOkCaseValue_value(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12849 fc = &graphql.FieldContext{
12850 Object: "VOkCaseValue",
12851 Field: field,
12852 IsMethod: true,
12853 IsResolver: false,
12854 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12855 return nil, errors.New("field of type String does not have child fields")
12856 },
12857 }
12858 return fc, nil
12859 }
12860
12861 func (ec *executionContext) _ValidType_differentCase(ctx context.Context, field graphql.CollectedField, obj *ValidType) (ret graphql.Marshaler) {
12862 fc, err := ec.fieldContext_ValidType_differentCase(ctx, field)
12863 if err != nil {
12864 return graphql.Null
12865 }
12866 ctx = graphql.WithFieldContext(ctx, fc)
12867 defer func() {
12868 if r := recover(); r != nil {
12869 ec.Error(ctx, ec.Recover(ctx, r))
12870 ret = graphql.Null
12871 }
12872 }()
12873 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
12874 ctx = rctx
12875 return obj.DifferentCase, nil
12876 })
12877
12878 if resTmp == nil {
12879 if !graphql.HasFieldError(ctx, fc) {
12880 ec.Errorf(ctx, "must not be null")
12881 }
12882 return graphql.Null
12883 }
12884 res := resTmp.(string)
12885 fc.Result = res
12886 return ec.marshalNString2string(ctx, field.Selections, res)
12887 }
12888
12889 func (ec *executionContext) fieldContext_ValidType_differentCase(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12890 fc = &graphql.FieldContext{
12891 Object: "ValidType",
12892 Field: field,
12893 IsMethod: false,
12894 IsResolver: false,
12895 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12896 return nil, errors.New("field of type String does not have child fields")
12897 },
12898 }
12899 return fc, nil
12900 }
12901
12902 func (ec *executionContext) _ValidType_different_case(ctx context.Context, field graphql.CollectedField, obj *ValidType) (ret graphql.Marshaler) {
12903 fc, err := ec.fieldContext_ValidType_different_case(ctx, field)
12904 if err != nil {
12905 return graphql.Null
12906 }
12907 ctx = graphql.WithFieldContext(ctx, fc)
12908 defer func() {
12909 if r := recover(); r != nil {
12910 ec.Error(ctx, ec.Recover(ctx, r))
12911 ret = graphql.Null
12912 }
12913 }()
12914 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
12915 ctx = rctx
12916 return obj.DifferentCaseOld, nil
12917 })
12918
12919 if resTmp == nil {
12920 if !graphql.HasFieldError(ctx, fc) {
12921 ec.Errorf(ctx, "must not be null")
12922 }
12923 return graphql.Null
12924 }
12925 res := resTmp.(string)
12926 fc.Result = res
12927 return ec.marshalNString2string(ctx, field.Selections, res)
12928 }
12929
12930 func (ec *executionContext) fieldContext_ValidType_different_case(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12931 fc = &graphql.FieldContext{
12932 Object: "ValidType",
12933 Field: field,
12934 IsMethod: false,
12935 IsResolver: false,
12936 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12937 return nil, errors.New("field of type String does not have child fields")
12938 },
12939 }
12940 return fc, nil
12941 }
12942
12943 func (ec *executionContext) _ValidType_validInputKeywords(ctx context.Context, field graphql.CollectedField, obj *ValidType) (ret graphql.Marshaler) {
12944 fc, err := ec.fieldContext_ValidType_validInputKeywords(ctx, field)
12945 if err != nil {
12946 return graphql.Null
12947 }
12948 ctx = graphql.WithFieldContext(ctx, fc)
12949 defer func() {
12950 if r := recover(); r != nil {
12951 ec.Error(ctx, ec.Recover(ctx, r))
12952 ret = graphql.Null
12953 }
12954 }()
12955 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
12956 ctx = rctx
12957 return obj.ValidInputKeywords, nil
12958 })
12959
12960 if resTmp == nil {
12961 if !graphql.HasFieldError(ctx, fc) {
12962 ec.Errorf(ctx, "must not be null")
12963 }
12964 return graphql.Null
12965 }
12966 res := resTmp.(bool)
12967 fc.Result = res
12968 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
12969 }
12970
12971 func (ec *executionContext) fieldContext_ValidType_validInputKeywords(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
12972 fc = &graphql.FieldContext{
12973 Object: "ValidType",
12974 Field: field,
12975 IsMethod: false,
12976 IsResolver: false,
12977 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
12978 return nil, errors.New("field of type Boolean does not have child fields")
12979 },
12980 }
12981 defer func() {
12982 if r := recover(); r != nil {
12983 err = ec.Recover(ctx, r)
12984 ec.Error(ctx, err)
12985 }
12986 }()
12987 ctx = graphql.WithFieldContext(ctx, fc)
12988 if fc.Args, err = ec.field_ValidType_validInputKeywords_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
12989 ec.Error(ctx, err)
12990 return fc, err
12991 }
12992 return fc, nil
12993 }
12994
12995 func (ec *executionContext) _ValidType_validArgs(ctx context.Context, field graphql.CollectedField, obj *ValidType) (ret graphql.Marshaler) {
12996 fc, err := ec.fieldContext_ValidType_validArgs(ctx, field)
12997 if err != nil {
12998 return graphql.Null
12999 }
13000 ctx = graphql.WithFieldContext(ctx, fc)
13001 defer func() {
13002 if r := recover(); r != nil {
13003 ec.Error(ctx, ec.Recover(ctx, r))
13004 ret = graphql.Null
13005 }
13006 }()
13007 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13008 ctx = rctx
13009 return obj.ValidArgs, nil
13010 })
13011
13012 if resTmp == nil {
13013 if !graphql.HasFieldError(ctx, fc) {
13014 ec.Errorf(ctx, "must not be null")
13015 }
13016 return graphql.Null
13017 }
13018 res := resTmp.(bool)
13019 fc.Result = res
13020 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
13021 }
13022
13023 func (ec *executionContext) fieldContext_ValidType_validArgs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13024 fc = &graphql.FieldContext{
13025 Object: "ValidType",
13026 Field: field,
13027 IsMethod: false,
13028 IsResolver: false,
13029 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13030 return nil, errors.New("field of type Boolean does not have child fields")
13031 },
13032 }
13033 defer func() {
13034 if r := recover(); r != nil {
13035 err = ec.Recover(ctx, r)
13036 ec.Error(ctx, err)
13037 }
13038 }()
13039 ctx = graphql.WithFieldContext(ctx, fc)
13040 if fc.Args, err = ec.field_ValidType_validArgs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
13041 ec.Error(ctx, err)
13042 return fc, err
13043 }
13044 return fc, nil
13045 }
13046
13047 func (ec *executionContext) _VariadicModel_value(ctx context.Context, field graphql.CollectedField, obj *VariadicModel) (ret graphql.Marshaler) {
13048 fc, err := ec.fieldContext_VariadicModel_value(ctx, field)
13049 if err != nil {
13050 return graphql.Null
13051 }
13052 ctx = graphql.WithFieldContext(ctx, fc)
13053 defer func() {
13054 if r := recover(); r != nil {
13055 ec.Error(ctx, ec.Recover(ctx, r))
13056 ret = graphql.Null
13057 }
13058 }()
13059 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13060 ctx = rctx
13061 return obj.Value(ctx, fc.Args["rank"].(int))
13062 })
13063
13064 if resTmp == nil {
13065 return graphql.Null
13066 }
13067 res := resTmp.(string)
13068 fc.Result = res
13069 return ec.marshalOString2string(ctx, field.Selections, res)
13070 }
13071
13072 func (ec *executionContext) fieldContext_VariadicModel_value(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13073 fc = &graphql.FieldContext{
13074 Object: "VariadicModel",
13075 Field: field,
13076 IsMethod: true,
13077 IsResolver: false,
13078 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13079 return nil, errors.New("field of type String does not have child fields")
13080 },
13081 }
13082 defer func() {
13083 if r := recover(); r != nil {
13084 err = ec.Recover(ctx, r)
13085 ec.Error(ctx, err)
13086 }
13087 }()
13088 ctx = graphql.WithFieldContext(ctx, fc)
13089 if fc.Args, err = ec.field_VariadicModel_value_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
13090 ec.Error(ctx, err)
13091 return fc, err
13092 }
13093 return fc, nil
13094 }
13095
13096 func (ec *executionContext) _WrappedMap_get(ctx context.Context, field graphql.CollectedField, obj WrappedMap) (ret graphql.Marshaler) {
13097 fc, err := ec.fieldContext_WrappedMap_get(ctx, field)
13098 if err != nil {
13099 return graphql.Null
13100 }
13101 ctx = graphql.WithFieldContext(ctx, fc)
13102 defer func() {
13103 if r := recover(); r != nil {
13104 ec.Error(ctx, ec.Recover(ctx, r))
13105 ret = graphql.Null
13106 }
13107 }()
13108 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13109 ctx = rctx
13110 return ec.resolvers.WrappedMap().Get(rctx, obj, fc.Args["key"].(string))
13111 })
13112
13113 if resTmp == nil {
13114 if !graphql.HasFieldError(ctx, fc) {
13115 ec.Errorf(ctx, "must not be null")
13116 }
13117 return graphql.Null
13118 }
13119 res := resTmp.(string)
13120 fc.Result = res
13121 return ec.marshalNString2string(ctx, field.Selections, res)
13122 }
13123
13124 func (ec *executionContext) fieldContext_WrappedMap_get(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13125 fc = &graphql.FieldContext{
13126 Object: "WrappedMap",
13127 Field: field,
13128 IsMethod: true,
13129 IsResolver: true,
13130 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13131 return nil, errors.New("field of type String does not have child fields")
13132 },
13133 }
13134 defer func() {
13135 if r := recover(); r != nil {
13136 err = ec.Recover(ctx, r)
13137 ec.Error(ctx, err)
13138 }
13139 }()
13140 ctx = graphql.WithFieldContext(ctx, fc)
13141 if fc.Args, err = ec.field_WrappedMap_get_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
13142 ec.Error(ctx, err)
13143 return fc, err
13144 }
13145 return fc, nil
13146 }
13147
13148 func (ec *executionContext) _WrappedSlice_get(ctx context.Context, field graphql.CollectedField, obj WrappedSlice) (ret graphql.Marshaler) {
13149 fc, err := ec.fieldContext_WrappedSlice_get(ctx, field)
13150 if err != nil {
13151 return graphql.Null
13152 }
13153 ctx = graphql.WithFieldContext(ctx, fc)
13154 defer func() {
13155 if r := recover(); r != nil {
13156 ec.Error(ctx, ec.Recover(ctx, r))
13157 ret = graphql.Null
13158 }
13159 }()
13160 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13161 ctx = rctx
13162 return ec.resolvers.WrappedSlice().Get(rctx, obj, fc.Args["idx"].(int))
13163 })
13164
13165 if resTmp == nil {
13166 if !graphql.HasFieldError(ctx, fc) {
13167 ec.Errorf(ctx, "must not be null")
13168 }
13169 return graphql.Null
13170 }
13171 res := resTmp.(string)
13172 fc.Result = res
13173 return ec.marshalNString2string(ctx, field.Selections, res)
13174 }
13175
13176 func (ec *executionContext) fieldContext_WrappedSlice_get(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13177 fc = &graphql.FieldContext{
13178 Object: "WrappedSlice",
13179 Field: field,
13180 IsMethod: true,
13181 IsResolver: true,
13182 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13183 return nil, errors.New("field of type String does not have child fields")
13184 },
13185 }
13186 defer func() {
13187 if r := recover(); r != nil {
13188 err = ec.Recover(ctx, r)
13189 ec.Error(ctx, err)
13190 }
13191 }()
13192 ctx = graphql.WithFieldContext(ctx, fc)
13193 if fc.Args, err = ec.field_WrappedSlice_get_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
13194 ec.Error(ctx, err)
13195 return fc, err
13196 }
13197 return fc, nil
13198 }
13199
13200 func (ec *executionContext) _WrappedStruct_name(ctx context.Context, field graphql.CollectedField, obj *WrappedStruct) (ret graphql.Marshaler) {
13201 fc, err := ec.fieldContext_WrappedStruct_name(ctx, field)
13202 if err != nil {
13203 return graphql.Null
13204 }
13205 ctx = graphql.WithFieldContext(ctx, fc)
13206 defer func() {
13207 if r := recover(); r != nil {
13208 ec.Error(ctx, ec.Recover(ctx, r))
13209 ret = graphql.Null
13210 }
13211 }()
13212 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13213 ctx = rctx
13214 return obj.Name, nil
13215 })
13216
13217 if resTmp == nil {
13218 if !graphql.HasFieldError(ctx, fc) {
13219 ec.Errorf(ctx, "must not be null")
13220 }
13221 return graphql.Null
13222 }
13223 res := resTmp.(otherpkg.Scalar)
13224 fc.Result = res
13225 return ec.marshalNWrappedScalar2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚋotherpkgᚐScalar(ctx, field.Selections, res)
13226 }
13227
13228 func (ec *executionContext) fieldContext_WrappedStruct_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13229 fc = &graphql.FieldContext{
13230 Object: "WrappedStruct",
13231 Field: field,
13232 IsMethod: false,
13233 IsResolver: false,
13234 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13235 return nil, errors.New("field of type WrappedScalar does not have child fields")
13236 },
13237 }
13238 return fc, nil
13239 }
13240
13241 func (ec *executionContext) _WrappedStruct_desc(ctx context.Context, field graphql.CollectedField, obj *WrappedStruct) (ret graphql.Marshaler) {
13242 fc, err := ec.fieldContext_WrappedStruct_desc(ctx, field)
13243 if err != nil {
13244 return graphql.Null
13245 }
13246 ctx = graphql.WithFieldContext(ctx, fc)
13247 defer func() {
13248 if r := recover(); r != nil {
13249 ec.Error(ctx, ec.Recover(ctx, r))
13250 ret = graphql.Null
13251 }
13252 }()
13253 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13254 ctx = rctx
13255 return obj.Desc, nil
13256 })
13257
13258 if resTmp == nil {
13259 return graphql.Null
13260 }
13261 res := resTmp.(*otherpkg.Scalar)
13262 fc.Result = res
13263 return ec.marshalOWrappedScalar2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚋotherpkgᚐScalar(ctx, field.Selections, res)
13264 }
13265
13266 func (ec *executionContext) fieldContext_WrappedStruct_desc(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13267 fc = &graphql.FieldContext{
13268 Object: "WrappedStruct",
13269 Field: field,
13270 IsMethod: false,
13271 IsResolver: false,
13272 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13273 return nil, errors.New("field of type WrappedScalar does not have child fields")
13274 },
13275 }
13276 return fc, nil
13277 }
13278
13279 func (ec *executionContext) _XXIt_id(ctx context.Context, field graphql.CollectedField, obj *XXIt) (ret graphql.Marshaler) {
13280 fc, err := ec.fieldContext_XXIt_id(ctx, field)
13281 if err != nil {
13282 return graphql.Null
13283 }
13284 ctx = graphql.WithFieldContext(ctx, fc)
13285 defer func() {
13286 if r := recover(); r != nil {
13287 ec.Error(ctx, ec.Recover(ctx, r))
13288 ret = graphql.Null
13289 }
13290 }()
13291 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13292 ctx = rctx
13293 return obj.ID, nil
13294 })
13295
13296 if resTmp == nil {
13297 if !graphql.HasFieldError(ctx, fc) {
13298 ec.Errorf(ctx, "must not be null")
13299 }
13300 return graphql.Null
13301 }
13302 res := resTmp.(string)
13303 fc.Result = res
13304 return ec.marshalNID2string(ctx, field.Selections, res)
13305 }
13306
13307 func (ec *executionContext) fieldContext_XXIt_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13308 fc = &graphql.FieldContext{
13309 Object: "XXIt",
13310 Field: field,
13311 IsMethod: false,
13312 IsResolver: false,
13313 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13314 return nil, errors.New("field of type ID does not have child fields")
13315 },
13316 }
13317 return fc, nil
13318 }
13319
13320 func (ec *executionContext) _XxIt_id(ctx context.Context, field graphql.CollectedField, obj *XxIt) (ret graphql.Marshaler) {
13321 fc, err := ec.fieldContext_XxIt_id(ctx, field)
13322 if err != nil {
13323 return graphql.Null
13324 }
13325 ctx = graphql.WithFieldContext(ctx, fc)
13326 defer func() {
13327 if r := recover(); r != nil {
13328 ec.Error(ctx, ec.Recover(ctx, r))
13329 ret = graphql.Null
13330 }
13331 }()
13332 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13333 ctx = rctx
13334 return obj.ID, nil
13335 })
13336
13337 if resTmp == nil {
13338 if !graphql.HasFieldError(ctx, fc) {
13339 ec.Errorf(ctx, "must not be null")
13340 }
13341 return graphql.Null
13342 }
13343 res := resTmp.(string)
13344 fc.Result = res
13345 return ec.marshalNID2string(ctx, field.Selections, res)
13346 }
13347
13348 func (ec *executionContext) fieldContext_XxIt_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13349 fc = &graphql.FieldContext{
13350 Object: "XxIt",
13351 Field: field,
13352 IsMethod: false,
13353 IsResolver: false,
13354 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13355 return nil, errors.New("field of type ID does not have child fields")
13356 },
13357 }
13358 return fc, nil
13359 }
13360
13361 func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
13362 fc, err := ec.fieldContext___Directive_name(ctx, field)
13363 if err != nil {
13364 return graphql.Null
13365 }
13366 ctx = graphql.WithFieldContext(ctx, fc)
13367 defer func() {
13368 if r := recover(); r != nil {
13369 ec.Error(ctx, ec.Recover(ctx, r))
13370 ret = graphql.Null
13371 }
13372 }()
13373 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13374 ctx = rctx
13375 return obj.Name, nil
13376 })
13377
13378 if resTmp == nil {
13379 if !graphql.HasFieldError(ctx, fc) {
13380 ec.Errorf(ctx, "must not be null")
13381 }
13382 return graphql.Null
13383 }
13384 res := resTmp.(string)
13385 fc.Result = res
13386 return ec.marshalNString2string(ctx, field.Selections, res)
13387 }
13388
13389 func (ec *executionContext) fieldContext___Directive_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13390 fc = &graphql.FieldContext{
13391 Object: "__Directive",
13392 Field: field,
13393 IsMethod: false,
13394 IsResolver: false,
13395 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13396 return nil, errors.New("field of type String does not have child fields")
13397 },
13398 }
13399 return fc, nil
13400 }
13401
13402 func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
13403 fc, err := ec.fieldContext___Directive_description(ctx, field)
13404 if err != nil {
13405 return graphql.Null
13406 }
13407 ctx = graphql.WithFieldContext(ctx, fc)
13408 defer func() {
13409 if r := recover(); r != nil {
13410 ec.Error(ctx, ec.Recover(ctx, r))
13411 ret = graphql.Null
13412 }
13413 }()
13414 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13415 ctx = rctx
13416 return obj.Description(), nil
13417 })
13418
13419 if resTmp == nil {
13420 return graphql.Null
13421 }
13422 res := resTmp.(*string)
13423 fc.Result = res
13424 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
13425 }
13426
13427 func (ec *executionContext) fieldContext___Directive_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13428 fc = &graphql.FieldContext{
13429 Object: "__Directive",
13430 Field: field,
13431 IsMethod: true,
13432 IsResolver: false,
13433 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13434 return nil, errors.New("field of type String does not have child fields")
13435 },
13436 }
13437 return fc, nil
13438 }
13439
13440 func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
13441 fc, err := ec.fieldContext___Directive_locations(ctx, field)
13442 if err != nil {
13443 return graphql.Null
13444 }
13445 ctx = graphql.WithFieldContext(ctx, fc)
13446 defer func() {
13447 if r := recover(); r != nil {
13448 ec.Error(ctx, ec.Recover(ctx, r))
13449 ret = graphql.Null
13450 }
13451 }()
13452 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13453 ctx = rctx
13454 return obj.Locations, nil
13455 })
13456
13457 if resTmp == nil {
13458 if !graphql.HasFieldError(ctx, fc) {
13459 ec.Errorf(ctx, "must not be null")
13460 }
13461 return graphql.Null
13462 }
13463 res := resTmp.([]string)
13464 fc.Result = res
13465 return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
13466 }
13467
13468 func (ec *executionContext) fieldContext___Directive_locations(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13469 fc = &graphql.FieldContext{
13470 Object: "__Directive",
13471 Field: field,
13472 IsMethod: false,
13473 IsResolver: false,
13474 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13475 return nil, errors.New("field of type __DirectiveLocation does not have child fields")
13476 },
13477 }
13478 return fc, nil
13479 }
13480
13481 func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
13482 fc, err := ec.fieldContext___Directive_args(ctx, field)
13483 if err != nil {
13484 return graphql.Null
13485 }
13486 ctx = graphql.WithFieldContext(ctx, fc)
13487 defer func() {
13488 if r := recover(); r != nil {
13489 ec.Error(ctx, ec.Recover(ctx, r))
13490 ret = graphql.Null
13491 }
13492 }()
13493 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13494 ctx = rctx
13495 return obj.Args, nil
13496 })
13497
13498 if resTmp == nil {
13499 if !graphql.HasFieldError(ctx, fc) {
13500 ec.Errorf(ctx, "must not be null")
13501 }
13502 return graphql.Null
13503 }
13504 res := resTmp.([]introspection.InputValue)
13505 fc.Result = res
13506 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
13507 }
13508
13509 func (ec *executionContext) fieldContext___Directive_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13510 fc = &graphql.FieldContext{
13511 Object: "__Directive",
13512 Field: field,
13513 IsMethod: false,
13514 IsResolver: false,
13515 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13516 switch field.Name {
13517 case "name":
13518 return ec.fieldContext___InputValue_name(ctx, field)
13519 case "description":
13520 return ec.fieldContext___InputValue_description(ctx, field)
13521 case "type":
13522 return ec.fieldContext___InputValue_type(ctx, field)
13523 case "defaultValue":
13524 return ec.fieldContext___InputValue_defaultValue(ctx, field)
13525 }
13526 return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
13527 },
13528 }
13529 return fc, nil
13530 }
13531
13532 func (ec *executionContext) ___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
13533 fc, err := ec.fieldContext___Directive_isRepeatable(ctx, field)
13534 if err != nil {
13535 return graphql.Null
13536 }
13537 ctx = graphql.WithFieldContext(ctx, fc)
13538 defer func() {
13539 if r := recover(); r != nil {
13540 ec.Error(ctx, ec.Recover(ctx, r))
13541 ret = graphql.Null
13542 }
13543 }()
13544 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13545 ctx = rctx
13546 return obj.IsRepeatable, nil
13547 })
13548
13549 if resTmp == nil {
13550 if !graphql.HasFieldError(ctx, fc) {
13551 ec.Errorf(ctx, "must not be null")
13552 }
13553 return graphql.Null
13554 }
13555 res := resTmp.(bool)
13556 fc.Result = res
13557 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
13558 }
13559
13560 func (ec *executionContext) fieldContext___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13561 fc = &graphql.FieldContext{
13562 Object: "__Directive",
13563 Field: field,
13564 IsMethod: false,
13565 IsResolver: false,
13566 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13567 return nil, errors.New("field of type Boolean does not have child fields")
13568 },
13569 }
13570 return fc, nil
13571 }
13572
13573 func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
13574 fc, err := ec.fieldContext___EnumValue_name(ctx, field)
13575 if err != nil {
13576 return graphql.Null
13577 }
13578 ctx = graphql.WithFieldContext(ctx, fc)
13579 defer func() {
13580 if r := recover(); r != nil {
13581 ec.Error(ctx, ec.Recover(ctx, r))
13582 ret = graphql.Null
13583 }
13584 }()
13585 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13586 ctx = rctx
13587 return obj.Name, nil
13588 })
13589
13590 if resTmp == nil {
13591 if !graphql.HasFieldError(ctx, fc) {
13592 ec.Errorf(ctx, "must not be null")
13593 }
13594 return graphql.Null
13595 }
13596 res := resTmp.(string)
13597 fc.Result = res
13598 return ec.marshalNString2string(ctx, field.Selections, res)
13599 }
13600
13601 func (ec *executionContext) fieldContext___EnumValue_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13602 fc = &graphql.FieldContext{
13603 Object: "__EnumValue",
13604 Field: field,
13605 IsMethod: false,
13606 IsResolver: false,
13607 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13608 return nil, errors.New("field of type String does not have child fields")
13609 },
13610 }
13611 return fc, nil
13612 }
13613
13614 func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
13615 fc, err := ec.fieldContext___EnumValue_description(ctx, field)
13616 if err != nil {
13617 return graphql.Null
13618 }
13619 ctx = graphql.WithFieldContext(ctx, fc)
13620 defer func() {
13621 if r := recover(); r != nil {
13622 ec.Error(ctx, ec.Recover(ctx, r))
13623 ret = graphql.Null
13624 }
13625 }()
13626 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13627 ctx = rctx
13628 return obj.Description(), nil
13629 })
13630
13631 if resTmp == nil {
13632 return graphql.Null
13633 }
13634 res := resTmp.(*string)
13635 fc.Result = res
13636 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
13637 }
13638
13639 func (ec *executionContext) fieldContext___EnumValue_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13640 fc = &graphql.FieldContext{
13641 Object: "__EnumValue",
13642 Field: field,
13643 IsMethod: true,
13644 IsResolver: false,
13645 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13646 return nil, errors.New("field of type String does not have child fields")
13647 },
13648 }
13649 return fc, nil
13650 }
13651
13652 func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
13653 fc, err := ec.fieldContext___EnumValue_isDeprecated(ctx, field)
13654 if err != nil {
13655 return graphql.Null
13656 }
13657 ctx = graphql.WithFieldContext(ctx, fc)
13658 defer func() {
13659 if r := recover(); r != nil {
13660 ec.Error(ctx, ec.Recover(ctx, r))
13661 ret = graphql.Null
13662 }
13663 }()
13664 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13665 ctx = rctx
13666 return obj.IsDeprecated(), nil
13667 })
13668
13669 if resTmp == nil {
13670 if !graphql.HasFieldError(ctx, fc) {
13671 ec.Errorf(ctx, "must not be null")
13672 }
13673 return graphql.Null
13674 }
13675 res := resTmp.(bool)
13676 fc.Result = res
13677 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
13678 }
13679
13680 func (ec *executionContext) fieldContext___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13681 fc = &graphql.FieldContext{
13682 Object: "__EnumValue",
13683 Field: field,
13684 IsMethod: true,
13685 IsResolver: false,
13686 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13687 return nil, errors.New("field of type Boolean does not have child fields")
13688 },
13689 }
13690 return fc, nil
13691 }
13692
13693 func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
13694 fc, err := ec.fieldContext___EnumValue_deprecationReason(ctx, field)
13695 if err != nil {
13696 return graphql.Null
13697 }
13698 ctx = graphql.WithFieldContext(ctx, fc)
13699 defer func() {
13700 if r := recover(); r != nil {
13701 ec.Error(ctx, ec.Recover(ctx, r))
13702 ret = graphql.Null
13703 }
13704 }()
13705 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13706 ctx = rctx
13707 return obj.DeprecationReason(), nil
13708 })
13709
13710 if resTmp == nil {
13711 return graphql.Null
13712 }
13713 res := resTmp.(*string)
13714 fc.Result = res
13715 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
13716 }
13717
13718 func (ec *executionContext) fieldContext___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13719 fc = &graphql.FieldContext{
13720 Object: "__EnumValue",
13721 Field: field,
13722 IsMethod: true,
13723 IsResolver: false,
13724 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13725 return nil, errors.New("field of type String does not have child fields")
13726 },
13727 }
13728 return fc, nil
13729 }
13730
13731 func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
13732 fc, err := ec.fieldContext___Field_name(ctx, field)
13733 if err != nil {
13734 return graphql.Null
13735 }
13736 ctx = graphql.WithFieldContext(ctx, fc)
13737 defer func() {
13738 if r := recover(); r != nil {
13739 ec.Error(ctx, ec.Recover(ctx, r))
13740 ret = graphql.Null
13741 }
13742 }()
13743 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13744 ctx = rctx
13745 return obj.Name, nil
13746 })
13747
13748 if resTmp == nil {
13749 if !graphql.HasFieldError(ctx, fc) {
13750 ec.Errorf(ctx, "must not be null")
13751 }
13752 return graphql.Null
13753 }
13754 res := resTmp.(string)
13755 fc.Result = res
13756 return ec.marshalNString2string(ctx, field.Selections, res)
13757 }
13758
13759 func (ec *executionContext) fieldContext___Field_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13760 fc = &graphql.FieldContext{
13761 Object: "__Field",
13762 Field: field,
13763 IsMethod: false,
13764 IsResolver: false,
13765 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13766 return nil, errors.New("field of type String does not have child fields")
13767 },
13768 }
13769 return fc, nil
13770 }
13771
13772 func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
13773 fc, err := ec.fieldContext___Field_description(ctx, field)
13774 if err != nil {
13775 return graphql.Null
13776 }
13777 ctx = graphql.WithFieldContext(ctx, fc)
13778 defer func() {
13779 if r := recover(); r != nil {
13780 ec.Error(ctx, ec.Recover(ctx, r))
13781 ret = graphql.Null
13782 }
13783 }()
13784 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13785 ctx = rctx
13786 return obj.Description(), nil
13787 })
13788
13789 if resTmp == nil {
13790 return graphql.Null
13791 }
13792 res := resTmp.(*string)
13793 fc.Result = res
13794 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
13795 }
13796
13797 func (ec *executionContext) fieldContext___Field_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13798 fc = &graphql.FieldContext{
13799 Object: "__Field",
13800 Field: field,
13801 IsMethod: true,
13802 IsResolver: false,
13803 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13804 return nil, errors.New("field of type String does not have child fields")
13805 },
13806 }
13807 return fc, nil
13808 }
13809
13810 func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
13811 fc, err := ec.fieldContext___Field_args(ctx, field)
13812 if err != nil {
13813 return graphql.Null
13814 }
13815 ctx = graphql.WithFieldContext(ctx, fc)
13816 defer func() {
13817 if r := recover(); r != nil {
13818 ec.Error(ctx, ec.Recover(ctx, r))
13819 ret = graphql.Null
13820 }
13821 }()
13822 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13823 ctx = rctx
13824 return obj.Args, nil
13825 })
13826
13827 if resTmp == nil {
13828 if !graphql.HasFieldError(ctx, fc) {
13829 ec.Errorf(ctx, "must not be null")
13830 }
13831 return graphql.Null
13832 }
13833 res := resTmp.([]introspection.InputValue)
13834 fc.Result = res
13835 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
13836 }
13837
13838 func (ec *executionContext) fieldContext___Field_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13839 fc = &graphql.FieldContext{
13840 Object: "__Field",
13841 Field: field,
13842 IsMethod: false,
13843 IsResolver: false,
13844 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13845 switch field.Name {
13846 case "name":
13847 return ec.fieldContext___InputValue_name(ctx, field)
13848 case "description":
13849 return ec.fieldContext___InputValue_description(ctx, field)
13850 case "type":
13851 return ec.fieldContext___InputValue_type(ctx, field)
13852 case "defaultValue":
13853 return ec.fieldContext___InputValue_defaultValue(ctx, field)
13854 }
13855 return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
13856 },
13857 }
13858 return fc, nil
13859 }
13860
13861 func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
13862 fc, err := ec.fieldContext___Field_type(ctx, field)
13863 if err != nil {
13864 return graphql.Null
13865 }
13866 ctx = graphql.WithFieldContext(ctx, fc)
13867 defer func() {
13868 if r := recover(); r != nil {
13869 ec.Error(ctx, ec.Recover(ctx, r))
13870 ret = graphql.Null
13871 }
13872 }()
13873 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13874 ctx = rctx
13875 return obj.Type, nil
13876 })
13877
13878 if resTmp == nil {
13879 if !graphql.HasFieldError(ctx, fc) {
13880 ec.Errorf(ctx, "must not be null")
13881 }
13882 return graphql.Null
13883 }
13884 res := resTmp.(*introspection.Type)
13885 fc.Result = res
13886 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
13887 }
13888
13889 func (ec *executionContext) fieldContext___Field_type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13890 fc = &graphql.FieldContext{
13891 Object: "__Field",
13892 Field: field,
13893 IsMethod: false,
13894 IsResolver: false,
13895 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13896 switch field.Name {
13897 case "kind":
13898 return ec.fieldContext___Type_kind(ctx, field)
13899 case "name":
13900 return ec.fieldContext___Type_name(ctx, field)
13901 case "description":
13902 return ec.fieldContext___Type_description(ctx, field)
13903 case "fields":
13904 return ec.fieldContext___Type_fields(ctx, field)
13905 case "interfaces":
13906 return ec.fieldContext___Type_interfaces(ctx, field)
13907 case "possibleTypes":
13908 return ec.fieldContext___Type_possibleTypes(ctx, field)
13909 case "enumValues":
13910 return ec.fieldContext___Type_enumValues(ctx, field)
13911 case "inputFields":
13912 return ec.fieldContext___Type_inputFields(ctx, field)
13913 case "ofType":
13914 return ec.fieldContext___Type_ofType(ctx, field)
13915 case "specifiedByURL":
13916 return ec.fieldContext___Type_specifiedByURL(ctx, field)
13917 }
13918 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
13919 },
13920 }
13921 return fc, nil
13922 }
13923
13924 func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
13925 fc, err := ec.fieldContext___Field_isDeprecated(ctx, field)
13926 if err != nil {
13927 return graphql.Null
13928 }
13929 ctx = graphql.WithFieldContext(ctx, fc)
13930 defer func() {
13931 if r := recover(); r != nil {
13932 ec.Error(ctx, ec.Recover(ctx, r))
13933 ret = graphql.Null
13934 }
13935 }()
13936 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13937 ctx = rctx
13938 return obj.IsDeprecated(), nil
13939 })
13940
13941 if resTmp == nil {
13942 if !graphql.HasFieldError(ctx, fc) {
13943 ec.Errorf(ctx, "must not be null")
13944 }
13945 return graphql.Null
13946 }
13947 res := resTmp.(bool)
13948 fc.Result = res
13949 return ec.marshalNBoolean2bool(ctx, field.Selections, res)
13950 }
13951
13952 func (ec *executionContext) fieldContext___Field_isDeprecated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13953 fc = &graphql.FieldContext{
13954 Object: "__Field",
13955 Field: field,
13956 IsMethod: true,
13957 IsResolver: false,
13958 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13959 return nil, errors.New("field of type Boolean does not have child fields")
13960 },
13961 }
13962 return fc, nil
13963 }
13964
13965 func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
13966 fc, err := ec.fieldContext___Field_deprecationReason(ctx, field)
13967 if err != nil {
13968 return graphql.Null
13969 }
13970 ctx = graphql.WithFieldContext(ctx, fc)
13971 defer func() {
13972 if r := recover(); r != nil {
13973 ec.Error(ctx, ec.Recover(ctx, r))
13974 ret = graphql.Null
13975 }
13976 }()
13977 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
13978 ctx = rctx
13979 return obj.DeprecationReason(), nil
13980 })
13981
13982 if resTmp == nil {
13983 return graphql.Null
13984 }
13985 res := resTmp.(*string)
13986 fc.Result = res
13987 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
13988 }
13989
13990 func (ec *executionContext) fieldContext___Field_deprecationReason(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
13991 fc = &graphql.FieldContext{
13992 Object: "__Field",
13993 Field: field,
13994 IsMethod: true,
13995 IsResolver: false,
13996 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
13997 return nil, errors.New("field of type String does not have child fields")
13998 },
13999 }
14000 return fc, nil
14001 }
14002
14003 func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
14004 fc, err := ec.fieldContext___InputValue_name(ctx, field)
14005 if err != nil {
14006 return graphql.Null
14007 }
14008 ctx = graphql.WithFieldContext(ctx, fc)
14009 defer func() {
14010 if r := recover(); r != nil {
14011 ec.Error(ctx, ec.Recover(ctx, r))
14012 ret = graphql.Null
14013 }
14014 }()
14015 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14016 ctx = rctx
14017 return obj.Name, nil
14018 })
14019
14020 if resTmp == nil {
14021 if !graphql.HasFieldError(ctx, fc) {
14022 ec.Errorf(ctx, "must not be null")
14023 }
14024 return graphql.Null
14025 }
14026 res := resTmp.(string)
14027 fc.Result = res
14028 return ec.marshalNString2string(ctx, field.Selections, res)
14029 }
14030
14031 func (ec *executionContext) fieldContext___InputValue_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14032 fc = &graphql.FieldContext{
14033 Object: "__InputValue",
14034 Field: field,
14035 IsMethod: false,
14036 IsResolver: false,
14037 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14038 return nil, errors.New("field of type String does not have child fields")
14039 },
14040 }
14041 return fc, nil
14042 }
14043
14044 func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
14045 fc, err := ec.fieldContext___InputValue_description(ctx, field)
14046 if err != nil {
14047 return graphql.Null
14048 }
14049 ctx = graphql.WithFieldContext(ctx, fc)
14050 defer func() {
14051 if r := recover(); r != nil {
14052 ec.Error(ctx, ec.Recover(ctx, r))
14053 ret = graphql.Null
14054 }
14055 }()
14056 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14057 ctx = rctx
14058 return obj.Description(), nil
14059 })
14060
14061 if resTmp == nil {
14062 return graphql.Null
14063 }
14064 res := resTmp.(*string)
14065 fc.Result = res
14066 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
14067 }
14068
14069 func (ec *executionContext) fieldContext___InputValue_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14070 fc = &graphql.FieldContext{
14071 Object: "__InputValue",
14072 Field: field,
14073 IsMethod: true,
14074 IsResolver: false,
14075 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14076 return nil, errors.New("field of type String does not have child fields")
14077 },
14078 }
14079 return fc, nil
14080 }
14081
14082 func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
14083 fc, err := ec.fieldContext___InputValue_type(ctx, field)
14084 if err != nil {
14085 return graphql.Null
14086 }
14087 ctx = graphql.WithFieldContext(ctx, fc)
14088 defer func() {
14089 if r := recover(); r != nil {
14090 ec.Error(ctx, ec.Recover(ctx, r))
14091 ret = graphql.Null
14092 }
14093 }()
14094 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14095 ctx = rctx
14096 return obj.Type, nil
14097 })
14098
14099 if resTmp == nil {
14100 if !graphql.HasFieldError(ctx, fc) {
14101 ec.Errorf(ctx, "must not be null")
14102 }
14103 return graphql.Null
14104 }
14105 res := resTmp.(*introspection.Type)
14106 fc.Result = res
14107 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
14108 }
14109
14110 func (ec *executionContext) fieldContext___InputValue_type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14111 fc = &graphql.FieldContext{
14112 Object: "__InputValue",
14113 Field: field,
14114 IsMethod: false,
14115 IsResolver: false,
14116 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14117 switch field.Name {
14118 case "kind":
14119 return ec.fieldContext___Type_kind(ctx, field)
14120 case "name":
14121 return ec.fieldContext___Type_name(ctx, field)
14122 case "description":
14123 return ec.fieldContext___Type_description(ctx, field)
14124 case "fields":
14125 return ec.fieldContext___Type_fields(ctx, field)
14126 case "interfaces":
14127 return ec.fieldContext___Type_interfaces(ctx, field)
14128 case "possibleTypes":
14129 return ec.fieldContext___Type_possibleTypes(ctx, field)
14130 case "enumValues":
14131 return ec.fieldContext___Type_enumValues(ctx, field)
14132 case "inputFields":
14133 return ec.fieldContext___Type_inputFields(ctx, field)
14134 case "ofType":
14135 return ec.fieldContext___Type_ofType(ctx, field)
14136 case "specifiedByURL":
14137 return ec.fieldContext___Type_specifiedByURL(ctx, field)
14138 }
14139 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
14140 },
14141 }
14142 return fc, nil
14143 }
14144
14145 func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
14146 fc, err := ec.fieldContext___InputValue_defaultValue(ctx, field)
14147 if err != nil {
14148 return graphql.Null
14149 }
14150 ctx = graphql.WithFieldContext(ctx, fc)
14151 defer func() {
14152 if r := recover(); r != nil {
14153 ec.Error(ctx, ec.Recover(ctx, r))
14154 ret = graphql.Null
14155 }
14156 }()
14157 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14158 ctx = rctx
14159 return obj.DefaultValue, nil
14160 })
14161
14162 if resTmp == nil {
14163 return graphql.Null
14164 }
14165 res := resTmp.(*string)
14166 fc.Result = res
14167 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
14168 }
14169
14170 func (ec *executionContext) fieldContext___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14171 fc = &graphql.FieldContext{
14172 Object: "__InputValue",
14173 Field: field,
14174 IsMethod: false,
14175 IsResolver: false,
14176 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14177 return nil, errors.New("field of type String does not have child fields")
14178 },
14179 }
14180 return fc, nil
14181 }
14182
14183 func (ec *executionContext) ___Schema_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
14184 fc, err := ec.fieldContext___Schema_description(ctx, field)
14185 if err != nil {
14186 return graphql.Null
14187 }
14188 ctx = graphql.WithFieldContext(ctx, fc)
14189 defer func() {
14190 if r := recover(); r != nil {
14191 ec.Error(ctx, ec.Recover(ctx, r))
14192 ret = graphql.Null
14193 }
14194 }()
14195 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14196 ctx = rctx
14197 return obj.Description(), nil
14198 })
14199
14200 if resTmp == nil {
14201 return graphql.Null
14202 }
14203 res := resTmp.(*string)
14204 fc.Result = res
14205 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
14206 }
14207
14208 func (ec *executionContext) fieldContext___Schema_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14209 fc = &graphql.FieldContext{
14210 Object: "__Schema",
14211 Field: field,
14212 IsMethod: true,
14213 IsResolver: false,
14214 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14215 return nil, errors.New("field of type String does not have child fields")
14216 },
14217 }
14218 return fc, nil
14219 }
14220
14221 func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
14222 fc, err := ec.fieldContext___Schema_types(ctx, field)
14223 if err != nil {
14224 return graphql.Null
14225 }
14226 ctx = graphql.WithFieldContext(ctx, fc)
14227 defer func() {
14228 if r := recover(); r != nil {
14229 ec.Error(ctx, ec.Recover(ctx, r))
14230 ret = graphql.Null
14231 }
14232 }()
14233 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14234 ctx = rctx
14235 return obj.Types(), nil
14236 })
14237
14238 if resTmp == nil {
14239 if !graphql.HasFieldError(ctx, fc) {
14240 ec.Errorf(ctx, "must not be null")
14241 }
14242 return graphql.Null
14243 }
14244 res := resTmp.([]introspection.Type)
14245 fc.Result = res
14246 return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
14247 }
14248
14249 func (ec *executionContext) fieldContext___Schema_types(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14250 fc = &graphql.FieldContext{
14251 Object: "__Schema",
14252 Field: field,
14253 IsMethod: true,
14254 IsResolver: false,
14255 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14256 switch field.Name {
14257 case "kind":
14258 return ec.fieldContext___Type_kind(ctx, field)
14259 case "name":
14260 return ec.fieldContext___Type_name(ctx, field)
14261 case "description":
14262 return ec.fieldContext___Type_description(ctx, field)
14263 case "fields":
14264 return ec.fieldContext___Type_fields(ctx, field)
14265 case "interfaces":
14266 return ec.fieldContext___Type_interfaces(ctx, field)
14267 case "possibleTypes":
14268 return ec.fieldContext___Type_possibleTypes(ctx, field)
14269 case "enumValues":
14270 return ec.fieldContext___Type_enumValues(ctx, field)
14271 case "inputFields":
14272 return ec.fieldContext___Type_inputFields(ctx, field)
14273 case "ofType":
14274 return ec.fieldContext___Type_ofType(ctx, field)
14275 case "specifiedByURL":
14276 return ec.fieldContext___Type_specifiedByURL(ctx, field)
14277 }
14278 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
14279 },
14280 }
14281 return fc, nil
14282 }
14283
14284 func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
14285 fc, err := ec.fieldContext___Schema_queryType(ctx, field)
14286 if err != nil {
14287 return graphql.Null
14288 }
14289 ctx = graphql.WithFieldContext(ctx, fc)
14290 defer func() {
14291 if r := recover(); r != nil {
14292 ec.Error(ctx, ec.Recover(ctx, r))
14293 ret = graphql.Null
14294 }
14295 }()
14296 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14297 ctx = rctx
14298 return obj.QueryType(), nil
14299 })
14300
14301 if resTmp == nil {
14302 if !graphql.HasFieldError(ctx, fc) {
14303 ec.Errorf(ctx, "must not be null")
14304 }
14305 return graphql.Null
14306 }
14307 res := resTmp.(*introspection.Type)
14308 fc.Result = res
14309 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
14310 }
14311
14312 func (ec *executionContext) fieldContext___Schema_queryType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14313 fc = &graphql.FieldContext{
14314 Object: "__Schema",
14315 Field: field,
14316 IsMethod: true,
14317 IsResolver: false,
14318 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14319 switch field.Name {
14320 case "kind":
14321 return ec.fieldContext___Type_kind(ctx, field)
14322 case "name":
14323 return ec.fieldContext___Type_name(ctx, field)
14324 case "description":
14325 return ec.fieldContext___Type_description(ctx, field)
14326 case "fields":
14327 return ec.fieldContext___Type_fields(ctx, field)
14328 case "interfaces":
14329 return ec.fieldContext___Type_interfaces(ctx, field)
14330 case "possibleTypes":
14331 return ec.fieldContext___Type_possibleTypes(ctx, field)
14332 case "enumValues":
14333 return ec.fieldContext___Type_enumValues(ctx, field)
14334 case "inputFields":
14335 return ec.fieldContext___Type_inputFields(ctx, field)
14336 case "ofType":
14337 return ec.fieldContext___Type_ofType(ctx, field)
14338 case "specifiedByURL":
14339 return ec.fieldContext___Type_specifiedByURL(ctx, field)
14340 }
14341 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
14342 },
14343 }
14344 return fc, nil
14345 }
14346
14347 func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
14348 fc, err := ec.fieldContext___Schema_mutationType(ctx, field)
14349 if err != nil {
14350 return graphql.Null
14351 }
14352 ctx = graphql.WithFieldContext(ctx, fc)
14353 defer func() {
14354 if r := recover(); r != nil {
14355 ec.Error(ctx, ec.Recover(ctx, r))
14356 ret = graphql.Null
14357 }
14358 }()
14359 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14360 ctx = rctx
14361 return obj.MutationType(), nil
14362 })
14363
14364 if resTmp == nil {
14365 return graphql.Null
14366 }
14367 res := resTmp.(*introspection.Type)
14368 fc.Result = res
14369 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
14370 }
14371
14372 func (ec *executionContext) fieldContext___Schema_mutationType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14373 fc = &graphql.FieldContext{
14374 Object: "__Schema",
14375 Field: field,
14376 IsMethod: true,
14377 IsResolver: false,
14378 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14379 switch field.Name {
14380 case "kind":
14381 return ec.fieldContext___Type_kind(ctx, field)
14382 case "name":
14383 return ec.fieldContext___Type_name(ctx, field)
14384 case "description":
14385 return ec.fieldContext___Type_description(ctx, field)
14386 case "fields":
14387 return ec.fieldContext___Type_fields(ctx, field)
14388 case "interfaces":
14389 return ec.fieldContext___Type_interfaces(ctx, field)
14390 case "possibleTypes":
14391 return ec.fieldContext___Type_possibleTypes(ctx, field)
14392 case "enumValues":
14393 return ec.fieldContext___Type_enumValues(ctx, field)
14394 case "inputFields":
14395 return ec.fieldContext___Type_inputFields(ctx, field)
14396 case "ofType":
14397 return ec.fieldContext___Type_ofType(ctx, field)
14398 case "specifiedByURL":
14399 return ec.fieldContext___Type_specifiedByURL(ctx, field)
14400 }
14401 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
14402 },
14403 }
14404 return fc, nil
14405 }
14406
14407 func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
14408 fc, err := ec.fieldContext___Schema_subscriptionType(ctx, field)
14409 if err != nil {
14410 return graphql.Null
14411 }
14412 ctx = graphql.WithFieldContext(ctx, fc)
14413 defer func() {
14414 if r := recover(); r != nil {
14415 ec.Error(ctx, ec.Recover(ctx, r))
14416 ret = graphql.Null
14417 }
14418 }()
14419 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14420 ctx = rctx
14421 return obj.SubscriptionType(), nil
14422 })
14423
14424 if resTmp == nil {
14425 return graphql.Null
14426 }
14427 res := resTmp.(*introspection.Type)
14428 fc.Result = res
14429 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
14430 }
14431
14432 func (ec *executionContext) fieldContext___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14433 fc = &graphql.FieldContext{
14434 Object: "__Schema",
14435 Field: field,
14436 IsMethod: true,
14437 IsResolver: false,
14438 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14439 switch field.Name {
14440 case "kind":
14441 return ec.fieldContext___Type_kind(ctx, field)
14442 case "name":
14443 return ec.fieldContext___Type_name(ctx, field)
14444 case "description":
14445 return ec.fieldContext___Type_description(ctx, field)
14446 case "fields":
14447 return ec.fieldContext___Type_fields(ctx, field)
14448 case "interfaces":
14449 return ec.fieldContext___Type_interfaces(ctx, field)
14450 case "possibleTypes":
14451 return ec.fieldContext___Type_possibleTypes(ctx, field)
14452 case "enumValues":
14453 return ec.fieldContext___Type_enumValues(ctx, field)
14454 case "inputFields":
14455 return ec.fieldContext___Type_inputFields(ctx, field)
14456 case "ofType":
14457 return ec.fieldContext___Type_ofType(ctx, field)
14458 case "specifiedByURL":
14459 return ec.fieldContext___Type_specifiedByURL(ctx, field)
14460 }
14461 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
14462 },
14463 }
14464 return fc, nil
14465 }
14466
14467 func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
14468 fc, err := ec.fieldContext___Schema_directives(ctx, field)
14469 if err != nil {
14470 return graphql.Null
14471 }
14472 ctx = graphql.WithFieldContext(ctx, fc)
14473 defer func() {
14474 if r := recover(); r != nil {
14475 ec.Error(ctx, ec.Recover(ctx, r))
14476 ret = graphql.Null
14477 }
14478 }()
14479 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14480 ctx = rctx
14481 return obj.Directives(), nil
14482 })
14483
14484 if resTmp == nil {
14485 if !graphql.HasFieldError(ctx, fc) {
14486 ec.Errorf(ctx, "must not be null")
14487 }
14488 return graphql.Null
14489 }
14490 res := resTmp.([]introspection.Directive)
14491 fc.Result = res
14492 return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
14493 }
14494
14495 func (ec *executionContext) fieldContext___Schema_directives(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14496 fc = &graphql.FieldContext{
14497 Object: "__Schema",
14498 Field: field,
14499 IsMethod: true,
14500 IsResolver: false,
14501 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14502 switch field.Name {
14503 case "name":
14504 return ec.fieldContext___Directive_name(ctx, field)
14505 case "description":
14506 return ec.fieldContext___Directive_description(ctx, field)
14507 case "locations":
14508 return ec.fieldContext___Directive_locations(ctx, field)
14509 case "args":
14510 return ec.fieldContext___Directive_args(ctx, field)
14511 case "isRepeatable":
14512 return ec.fieldContext___Directive_isRepeatable(ctx, field)
14513 }
14514 return nil, fmt.Errorf("no field named %q was found under type __Directive", field.Name)
14515 },
14516 }
14517 return fc, nil
14518 }
14519
14520 func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14521 fc, err := ec.fieldContext___Type_kind(ctx, field)
14522 if err != nil {
14523 return graphql.Null
14524 }
14525 ctx = graphql.WithFieldContext(ctx, fc)
14526 defer func() {
14527 if r := recover(); r != nil {
14528 ec.Error(ctx, ec.Recover(ctx, r))
14529 ret = graphql.Null
14530 }
14531 }()
14532 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14533 ctx = rctx
14534 return obj.Kind(), nil
14535 })
14536
14537 if resTmp == nil {
14538 if !graphql.HasFieldError(ctx, fc) {
14539 ec.Errorf(ctx, "must not be null")
14540 }
14541 return graphql.Null
14542 }
14543 res := resTmp.(string)
14544 fc.Result = res
14545 return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
14546 }
14547
14548 func (ec *executionContext) fieldContext___Type_kind(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14549 fc = &graphql.FieldContext{
14550 Object: "__Type",
14551 Field: field,
14552 IsMethod: true,
14553 IsResolver: false,
14554 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14555 return nil, errors.New("field of type __TypeKind does not have child fields")
14556 },
14557 }
14558 return fc, nil
14559 }
14560
14561 func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14562 fc, err := ec.fieldContext___Type_name(ctx, field)
14563 if err != nil {
14564 return graphql.Null
14565 }
14566 ctx = graphql.WithFieldContext(ctx, fc)
14567 defer func() {
14568 if r := recover(); r != nil {
14569 ec.Error(ctx, ec.Recover(ctx, r))
14570 ret = graphql.Null
14571 }
14572 }()
14573 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14574 ctx = rctx
14575 return obj.Name(), nil
14576 })
14577
14578 if resTmp == nil {
14579 return graphql.Null
14580 }
14581 res := resTmp.(*string)
14582 fc.Result = res
14583 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
14584 }
14585
14586 func (ec *executionContext) fieldContext___Type_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14587 fc = &graphql.FieldContext{
14588 Object: "__Type",
14589 Field: field,
14590 IsMethod: true,
14591 IsResolver: false,
14592 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14593 return nil, errors.New("field of type String does not have child fields")
14594 },
14595 }
14596 return fc, nil
14597 }
14598
14599 func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14600 fc, err := ec.fieldContext___Type_description(ctx, field)
14601 if err != nil {
14602 return graphql.Null
14603 }
14604 ctx = graphql.WithFieldContext(ctx, fc)
14605 defer func() {
14606 if r := recover(); r != nil {
14607 ec.Error(ctx, ec.Recover(ctx, r))
14608 ret = graphql.Null
14609 }
14610 }()
14611 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14612 ctx = rctx
14613 return obj.Description(), nil
14614 })
14615
14616 if resTmp == nil {
14617 return graphql.Null
14618 }
14619 res := resTmp.(*string)
14620 fc.Result = res
14621 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
14622 }
14623
14624 func (ec *executionContext) fieldContext___Type_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14625 fc = &graphql.FieldContext{
14626 Object: "__Type",
14627 Field: field,
14628 IsMethod: true,
14629 IsResolver: false,
14630 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14631 return nil, errors.New("field of type String does not have child fields")
14632 },
14633 }
14634 return fc, nil
14635 }
14636
14637 func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14638 fc, err := ec.fieldContext___Type_fields(ctx, field)
14639 if err != nil {
14640 return graphql.Null
14641 }
14642 ctx = graphql.WithFieldContext(ctx, fc)
14643 defer func() {
14644 if r := recover(); r != nil {
14645 ec.Error(ctx, ec.Recover(ctx, r))
14646 ret = graphql.Null
14647 }
14648 }()
14649 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14650 ctx = rctx
14651 return obj.Fields(fc.Args["includeDeprecated"].(bool)), nil
14652 })
14653
14654 if resTmp == nil {
14655 return graphql.Null
14656 }
14657 res := resTmp.([]introspection.Field)
14658 fc.Result = res
14659 return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
14660 }
14661
14662 func (ec *executionContext) fieldContext___Type_fields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14663 fc = &graphql.FieldContext{
14664 Object: "__Type",
14665 Field: field,
14666 IsMethod: true,
14667 IsResolver: false,
14668 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14669 switch field.Name {
14670 case "name":
14671 return ec.fieldContext___Field_name(ctx, field)
14672 case "description":
14673 return ec.fieldContext___Field_description(ctx, field)
14674 case "args":
14675 return ec.fieldContext___Field_args(ctx, field)
14676 case "type":
14677 return ec.fieldContext___Field_type(ctx, field)
14678 case "isDeprecated":
14679 return ec.fieldContext___Field_isDeprecated(ctx, field)
14680 case "deprecationReason":
14681 return ec.fieldContext___Field_deprecationReason(ctx, field)
14682 }
14683 return nil, fmt.Errorf("no field named %q was found under type __Field", field.Name)
14684 },
14685 }
14686 defer func() {
14687 if r := recover(); r != nil {
14688 err = ec.Recover(ctx, r)
14689 ec.Error(ctx, err)
14690 }
14691 }()
14692 ctx = graphql.WithFieldContext(ctx, fc)
14693 if fc.Args, err = ec.field___Type_fields_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
14694 ec.Error(ctx, err)
14695 return fc, err
14696 }
14697 return fc, nil
14698 }
14699
14700 func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14701 fc, err := ec.fieldContext___Type_interfaces(ctx, field)
14702 if err != nil {
14703 return graphql.Null
14704 }
14705 ctx = graphql.WithFieldContext(ctx, fc)
14706 defer func() {
14707 if r := recover(); r != nil {
14708 ec.Error(ctx, ec.Recover(ctx, r))
14709 ret = graphql.Null
14710 }
14711 }()
14712 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14713 ctx = rctx
14714 return obj.Interfaces(), nil
14715 })
14716
14717 if resTmp == nil {
14718 return graphql.Null
14719 }
14720 res := resTmp.([]introspection.Type)
14721 fc.Result = res
14722 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
14723 }
14724
14725 func (ec *executionContext) fieldContext___Type_interfaces(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14726 fc = &graphql.FieldContext{
14727 Object: "__Type",
14728 Field: field,
14729 IsMethod: true,
14730 IsResolver: false,
14731 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14732 switch field.Name {
14733 case "kind":
14734 return ec.fieldContext___Type_kind(ctx, field)
14735 case "name":
14736 return ec.fieldContext___Type_name(ctx, field)
14737 case "description":
14738 return ec.fieldContext___Type_description(ctx, field)
14739 case "fields":
14740 return ec.fieldContext___Type_fields(ctx, field)
14741 case "interfaces":
14742 return ec.fieldContext___Type_interfaces(ctx, field)
14743 case "possibleTypes":
14744 return ec.fieldContext___Type_possibleTypes(ctx, field)
14745 case "enumValues":
14746 return ec.fieldContext___Type_enumValues(ctx, field)
14747 case "inputFields":
14748 return ec.fieldContext___Type_inputFields(ctx, field)
14749 case "ofType":
14750 return ec.fieldContext___Type_ofType(ctx, field)
14751 case "specifiedByURL":
14752 return ec.fieldContext___Type_specifiedByURL(ctx, field)
14753 }
14754 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
14755 },
14756 }
14757 return fc, nil
14758 }
14759
14760 func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14761 fc, err := ec.fieldContext___Type_possibleTypes(ctx, field)
14762 if err != nil {
14763 return graphql.Null
14764 }
14765 ctx = graphql.WithFieldContext(ctx, fc)
14766 defer func() {
14767 if r := recover(); r != nil {
14768 ec.Error(ctx, ec.Recover(ctx, r))
14769 ret = graphql.Null
14770 }
14771 }()
14772 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14773 ctx = rctx
14774 return obj.PossibleTypes(), nil
14775 })
14776
14777 if resTmp == nil {
14778 return graphql.Null
14779 }
14780 res := resTmp.([]introspection.Type)
14781 fc.Result = res
14782 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
14783 }
14784
14785 func (ec *executionContext) fieldContext___Type_possibleTypes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14786 fc = &graphql.FieldContext{
14787 Object: "__Type",
14788 Field: field,
14789 IsMethod: true,
14790 IsResolver: false,
14791 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14792 switch field.Name {
14793 case "kind":
14794 return ec.fieldContext___Type_kind(ctx, field)
14795 case "name":
14796 return ec.fieldContext___Type_name(ctx, field)
14797 case "description":
14798 return ec.fieldContext___Type_description(ctx, field)
14799 case "fields":
14800 return ec.fieldContext___Type_fields(ctx, field)
14801 case "interfaces":
14802 return ec.fieldContext___Type_interfaces(ctx, field)
14803 case "possibleTypes":
14804 return ec.fieldContext___Type_possibleTypes(ctx, field)
14805 case "enumValues":
14806 return ec.fieldContext___Type_enumValues(ctx, field)
14807 case "inputFields":
14808 return ec.fieldContext___Type_inputFields(ctx, field)
14809 case "ofType":
14810 return ec.fieldContext___Type_ofType(ctx, field)
14811 case "specifiedByURL":
14812 return ec.fieldContext___Type_specifiedByURL(ctx, field)
14813 }
14814 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
14815 },
14816 }
14817 return fc, nil
14818 }
14819
14820 func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14821 fc, err := ec.fieldContext___Type_enumValues(ctx, field)
14822 if err != nil {
14823 return graphql.Null
14824 }
14825 ctx = graphql.WithFieldContext(ctx, fc)
14826 defer func() {
14827 if r := recover(); r != nil {
14828 ec.Error(ctx, ec.Recover(ctx, r))
14829 ret = graphql.Null
14830 }
14831 }()
14832 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14833 ctx = rctx
14834 return obj.EnumValues(fc.Args["includeDeprecated"].(bool)), nil
14835 })
14836
14837 if resTmp == nil {
14838 return graphql.Null
14839 }
14840 res := resTmp.([]introspection.EnumValue)
14841 fc.Result = res
14842 return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
14843 }
14844
14845 func (ec *executionContext) fieldContext___Type_enumValues(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14846 fc = &graphql.FieldContext{
14847 Object: "__Type",
14848 Field: field,
14849 IsMethod: true,
14850 IsResolver: false,
14851 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14852 switch field.Name {
14853 case "name":
14854 return ec.fieldContext___EnumValue_name(ctx, field)
14855 case "description":
14856 return ec.fieldContext___EnumValue_description(ctx, field)
14857 case "isDeprecated":
14858 return ec.fieldContext___EnumValue_isDeprecated(ctx, field)
14859 case "deprecationReason":
14860 return ec.fieldContext___EnumValue_deprecationReason(ctx, field)
14861 }
14862 return nil, fmt.Errorf("no field named %q was found under type __EnumValue", field.Name)
14863 },
14864 }
14865 defer func() {
14866 if r := recover(); r != nil {
14867 err = ec.Recover(ctx, r)
14868 ec.Error(ctx, err)
14869 }
14870 }()
14871 ctx = graphql.WithFieldContext(ctx, fc)
14872 if fc.Args, err = ec.field___Type_enumValues_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
14873 ec.Error(ctx, err)
14874 return fc, err
14875 }
14876 return fc, nil
14877 }
14878
14879 func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14880 fc, err := ec.fieldContext___Type_inputFields(ctx, field)
14881 if err != nil {
14882 return graphql.Null
14883 }
14884 ctx = graphql.WithFieldContext(ctx, fc)
14885 defer func() {
14886 if r := recover(); r != nil {
14887 ec.Error(ctx, ec.Recover(ctx, r))
14888 ret = graphql.Null
14889 }
14890 }()
14891 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14892 ctx = rctx
14893 return obj.InputFields(), nil
14894 })
14895
14896 if resTmp == nil {
14897 return graphql.Null
14898 }
14899 res := resTmp.([]introspection.InputValue)
14900 fc.Result = res
14901 return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
14902 }
14903
14904 func (ec *executionContext) fieldContext___Type_inputFields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14905 fc = &graphql.FieldContext{
14906 Object: "__Type",
14907 Field: field,
14908 IsMethod: true,
14909 IsResolver: false,
14910 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14911 switch field.Name {
14912 case "name":
14913 return ec.fieldContext___InputValue_name(ctx, field)
14914 case "description":
14915 return ec.fieldContext___InputValue_description(ctx, field)
14916 case "type":
14917 return ec.fieldContext___InputValue_type(ctx, field)
14918 case "defaultValue":
14919 return ec.fieldContext___InputValue_defaultValue(ctx, field)
14920 }
14921 return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
14922 },
14923 }
14924 return fc, nil
14925 }
14926
14927 func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14928 fc, err := ec.fieldContext___Type_ofType(ctx, field)
14929 if err != nil {
14930 return graphql.Null
14931 }
14932 ctx = graphql.WithFieldContext(ctx, fc)
14933 defer func() {
14934 if r := recover(); r != nil {
14935 ec.Error(ctx, ec.Recover(ctx, r))
14936 ret = graphql.Null
14937 }
14938 }()
14939 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
14940 ctx = rctx
14941 return obj.OfType(), nil
14942 })
14943
14944 if resTmp == nil {
14945 return graphql.Null
14946 }
14947 res := resTmp.(*introspection.Type)
14948 fc.Result = res
14949 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
14950 }
14951
14952 func (ec *executionContext) fieldContext___Type_ofType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
14953 fc = &graphql.FieldContext{
14954 Object: "__Type",
14955 Field: field,
14956 IsMethod: true,
14957 IsResolver: false,
14958 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
14959 switch field.Name {
14960 case "kind":
14961 return ec.fieldContext___Type_kind(ctx, field)
14962 case "name":
14963 return ec.fieldContext___Type_name(ctx, field)
14964 case "description":
14965 return ec.fieldContext___Type_description(ctx, field)
14966 case "fields":
14967 return ec.fieldContext___Type_fields(ctx, field)
14968 case "interfaces":
14969 return ec.fieldContext___Type_interfaces(ctx, field)
14970 case "possibleTypes":
14971 return ec.fieldContext___Type_possibleTypes(ctx, field)
14972 case "enumValues":
14973 return ec.fieldContext___Type_enumValues(ctx, field)
14974 case "inputFields":
14975 return ec.fieldContext___Type_inputFields(ctx, field)
14976 case "ofType":
14977 return ec.fieldContext___Type_ofType(ctx, field)
14978 case "specifiedByURL":
14979 return ec.fieldContext___Type_specifiedByURL(ctx, field)
14980 }
14981 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
14982 },
14983 }
14984 return fc, nil
14985 }
14986
14987 func (ec *executionContext) ___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
14988 fc, err := ec.fieldContext___Type_specifiedByURL(ctx, field)
14989 if err != nil {
14990 return graphql.Null
14991 }
14992 ctx = graphql.WithFieldContext(ctx, fc)
14993 defer func() {
14994 if r := recover(); r != nil {
14995 ec.Error(ctx, ec.Recover(ctx, r))
14996 ret = graphql.Null
14997 }
14998 }()
14999 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
15000 ctx = rctx
15001 return obj.SpecifiedByURL(), nil
15002 })
15003
15004 if resTmp == nil {
15005 return graphql.Null
15006 }
15007 res := resTmp.(*string)
15008 fc.Result = res
15009 return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
15010 }
15011
15012 func (ec *executionContext) fieldContext___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
15013 fc = &graphql.FieldContext{
15014 Object: "__Type",
15015 Field: field,
15016 IsMethod: true,
15017 IsResolver: false,
15018 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
15019 return nil, errors.New("field of type String does not have child fields")
15020 },
15021 }
15022 return fc, nil
15023 }
15024
15025 func (ec *executionContext) _asdfIt_id(ctx context.Context, field graphql.CollectedField, obj *AsdfIt) (ret graphql.Marshaler) {
15026 fc, err := ec.fieldContext_asdfIt_id(ctx, field)
15027 if err != nil {
15028 return graphql.Null
15029 }
15030 ctx = graphql.WithFieldContext(ctx, fc)
15031 defer func() {
15032 if r := recover(); r != nil {
15033 ec.Error(ctx, ec.Recover(ctx, r))
15034 ret = graphql.Null
15035 }
15036 }()
15037 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
15038 ctx = rctx
15039 return obj.ID, nil
15040 })
15041
15042 if resTmp == nil {
15043 if !graphql.HasFieldError(ctx, fc) {
15044 ec.Errorf(ctx, "must not be null")
15045 }
15046 return graphql.Null
15047 }
15048 res := resTmp.(string)
15049 fc.Result = res
15050 return ec.marshalNID2string(ctx, field.Selections, res)
15051 }
15052
15053 func (ec *executionContext) fieldContext_asdfIt_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
15054 fc = &graphql.FieldContext{
15055 Object: "asdfIt",
15056 Field: field,
15057 IsMethod: false,
15058 IsResolver: false,
15059 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
15060 return nil, errors.New("field of type ID does not have child fields")
15061 },
15062 }
15063 return fc, nil
15064 }
15065
15066 func (ec *executionContext) _iIt_id(ctx context.Context, field graphql.CollectedField, obj *IIt) (ret graphql.Marshaler) {
15067 fc, err := ec.fieldContext_iIt_id(ctx, field)
15068 if err != nil {
15069 return graphql.Null
15070 }
15071 ctx = graphql.WithFieldContext(ctx, fc)
15072 defer func() {
15073 if r := recover(); r != nil {
15074 ec.Error(ctx, ec.Recover(ctx, r))
15075 ret = graphql.Null
15076 }
15077 }()
15078 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
15079 ctx = rctx
15080 return obj.ID, nil
15081 })
15082
15083 if resTmp == nil {
15084 if !graphql.HasFieldError(ctx, fc) {
15085 ec.Errorf(ctx, "must not be null")
15086 }
15087 return graphql.Null
15088 }
15089 res := resTmp.(string)
15090 fc.Result = res
15091 return ec.marshalNID2string(ctx, field.Selections, res)
15092 }
15093
15094 func (ec *executionContext) fieldContext_iIt_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
15095 fc = &graphql.FieldContext{
15096 Object: "iIt",
15097 Field: field,
15098 IsMethod: false,
15099 IsResolver: false,
15100 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
15101 return nil, errors.New("field of type ID does not have child fields")
15102 },
15103 }
15104 return fc, nil
15105 }
15106
15107
15108
15109
15110
15111 func (ec *executionContext) unmarshalInputChanges(ctx context.Context, obj interface{}) (map[string]interface{}, error) {
15112 it := make(map[string]interface{}, len(obj.(map[string]interface{})))
15113 asMap := map[string]interface{}{}
15114 for k, v := range obj.(map[string]interface{}) {
15115 asMap[k] = v
15116 }
15117
15118 fieldsInOrder := [...]string{"a", "b"}
15119 for _, k := range fieldsInOrder {
15120 v, ok := asMap[k]
15121 if !ok {
15122 continue
15123 }
15124 switch k {
15125 case "a":
15126 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("a"))
15127 data, err := ec.unmarshalOInt2ᚖint(ctx, v)
15128 if err != nil {
15129 return it, err
15130 }
15131 it["a"] = data
15132 case "b":
15133 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("b"))
15134 data, err := ec.unmarshalOInt2ᚖint(ctx, v)
15135 if err != nil {
15136 return it, err
15137 }
15138 it["b"] = data
15139 }
15140 }
15141
15142 return it, nil
15143 }
15144
15145 func (ec *executionContext) unmarshalInputDefaultInput(ctx context.Context, obj interface{}) (DefaultInput, error) {
15146 var it DefaultInput
15147 asMap := map[string]interface{}{}
15148 for k, v := range obj.(map[string]interface{}) {
15149 asMap[k] = v
15150 }
15151
15152 if _, present := asMap["falsyBoolean"]; !present {
15153 asMap["falsyBoolean"] = false
15154 }
15155 if _, present := asMap["truthyBoolean"]; !present {
15156 asMap["truthyBoolean"] = true
15157 }
15158
15159 fieldsInOrder := [...]string{"falsyBoolean", "truthyBoolean"}
15160 for _, k := range fieldsInOrder {
15161 v, ok := asMap[k]
15162 if !ok {
15163 continue
15164 }
15165 switch k {
15166 case "falsyBoolean":
15167 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("falsyBoolean"))
15168 data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v)
15169 if err != nil {
15170 return it, err
15171 }
15172 it.FalsyBoolean = data
15173 case "truthyBoolean":
15174 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("truthyBoolean"))
15175 data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v)
15176 if err != nil {
15177 return it, err
15178 }
15179 it.TruthyBoolean = data
15180 }
15181 }
15182
15183 return it, nil
15184 }
15185
15186 func (ec *executionContext) unmarshalInputFieldsOrderInput(ctx context.Context, obj interface{}) (FieldsOrderInput, error) {
15187 var it FieldsOrderInput
15188 asMap := map[string]interface{}{}
15189 for k, v := range obj.(map[string]interface{}) {
15190 asMap[k] = v
15191 }
15192
15193 fieldsInOrder := [...]string{"firstField", "overrideFirstField"}
15194 for _, k := range fieldsInOrder {
15195 v, ok := asMap[k]
15196 if !ok {
15197 continue
15198 }
15199 switch k {
15200 case "firstField":
15201 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("firstField"))
15202 data, err := ec.unmarshalOString2ᚖstring(ctx, v)
15203 if err != nil {
15204 return it, err
15205 }
15206 it.FirstField = data
15207 case "overrideFirstField":
15208 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("overrideFirstField"))
15209 data, err := ec.unmarshalOString2ᚖstring(ctx, v)
15210 if err != nil {
15211 return it, err
15212 }
15213 if err = ec.resolvers.FieldsOrderInput().OverrideFirstField(ctx, &it, data); err != nil {
15214 return it, err
15215 }
15216 }
15217 }
15218
15219 return it, nil
15220 }
15221
15222 func (ec *executionContext) unmarshalInputInnerDirectives(ctx context.Context, obj interface{}) (InnerDirectives, error) {
15223 var it InnerDirectives
15224 asMap := map[string]interface{}{}
15225 for k, v := range obj.(map[string]interface{}) {
15226 asMap[k] = v
15227 }
15228
15229 fieldsInOrder := [...]string{"message"}
15230 for _, k := range fieldsInOrder {
15231 v, ok := asMap[k]
15232 if !ok {
15233 continue
15234 }
15235 switch k {
15236 case "message":
15237 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
15238 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalNString2string(ctx, v) }
15239 directive1 := func(ctx context.Context) (interface{}, error) {
15240 min, err := ec.unmarshalNInt2int(ctx, 1)
15241 if err != nil {
15242 return nil, err
15243 }
15244 message, err := ec.unmarshalOString2ᚖstring(ctx, "not valid")
15245 if err != nil {
15246 return nil, err
15247 }
15248 if ec.directives.Length == nil {
15249 return nil, errors.New("directive length is not implemented")
15250 }
15251 return ec.directives.Length(ctx, obj, directive0, min, nil, message)
15252 }
15253
15254 tmp, err := directive1(ctx)
15255 if err != nil {
15256 return it, graphql.ErrorOnPath(ctx, err)
15257 }
15258 if data, ok := tmp.(string); ok {
15259 it.Message = data
15260 } else {
15261 err := fmt.Errorf(`unexpected type %T from directive, should be string`, tmp)
15262 return it, graphql.ErrorOnPath(ctx, err)
15263 }
15264 }
15265 }
15266
15267 return it, nil
15268 }
15269
15270 func (ec *executionContext) unmarshalInputInnerInput(ctx context.Context, obj interface{}) (InnerInput, error) {
15271 var it InnerInput
15272 asMap := map[string]interface{}{}
15273 for k, v := range obj.(map[string]interface{}) {
15274 asMap[k] = v
15275 }
15276
15277 fieldsInOrder := [...]string{"id"}
15278 for _, k := range fieldsInOrder {
15279 v, ok := asMap[k]
15280 if !ok {
15281 continue
15282 }
15283 switch k {
15284 case "id":
15285 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
15286 data, err := ec.unmarshalNInt2int(ctx, v)
15287 if err != nil {
15288 return it, err
15289 }
15290 it.ID = data
15291 }
15292 }
15293
15294 return it, nil
15295 }
15296
15297 func (ec *executionContext) unmarshalInputInputDirectives(ctx context.Context, obj interface{}) (InputDirectives, error) {
15298 var it InputDirectives
15299 asMap := map[string]interface{}{}
15300 for k, v := range obj.(map[string]interface{}) {
15301 asMap[k] = v
15302 }
15303
15304 fieldsInOrder := [...]string{"text", "nullableText", "inner", "innerNullable", "thirdParty"}
15305 for _, k := range fieldsInOrder {
15306 v, ok := asMap[k]
15307 if !ok {
15308 continue
15309 }
15310 switch k {
15311 case "text":
15312 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text"))
15313 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalNString2string(ctx, v) }
15314 directive1 := func(ctx context.Context) (interface{}, error) {
15315 if ec.directives.Directive3 == nil {
15316 return nil, errors.New("directive directive3 is not implemented")
15317 }
15318 return ec.directives.Directive3(ctx, obj, directive0)
15319 }
15320 directive2 := func(ctx context.Context) (interface{}, error) {
15321 min, err := ec.unmarshalNInt2int(ctx, 0)
15322 if err != nil {
15323 return nil, err
15324 }
15325 max, err := ec.unmarshalOInt2ᚖint(ctx, 7)
15326 if err != nil {
15327 return nil, err
15328 }
15329 message, err := ec.unmarshalOString2ᚖstring(ctx, "not valid")
15330 if err != nil {
15331 return nil, err
15332 }
15333 if ec.directives.Length == nil {
15334 return nil, errors.New("directive length is not implemented")
15335 }
15336 return ec.directives.Length(ctx, obj, directive1, min, max, message)
15337 }
15338
15339 tmp, err := directive2(ctx)
15340 if err != nil {
15341 return it, graphql.ErrorOnPath(ctx, err)
15342 }
15343 if data, ok := tmp.(string); ok {
15344 it.Text = data
15345 } else {
15346 err := fmt.Errorf(`unexpected type %T from directive, should be string`, tmp)
15347 return it, graphql.ErrorOnPath(ctx, err)
15348 }
15349 case "nullableText":
15350 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nullableText"))
15351 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOString2ᚖstring(ctx, v) }
15352 directive1 := func(ctx context.Context) (interface{}, error) {
15353 if ec.directives.Directive3 == nil {
15354 return nil, errors.New("directive directive3 is not implemented")
15355 }
15356 return ec.directives.Directive3(ctx, obj, directive0)
15357 }
15358 directive2 := func(ctx context.Context) (interface{}, error) {
15359 if ec.directives.ToNull == nil {
15360 return nil, errors.New("directive toNull is not implemented")
15361 }
15362 return ec.directives.ToNull(ctx, obj, directive1)
15363 }
15364
15365 tmp, err := directive2(ctx)
15366 if err != nil {
15367 return it, graphql.ErrorOnPath(ctx, err)
15368 }
15369 if data, ok := tmp.(*string); ok {
15370 it.NullableText = data
15371 } else if tmp == nil {
15372 it.NullableText = nil
15373 } else {
15374 err := fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp)
15375 return it, graphql.ErrorOnPath(ctx, err)
15376 }
15377 case "inner":
15378 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("inner"))
15379 directive0 := func(ctx context.Context) (interface{}, error) {
15380 return ec.unmarshalNInnerDirectives2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInnerDirectives(ctx, v)
15381 }
15382 directive1 := func(ctx context.Context) (interface{}, error) {
15383 if ec.directives.Directive3 == nil {
15384 return nil, errors.New("directive directive3 is not implemented")
15385 }
15386 return ec.directives.Directive3(ctx, obj, directive0)
15387 }
15388
15389 tmp, err := directive1(ctx)
15390 if err != nil {
15391 return it, graphql.ErrorOnPath(ctx, err)
15392 }
15393 if data, ok := tmp.(*InnerDirectives); ok {
15394 it.Inner = data
15395 } else if tmp == nil {
15396 it.Inner = nil
15397 } else {
15398 err := fmt.Errorf(`unexpected type %T from directive, should be *github.com/99designs/gqlgen/codegen/testserver/singlefile.InnerDirectives`, tmp)
15399 return it, graphql.ErrorOnPath(ctx, err)
15400 }
15401 case "innerNullable":
15402 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("innerNullable"))
15403 directive0 := func(ctx context.Context) (interface{}, error) {
15404 return ec.unmarshalOInnerDirectives2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInnerDirectives(ctx, v)
15405 }
15406 directive1 := func(ctx context.Context) (interface{}, error) {
15407 if ec.directives.Directive3 == nil {
15408 return nil, errors.New("directive directive3 is not implemented")
15409 }
15410 return ec.directives.Directive3(ctx, obj, directive0)
15411 }
15412
15413 tmp, err := directive1(ctx)
15414 if err != nil {
15415 return it, graphql.ErrorOnPath(ctx, err)
15416 }
15417 if data, ok := tmp.(*InnerDirectives); ok {
15418 it.InnerNullable = data
15419 } else if tmp == nil {
15420 it.InnerNullable = nil
15421 } else {
15422 err := fmt.Errorf(`unexpected type %T from directive, should be *github.com/99designs/gqlgen/codegen/testserver/singlefile.InnerDirectives`, tmp)
15423 return it, graphql.ErrorOnPath(ctx, err)
15424 }
15425 case "thirdParty":
15426 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("thirdParty"))
15427 directive0 := func(ctx context.Context) (interface{}, error) {
15428 return ec.unmarshalOThirdParty2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐThirdParty(ctx, v)
15429 }
15430 directive1 := func(ctx context.Context) (interface{}, error) {
15431 if ec.directives.Directive3 == nil {
15432 return nil, errors.New("directive directive3 is not implemented")
15433 }
15434 return ec.directives.Directive3(ctx, obj, directive0)
15435 }
15436 directive2 := func(ctx context.Context) (interface{}, error) {
15437 min, err := ec.unmarshalNInt2int(ctx, 0)
15438 if err != nil {
15439 return nil, err
15440 }
15441 max, err := ec.unmarshalOInt2ᚖint(ctx, 7)
15442 if err != nil {
15443 return nil, err
15444 }
15445 if ec.directives.Length == nil {
15446 return nil, errors.New("directive length is not implemented")
15447 }
15448 return ec.directives.Length(ctx, obj, directive1, min, max, nil)
15449 }
15450
15451 tmp, err := directive2(ctx)
15452 if err != nil {
15453 return it, graphql.ErrorOnPath(ctx, err)
15454 }
15455 if data, ok := tmp.(*ThirdParty); ok {
15456 it.ThirdParty = data
15457 } else if tmp == nil {
15458 it.ThirdParty = nil
15459 } else {
15460 err := fmt.Errorf(`unexpected type %T from directive, should be *github.com/99designs/gqlgen/codegen/testserver/singlefile.ThirdParty`, tmp)
15461 return it, graphql.ErrorOnPath(ctx, err)
15462 }
15463 }
15464 }
15465
15466 return it, nil
15467 }
15468
15469 func (ec *executionContext) unmarshalInputInputWithEnumValue(ctx context.Context, obj interface{}) (InputWithEnumValue, error) {
15470 var it InputWithEnumValue
15471 asMap := map[string]interface{}{}
15472 for k, v := range obj.(map[string]interface{}) {
15473 asMap[k] = v
15474 }
15475
15476 fieldsInOrder := [...]string{"enum"}
15477 for _, k := range fieldsInOrder {
15478 v, ok := asMap[k]
15479 if !ok {
15480 continue
15481 }
15482 switch k {
15483 case "enum":
15484 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("enum"))
15485 data, err := ec.unmarshalNEnumTest2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐEnumTest(ctx, v)
15486 if err != nil {
15487 return it, err
15488 }
15489 it.Enum = data
15490 }
15491 }
15492
15493 return it, nil
15494 }
15495
15496 func (ec *executionContext) unmarshalInputMapNestedInput(ctx context.Context, obj interface{}) (MapNested, error) {
15497 var it MapNested
15498 asMap := map[string]interface{}{}
15499 for k, v := range obj.(map[string]interface{}) {
15500 asMap[k] = v
15501 }
15502
15503 fieldsInOrder := [...]string{"value"}
15504 for _, k := range fieldsInOrder {
15505 v, ok := asMap[k]
15506 if !ok {
15507 continue
15508 }
15509 switch k {
15510 case "value":
15511 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("value"))
15512 data, err := ec.unmarshalNCustomScalar2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCustomScalar(ctx, v)
15513 if err != nil {
15514 return it, err
15515 }
15516 it.Value = data
15517 }
15518 }
15519
15520 return it, nil
15521 }
15522
15523 func (ec *executionContext) unmarshalInputMapStringInterfaceInput(ctx context.Context, obj interface{}) (map[string]interface{}, error) {
15524 it := make(map[string]interface{}, len(obj.(map[string]interface{})))
15525 asMap := map[string]interface{}{}
15526 for k, v := range obj.(map[string]interface{}) {
15527 asMap[k] = v
15528 }
15529
15530 fieldsInOrder := [...]string{"a", "b", "c", "nested"}
15531 for _, k := range fieldsInOrder {
15532 v, ok := asMap[k]
15533 if !ok {
15534 continue
15535 }
15536 switch k {
15537 case "a":
15538 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("a"))
15539 data, err := ec.unmarshalNString2string(ctx, v)
15540 if err != nil {
15541 return it, err
15542 }
15543 it["a"] = data
15544 case "b":
15545 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("b"))
15546 data, err := ec.unmarshalOInt2ᚖint(ctx, v)
15547 if err != nil {
15548 return it, err
15549 }
15550 it["b"] = data
15551 case "c":
15552 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("c"))
15553 data, err := ec.unmarshalOCustomScalar2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCustomScalar(ctx, v)
15554 if err != nil {
15555 return it, err
15556 }
15557 it["c"] = data
15558 case "nested":
15559 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nested"))
15560 data, err := ec.unmarshalOMapNestedInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐMapNested(ctx, v)
15561 if err != nil {
15562 return it, err
15563 }
15564 it["nested"] = data
15565 }
15566 }
15567
15568 return it, nil
15569 }
15570
15571 func (ec *executionContext) unmarshalInputNestedInput(ctx context.Context, obj interface{}) (NestedInput, error) {
15572 var it NestedInput
15573 asMap := map[string]interface{}{}
15574 for k, v := range obj.(map[string]interface{}) {
15575 asMap[k] = v
15576 }
15577
15578 fieldsInOrder := [...]string{"field"}
15579 for _, k := range fieldsInOrder {
15580 v, ok := asMap[k]
15581 if !ok {
15582 continue
15583 }
15584 switch k {
15585 case "field":
15586 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field"))
15587 data, err := ec.unmarshalNEmail2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐEmail(ctx, v)
15588 if err != nil {
15589 return it, err
15590 }
15591 it.Field = data
15592 }
15593 }
15594
15595 return it, nil
15596 }
15597
15598 func (ec *executionContext) unmarshalInputNestedMapInput(ctx context.Context, obj interface{}) (NestedMapInput, error) {
15599 var it NestedMapInput
15600 asMap := map[string]interface{}{}
15601 for k, v := range obj.(map[string]interface{}) {
15602 asMap[k] = v
15603 }
15604
15605 fieldsInOrder := [...]string{"map"}
15606 for _, k := range fieldsInOrder {
15607 v, ok := asMap[k]
15608 if !ok {
15609 continue
15610 }
15611 switch k {
15612 case "map":
15613 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("map"))
15614 data, err := ec.unmarshalOMapStringInterfaceInput2map(ctx, v)
15615 if err != nil {
15616 return it, err
15617 }
15618 it.Map = data
15619 }
15620 }
15621
15622 return it, nil
15623 }
15624
15625 func (ec *executionContext) unmarshalInputOmittableInput(ctx context.Context, obj interface{}) (OmittableInput, error) {
15626 var it OmittableInput
15627 asMap := map[string]interface{}{}
15628 for k, v := range obj.(map[string]interface{}) {
15629 asMap[k] = v
15630 }
15631
15632 fieldsInOrder := [...]string{"id", "bool", "str", "int", "time", "enum", "scalar", "object"}
15633 for _, k := range fieldsInOrder {
15634 v, ok := asMap[k]
15635 if !ok {
15636 continue
15637 }
15638 switch k {
15639 case "id":
15640 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
15641 data, err := ec.unmarshalOID2ᚖstring(ctx, v)
15642 if err != nil {
15643 return it, err
15644 }
15645 it.ID = graphql.OmittableOf(data)
15646 case "bool":
15647 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("bool"))
15648 data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v)
15649 if err != nil {
15650 return it, err
15651 }
15652 it.Bool = graphql.OmittableOf(data)
15653 case "str":
15654 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("str"))
15655 data, err := ec.unmarshalOString2ᚖstring(ctx, v)
15656 if err != nil {
15657 return it, err
15658 }
15659 it.Str = graphql.OmittableOf(data)
15660 case "int":
15661 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("int"))
15662 data, err := ec.unmarshalOInt2ᚖint(ctx, v)
15663 if err != nil {
15664 return it, err
15665 }
15666 it.Int = graphql.OmittableOf(data)
15667 case "time":
15668 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("time"))
15669 data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
15670 if err != nil {
15671 return it, err
15672 }
15673 it.Time = graphql.OmittableOf(data)
15674 case "enum":
15675 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("enum"))
15676 data, err := ec.unmarshalOStatus2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐStatus(ctx, v)
15677 if err != nil {
15678 return it, err
15679 }
15680 it.Enum = graphql.OmittableOf(data)
15681 case "scalar":
15682 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scalar"))
15683 data, err := ec.unmarshalOThirdParty2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐThirdParty(ctx, v)
15684 if err != nil {
15685 return it, err
15686 }
15687 it.Scalar = graphql.OmittableOf(data)
15688 case "object":
15689 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("object"))
15690 data, err := ec.unmarshalOOuterInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOuterInput(ctx, v)
15691 if err != nil {
15692 return it, err
15693 }
15694 it.Object = graphql.OmittableOf(data)
15695 }
15696 }
15697
15698 return it, nil
15699 }
15700
15701 func (ec *executionContext) unmarshalInputOuterInput(ctx context.Context, obj interface{}) (OuterInput, error) {
15702 var it OuterInput
15703 asMap := map[string]interface{}{}
15704 for k, v := range obj.(map[string]interface{}) {
15705 asMap[k] = v
15706 }
15707
15708 fieldsInOrder := [...]string{"inner"}
15709 for _, k := range fieldsInOrder {
15710 v, ok := asMap[k]
15711 if !ok {
15712 continue
15713 }
15714 switch k {
15715 case "inner":
15716 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("inner"))
15717 data, err := ec.unmarshalNInnerInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInnerInput(ctx, v)
15718 if err != nil {
15719 return it, err
15720 }
15721 it.Inner = data
15722 }
15723 }
15724
15725 return it, nil
15726 }
15727
15728 func (ec *executionContext) unmarshalInputRecursiveInputSlice(ctx context.Context, obj interface{}) (RecursiveInputSlice, error) {
15729 var it RecursiveInputSlice
15730 asMap := map[string]interface{}{}
15731 for k, v := range obj.(map[string]interface{}) {
15732 asMap[k] = v
15733 }
15734
15735 fieldsInOrder := [...]string{"self"}
15736 for _, k := range fieldsInOrder {
15737 v, ok := asMap[k]
15738 if !ok {
15739 continue
15740 }
15741 switch k {
15742 case "self":
15743 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("self"))
15744 data, err := ec.unmarshalORecursiveInputSlice2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐRecursiveInputSliceᚄ(ctx, v)
15745 if err != nil {
15746 return it, err
15747 }
15748 it.Self = data
15749 }
15750 }
15751
15752 return it, nil
15753 }
15754
15755 func (ec *executionContext) unmarshalInputSpecialInput(ctx context.Context, obj interface{}) (SpecialInput, error) {
15756 var it SpecialInput
15757 asMap := map[string]interface{}{}
15758 for k, v := range obj.(map[string]interface{}) {
15759 asMap[k] = v
15760 }
15761
15762 fieldsInOrder := [...]string{"nesting"}
15763 for _, k := range fieldsInOrder {
15764 v, ok := asMap[k]
15765 if !ok {
15766 continue
15767 }
15768 switch k {
15769 case "nesting":
15770 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nesting"))
15771 data, err := ec.unmarshalNNestedInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐNestedInput(ctx, v)
15772 if err != nil {
15773 return it, err
15774 }
15775 it.Nesting = data
15776 }
15777 }
15778
15779 return it, nil
15780 }
15781
15782 func (ec *executionContext) unmarshalInputUpdatePtrToPtrInner(ctx context.Context, obj interface{}) (UpdatePtrToPtrInner, error) {
15783 var it UpdatePtrToPtrInner
15784 asMap := map[string]interface{}{}
15785 for k, v := range obj.(map[string]interface{}) {
15786 asMap[k] = v
15787 }
15788
15789 fieldsInOrder := [...]string{"key", "value"}
15790 for _, k := range fieldsInOrder {
15791 v, ok := asMap[k]
15792 if !ok {
15793 continue
15794 }
15795 switch k {
15796 case "key":
15797 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("key"))
15798 data, err := ec.unmarshalOString2ᚖstring(ctx, v)
15799 if err != nil {
15800 return it, err
15801 }
15802 it.Key = data
15803 case "value":
15804 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("value"))
15805 data, err := ec.unmarshalOString2ᚖstring(ctx, v)
15806 if err != nil {
15807 return it, err
15808 }
15809 it.Value = data
15810 }
15811 }
15812
15813 return it, nil
15814 }
15815
15816 func (ec *executionContext) unmarshalInputUpdatePtrToPtrOuter(ctx context.Context, obj interface{}) (UpdatePtrToPtrOuter, error) {
15817 var it UpdatePtrToPtrOuter
15818 asMap := map[string]interface{}{}
15819 for k, v := range obj.(map[string]interface{}) {
15820 asMap[k] = v
15821 }
15822
15823 fieldsInOrder := [...]string{"name", "inner", "stupidInner"}
15824 for _, k := range fieldsInOrder {
15825 v, ok := asMap[k]
15826 if !ok {
15827 continue
15828 }
15829 switch k {
15830 case "name":
15831 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
15832 data, err := ec.unmarshalOString2ᚖstring(ctx, v)
15833 if err != nil {
15834 return it, err
15835 }
15836 it.Name = data
15837 case "inner":
15838 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("inner"))
15839 data, err := ec.unmarshalOUpdatePtrToPtrInner2ᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx, v)
15840 if err != nil {
15841 return it, err
15842 }
15843 it.Inner = data
15844 case "stupidInner":
15845 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stupidInner"))
15846 data, err := ec.unmarshalOUpdatePtrToPtrInner2ᚖᚖᚖᚖᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx, v)
15847 if err != nil {
15848 return it, err
15849 }
15850 it.StupidInner = data
15851 }
15852 }
15853
15854 return it, nil
15855 }
15856
15857 func (ec *executionContext) unmarshalInputValidInput(ctx context.Context, obj interface{}) (ValidInput, error) {
15858 var it ValidInput
15859 asMap := map[string]interface{}{}
15860 for k, v := range obj.(map[string]interface{}) {
15861 asMap[k] = v
15862 }
15863
15864 fieldsInOrder := [...]string{"break", "default", "func", "interface", "select", "case", "defer", "go", "map", "struct", "chan", "else", "goto", "package", "switch", "const", "fallthrough", "if", "range", "type", "continue", "for", "import", "return", "var", "_"}
15865 for _, k := range fieldsInOrder {
15866 v, ok := asMap[k]
15867 if !ok {
15868 continue
15869 }
15870 switch k {
15871 case "break":
15872 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("break"))
15873 data, err := ec.unmarshalNString2string(ctx, v)
15874 if err != nil {
15875 return it, err
15876 }
15877 it.Break = data
15878 case "default":
15879 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("default"))
15880 data, err := ec.unmarshalNString2string(ctx, v)
15881 if err != nil {
15882 return it, err
15883 }
15884 it.Default = data
15885 case "func":
15886 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("func"))
15887 data, err := ec.unmarshalNString2string(ctx, v)
15888 if err != nil {
15889 return it, err
15890 }
15891 it.Func = data
15892 case "interface":
15893 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("interface"))
15894 data, err := ec.unmarshalNString2string(ctx, v)
15895 if err != nil {
15896 return it, err
15897 }
15898 it.Interface = data
15899 case "select":
15900 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("select"))
15901 data, err := ec.unmarshalNString2string(ctx, v)
15902 if err != nil {
15903 return it, err
15904 }
15905 it.Select = data
15906 case "case":
15907 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("case"))
15908 data, err := ec.unmarshalNString2string(ctx, v)
15909 if err != nil {
15910 return it, err
15911 }
15912 it.Case = data
15913 case "defer":
15914 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("defer"))
15915 data, err := ec.unmarshalNString2string(ctx, v)
15916 if err != nil {
15917 return it, err
15918 }
15919 it.Defer = data
15920 case "go":
15921 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("go"))
15922 data, err := ec.unmarshalNString2string(ctx, v)
15923 if err != nil {
15924 return it, err
15925 }
15926 it.Go = data
15927 case "map":
15928 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("map"))
15929 data, err := ec.unmarshalNString2string(ctx, v)
15930 if err != nil {
15931 return it, err
15932 }
15933 it.Map = data
15934 case "struct":
15935 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("struct"))
15936 data, err := ec.unmarshalNString2string(ctx, v)
15937 if err != nil {
15938 return it, err
15939 }
15940 it.Struct = data
15941 case "chan":
15942 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("chan"))
15943 data, err := ec.unmarshalNString2string(ctx, v)
15944 if err != nil {
15945 return it, err
15946 }
15947 it.Chan = data
15948 case "else":
15949 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("else"))
15950 data, err := ec.unmarshalNString2string(ctx, v)
15951 if err != nil {
15952 return it, err
15953 }
15954 it.Else = data
15955 case "goto":
15956 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("goto"))
15957 data, err := ec.unmarshalNString2string(ctx, v)
15958 if err != nil {
15959 return it, err
15960 }
15961 it.Goto = data
15962 case "package":
15963 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("package"))
15964 data, err := ec.unmarshalNString2string(ctx, v)
15965 if err != nil {
15966 return it, err
15967 }
15968 it.Package = data
15969 case "switch":
15970 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("switch"))
15971 data, err := ec.unmarshalNString2string(ctx, v)
15972 if err != nil {
15973 return it, err
15974 }
15975 it.Switch = data
15976 case "const":
15977 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("const"))
15978 data, err := ec.unmarshalNString2string(ctx, v)
15979 if err != nil {
15980 return it, err
15981 }
15982 it.Const = data
15983 case "fallthrough":
15984 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("fallthrough"))
15985 data, err := ec.unmarshalNString2string(ctx, v)
15986 if err != nil {
15987 return it, err
15988 }
15989 it.Fallthrough = data
15990 case "if":
15991 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("if"))
15992 data, err := ec.unmarshalNString2string(ctx, v)
15993 if err != nil {
15994 return it, err
15995 }
15996 it.If = data
15997 case "range":
15998 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("range"))
15999 data, err := ec.unmarshalNString2string(ctx, v)
16000 if err != nil {
16001 return it, err
16002 }
16003 it.Range = data
16004 case "type":
16005 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("type"))
16006 data, err := ec.unmarshalNString2string(ctx, v)
16007 if err != nil {
16008 return it, err
16009 }
16010 it.Type = data
16011 case "continue":
16012 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("continue"))
16013 data, err := ec.unmarshalNString2string(ctx, v)
16014 if err != nil {
16015 return it, err
16016 }
16017 it.Continue = data
16018 case "for":
16019 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("for"))
16020 data, err := ec.unmarshalNString2string(ctx, v)
16021 if err != nil {
16022 return it, err
16023 }
16024 it.For = data
16025 case "import":
16026 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("import"))
16027 data, err := ec.unmarshalNString2string(ctx, v)
16028 if err != nil {
16029 return it, err
16030 }
16031 it.Import = data
16032 case "return":
16033 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("return"))
16034 data, err := ec.unmarshalNString2string(ctx, v)
16035 if err != nil {
16036 return it, err
16037 }
16038 it.Return = data
16039 case "var":
16040 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("var"))
16041 data, err := ec.unmarshalNString2string(ctx, v)
16042 if err != nil {
16043 return it, err
16044 }
16045 it.Var = data
16046 case "_":
16047 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("_"))
16048 data, err := ec.unmarshalNString2string(ctx, v)
16049 if err != nil {
16050 return it, err
16051 }
16052 it.Underscore = data
16053 }
16054 }
16055
16056 return it, nil
16057 }
16058
16059
16060
16061
16062
16063 func (ec *executionContext) _Animal(ctx context.Context, sel ast.SelectionSet, obj Animal) graphql.Marshaler {
16064 switch obj := (obj).(type) {
16065 case nil:
16066 return graphql.Null
16067 case Horse:
16068 return ec._Horse(ctx, sel, &obj)
16069 case *Horse:
16070 if obj == nil {
16071 return graphql.Null
16072 }
16073 return ec._Horse(ctx, sel, obj)
16074 case Dog:
16075 return ec._Dog(ctx, sel, &obj)
16076 case *Dog:
16077 if obj == nil {
16078 return graphql.Null
16079 }
16080 return ec._Dog(ctx, sel, obj)
16081 case Cat:
16082 return ec._Cat(ctx, sel, &obj)
16083 case *Cat:
16084 if obj == nil {
16085 return graphql.Null
16086 }
16087 return ec._Cat(ctx, sel, obj)
16088 case Mammalian:
16089 if obj == nil {
16090 return graphql.Null
16091 }
16092 return ec._Mammalian(ctx, sel, obj)
16093 default:
16094 panic(fmt.Errorf("unexpected type %T", obj))
16095 }
16096 }
16097
16098 func (ec *executionContext) _Content_Child(ctx context.Context, sel ast.SelectionSet, obj ContentChild) graphql.Marshaler {
16099 switch obj := (obj).(type) {
16100 case nil:
16101 return graphql.Null
16102 case ContentUser:
16103 return ec._Content_User(ctx, sel, &obj)
16104 case *ContentUser:
16105 if obj == nil {
16106 return graphql.Null
16107 }
16108 return ec._Content_User(ctx, sel, obj)
16109 case ContentPost:
16110 return ec._Content_Post(ctx, sel, &obj)
16111 case *ContentPost:
16112 if obj == nil {
16113 return graphql.Null
16114 }
16115 return ec._Content_Post(ctx, sel, obj)
16116 default:
16117 panic(fmt.Errorf("unexpected type %T", obj))
16118 }
16119 }
16120
16121 func (ec *executionContext) _Mammalian(ctx context.Context, sel ast.SelectionSet, obj Mammalian) graphql.Marshaler {
16122 switch obj := (obj).(type) {
16123 case nil:
16124 return graphql.Null
16125 case Horse:
16126 return ec._Horse(ctx, sel, &obj)
16127 case *Horse:
16128 if obj == nil {
16129 return graphql.Null
16130 }
16131 return ec._Horse(ctx, sel, obj)
16132 default:
16133 panic(fmt.Errorf("unexpected type %T", obj))
16134 }
16135 }
16136
16137 func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj Node) graphql.Marshaler {
16138 switch obj := (obj).(type) {
16139 case nil:
16140 return graphql.Null
16141 case *ConcreteNodeA:
16142 if obj == nil {
16143 return graphql.Null
16144 }
16145 return ec._ConcreteNodeA(ctx, sel, obj)
16146 case ConcreteNodeInterface:
16147 if obj == nil {
16148 return graphql.Null
16149 }
16150 return ec._ConcreteNodeInterface(ctx, sel, obj)
16151 default:
16152 panic(fmt.Errorf("unexpected type %T", obj))
16153 }
16154 }
16155
16156 func (ec *executionContext) _Shape(ctx context.Context, sel ast.SelectionSet, obj Shape) graphql.Marshaler {
16157 switch obj := (obj).(type) {
16158 case nil:
16159 return graphql.Null
16160 case *Circle:
16161 if obj == nil {
16162 return graphql.Null
16163 }
16164 return ec._Circle(ctx, sel, obj)
16165 case *Rectangle:
16166 if obj == nil {
16167 return graphql.Null
16168 }
16169 return ec._Rectangle(ctx, sel, obj)
16170 default:
16171 panic(fmt.Errorf("unexpected type %T", obj))
16172 }
16173 }
16174
16175 func (ec *executionContext) _ShapeUnion(ctx context.Context, sel ast.SelectionSet, obj ShapeUnion) graphql.Marshaler {
16176 switch obj := (obj).(type) {
16177 case nil:
16178 return graphql.Null
16179 case *Circle:
16180 if obj == nil {
16181 return graphql.Null
16182 }
16183 return ec._Circle(ctx, sel, obj)
16184 case *Rectangle:
16185 if obj == nil {
16186 return graphql.Null
16187 }
16188 return ec._Rectangle(ctx, sel, obj)
16189 default:
16190 panic(fmt.Errorf("unexpected type %T", obj))
16191 }
16192 }
16193
16194 func (ec *executionContext) _TestUnion(ctx context.Context, sel ast.SelectionSet, obj TestUnion) graphql.Marshaler {
16195 switch obj := (obj).(type) {
16196 case nil:
16197 return graphql.Null
16198 case A:
16199 return ec._A(ctx, sel, &obj)
16200 case *A:
16201 if obj == nil {
16202 return graphql.Null
16203 }
16204 return ec._A(ctx, sel, obj)
16205 case B:
16206 return ec._B(ctx, sel, &obj)
16207 case *B:
16208 if obj == nil {
16209 return graphql.Null
16210 }
16211 return ec._B(ctx, sel, obj)
16212 default:
16213 panic(fmt.Errorf("unexpected type %T", obj))
16214 }
16215 }
16216
16217
16218
16219
16220
16221 var aImplementors = []string{"A", "TestUnion"}
16222
16223 func (ec *executionContext) _A(ctx context.Context, sel ast.SelectionSet, obj *A) graphql.Marshaler {
16224 fields := graphql.CollectFields(ec.OperationContext, sel, aImplementors)
16225
16226 out := graphql.NewFieldSet(fields)
16227 deferred := make(map[string]*graphql.FieldSet)
16228 for i, field := range fields {
16229 switch field.Name {
16230 case "__typename":
16231 out.Values[i] = graphql.MarshalString("A")
16232 case "id":
16233 out.Values[i] = ec._A_id(ctx, field, obj)
16234 if out.Values[i] == graphql.Null {
16235 out.Invalids++
16236 }
16237 default:
16238 panic("unknown field " + strconv.Quote(field.Name))
16239 }
16240 }
16241 out.Dispatch(ctx)
16242 if out.Invalids > 0 {
16243 return graphql.Null
16244 }
16245
16246 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16247
16248 for label, dfs := range deferred {
16249 ec.processDeferredGroup(graphql.DeferredGroup{
16250 Label: label,
16251 Path: graphql.GetPath(ctx),
16252 FieldSet: dfs,
16253 Context: ctx,
16254 })
16255 }
16256
16257 return out
16258 }
16259
16260 var aItImplementors = []string{"AIt"}
16261
16262 func (ec *executionContext) _AIt(ctx context.Context, sel ast.SelectionSet, obj *AIt) graphql.Marshaler {
16263 fields := graphql.CollectFields(ec.OperationContext, sel, aItImplementors)
16264
16265 out := graphql.NewFieldSet(fields)
16266 deferred := make(map[string]*graphql.FieldSet)
16267 for i, field := range fields {
16268 switch field.Name {
16269 case "__typename":
16270 out.Values[i] = graphql.MarshalString("AIt")
16271 case "id":
16272 out.Values[i] = ec._AIt_id(ctx, field, obj)
16273 if out.Values[i] == graphql.Null {
16274 out.Invalids++
16275 }
16276 default:
16277 panic("unknown field " + strconv.Quote(field.Name))
16278 }
16279 }
16280 out.Dispatch(ctx)
16281 if out.Invalids > 0 {
16282 return graphql.Null
16283 }
16284
16285 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16286
16287 for label, dfs := range deferred {
16288 ec.processDeferredGroup(graphql.DeferredGroup{
16289 Label: label,
16290 Path: graphql.GetPath(ctx),
16291 FieldSet: dfs,
16292 Context: ctx,
16293 })
16294 }
16295
16296 return out
16297 }
16298
16299 var abItImplementors = []string{"AbIt"}
16300
16301 func (ec *executionContext) _AbIt(ctx context.Context, sel ast.SelectionSet, obj *AbIt) graphql.Marshaler {
16302 fields := graphql.CollectFields(ec.OperationContext, sel, abItImplementors)
16303
16304 out := graphql.NewFieldSet(fields)
16305 deferred := make(map[string]*graphql.FieldSet)
16306 for i, field := range fields {
16307 switch field.Name {
16308 case "__typename":
16309 out.Values[i] = graphql.MarshalString("AbIt")
16310 case "id":
16311 out.Values[i] = ec._AbIt_id(ctx, field, obj)
16312 if out.Values[i] == graphql.Null {
16313 out.Invalids++
16314 }
16315 default:
16316 panic("unknown field " + strconv.Quote(field.Name))
16317 }
16318 }
16319 out.Dispatch(ctx)
16320 if out.Invalids > 0 {
16321 return graphql.Null
16322 }
16323
16324 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16325
16326 for label, dfs := range deferred {
16327 ec.processDeferredGroup(graphql.DeferredGroup{
16328 Label: label,
16329 Path: graphql.GetPath(ctx),
16330 FieldSet: dfs,
16331 Context: ctx,
16332 })
16333 }
16334
16335 return out
16336 }
16337
16338 var autobindImplementors = []string{"Autobind"}
16339
16340 func (ec *executionContext) _Autobind(ctx context.Context, sel ast.SelectionSet, obj *Autobind) graphql.Marshaler {
16341 fields := graphql.CollectFields(ec.OperationContext, sel, autobindImplementors)
16342
16343 out := graphql.NewFieldSet(fields)
16344 deferred := make(map[string]*graphql.FieldSet)
16345 for i, field := range fields {
16346 switch field.Name {
16347 case "__typename":
16348 out.Values[i] = graphql.MarshalString("Autobind")
16349 case "int":
16350 out.Values[i] = ec._Autobind_int(ctx, field, obj)
16351 if out.Values[i] == graphql.Null {
16352 out.Invalids++
16353 }
16354 case "int32":
16355 out.Values[i] = ec._Autobind_int32(ctx, field, obj)
16356 if out.Values[i] == graphql.Null {
16357 out.Invalids++
16358 }
16359 case "int64":
16360 out.Values[i] = ec._Autobind_int64(ctx, field, obj)
16361 if out.Values[i] == graphql.Null {
16362 out.Invalids++
16363 }
16364 case "idStr":
16365 out.Values[i] = ec._Autobind_idStr(ctx, field, obj)
16366 if out.Values[i] == graphql.Null {
16367 out.Invalids++
16368 }
16369 case "idInt":
16370 out.Values[i] = ec._Autobind_idInt(ctx, field, obj)
16371 if out.Values[i] == graphql.Null {
16372 out.Invalids++
16373 }
16374 default:
16375 panic("unknown field " + strconv.Quote(field.Name))
16376 }
16377 }
16378 out.Dispatch(ctx)
16379 if out.Invalids > 0 {
16380 return graphql.Null
16381 }
16382
16383 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16384
16385 for label, dfs := range deferred {
16386 ec.processDeferredGroup(graphql.DeferredGroup{
16387 Label: label,
16388 Path: graphql.GetPath(ctx),
16389 FieldSet: dfs,
16390 Context: ctx,
16391 })
16392 }
16393
16394 return out
16395 }
16396
16397 var bImplementors = []string{"B", "TestUnion"}
16398
16399 func (ec *executionContext) _B(ctx context.Context, sel ast.SelectionSet, obj *B) graphql.Marshaler {
16400 fields := graphql.CollectFields(ec.OperationContext, sel, bImplementors)
16401
16402 out := graphql.NewFieldSet(fields)
16403 deferred := make(map[string]*graphql.FieldSet)
16404 for i, field := range fields {
16405 switch field.Name {
16406 case "__typename":
16407 out.Values[i] = graphql.MarshalString("B")
16408 case "id":
16409 out.Values[i] = ec._B_id(ctx, field, obj)
16410 if out.Values[i] == graphql.Null {
16411 out.Invalids++
16412 }
16413 default:
16414 panic("unknown field " + strconv.Quote(field.Name))
16415 }
16416 }
16417 out.Dispatch(ctx)
16418 if out.Invalids > 0 {
16419 return graphql.Null
16420 }
16421
16422 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16423
16424 for label, dfs := range deferred {
16425 ec.processDeferredGroup(graphql.DeferredGroup{
16426 Label: label,
16427 Path: graphql.GetPath(ctx),
16428 FieldSet: dfs,
16429 Context: ctx,
16430 })
16431 }
16432
16433 return out
16434 }
16435
16436 var backedByInterfaceImplementors = []string{"BackedByInterface"}
16437
16438 func (ec *executionContext) _BackedByInterface(ctx context.Context, sel ast.SelectionSet, obj BackedByInterface) graphql.Marshaler {
16439 fields := graphql.CollectFields(ec.OperationContext, sel, backedByInterfaceImplementors)
16440
16441 out := graphql.NewFieldSet(fields)
16442 deferred := make(map[string]*graphql.FieldSet)
16443 for i, field := range fields {
16444 switch field.Name {
16445 case "__typename":
16446 out.Values[i] = graphql.MarshalString("BackedByInterface")
16447 case "id":
16448 field := field
16449
16450 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
16451 defer func() {
16452 if r := recover(); r != nil {
16453 ec.Error(ctx, ec.Recover(ctx, r))
16454 }
16455 }()
16456 res = ec._BackedByInterface_id(ctx, field, obj)
16457 if res == graphql.Null {
16458 atomic.AddUint32(&fs.Invalids, 1)
16459 }
16460 return res
16461 }
16462
16463 if field.Deferrable != nil {
16464 dfs, ok := deferred[field.Deferrable.Label]
16465 di := 0
16466 if ok {
16467 dfs.AddField(field)
16468 di = len(dfs.Values) - 1
16469 } else {
16470 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
16471 deferred[field.Deferrable.Label] = dfs
16472 }
16473 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
16474 return innerFunc(ctx, dfs)
16475 })
16476
16477
16478 out.Values[i] = graphql.Null
16479 continue
16480 }
16481
16482 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
16483 case "thisShouldBind":
16484 out.Values[i] = ec._BackedByInterface_thisShouldBind(ctx, field, obj)
16485 if out.Values[i] == graphql.Null {
16486 atomic.AddUint32(&out.Invalids, 1)
16487 }
16488 case "thisShouldBindWithError":
16489 out.Values[i] = ec._BackedByInterface_thisShouldBindWithError(ctx, field, obj)
16490 if out.Values[i] == graphql.Null {
16491 atomic.AddUint32(&out.Invalids, 1)
16492 }
16493 default:
16494 panic("unknown field " + strconv.Quote(field.Name))
16495 }
16496 }
16497 out.Dispatch(ctx)
16498 if out.Invalids > 0 {
16499 return graphql.Null
16500 }
16501
16502 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16503
16504 for label, dfs := range deferred {
16505 ec.processDeferredGroup(graphql.DeferredGroup{
16506 Label: label,
16507 Path: graphql.GetPath(ctx),
16508 FieldSet: dfs,
16509 Context: ctx,
16510 })
16511 }
16512
16513 return out
16514 }
16515
16516 var catImplementors = []string{"Cat", "Animal"}
16517
16518 func (ec *executionContext) _Cat(ctx context.Context, sel ast.SelectionSet, obj *Cat) graphql.Marshaler {
16519 fields := graphql.CollectFields(ec.OperationContext, sel, catImplementors)
16520
16521 out := graphql.NewFieldSet(fields)
16522 deferred := make(map[string]*graphql.FieldSet)
16523 for i, field := range fields {
16524 switch field.Name {
16525 case "__typename":
16526 out.Values[i] = graphql.MarshalString("Cat")
16527 case "species":
16528 out.Values[i] = ec._Cat_species(ctx, field, obj)
16529 if out.Values[i] == graphql.Null {
16530 out.Invalids++
16531 }
16532 case "size":
16533 out.Values[i] = ec._Cat_size(ctx, field, obj)
16534 if out.Values[i] == graphql.Null {
16535 out.Invalids++
16536 }
16537 case "catBreed":
16538 out.Values[i] = ec._Cat_catBreed(ctx, field, obj)
16539 if out.Values[i] == graphql.Null {
16540 out.Invalids++
16541 }
16542 default:
16543 panic("unknown field " + strconv.Quote(field.Name))
16544 }
16545 }
16546 out.Dispatch(ctx)
16547 if out.Invalids > 0 {
16548 return graphql.Null
16549 }
16550
16551 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16552
16553 for label, dfs := range deferred {
16554 ec.processDeferredGroup(graphql.DeferredGroup{
16555 Label: label,
16556 Path: graphql.GetPath(ctx),
16557 FieldSet: dfs,
16558 Context: ctx,
16559 })
16560 }
16561
16562 return out
16563 }
16564
16565 var checkIssue896Implementors = []string{"CheckIssue896"}
16566
16567 func (ec *executionContext) _CheckIssue896(ctx context.Context, sel ast.SelectionSet, obj *CheckIssue896) graphql.Marshaler {
16568 fields := graphql.CollectFields(ec.OperationContext, sel, checkIssue896Implementors)
16569
16570 out := graphql.NewFieldSet(fields)
16571 deferred := make(map[string]*graphql.FieldSet)
16572 for i, field := range fields {
16573 switch field.Name {
16574 case "__typename":
16575 out.Values[i] = graphql.MarshalString("CheckIssue896")
16576 case "id":
16577 out.Values[i] = ec._CheckIssue896_id(ctx, field, obj)
16578 default:
16579 panic("unknown field " + strconv.Quote(field.Name))
16580 }
16581 }
16582 out.Dispatch(ctx)
16583 if out.Invalids > 0 {
16584 return graphql.Null
16585 }
16586
16587 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16588
16589 for label, dfs := range deferred {
16590 ec.processDeferredGroup(graphql.DeferredGroup{
16591 Label: label,
16592 Path: graphql.GetPath(ctx),
16593 FieldSet: dfs,
16594 Context: ctx,
16595 })
16596 }
16597
16598 return out
16599 }
16600
16601 var circleImplementors = []string{"Circle", "Shape", "ShapeUnion"}
16602
16603 func (ec *executionContext) _Circle(ctx context.Context, sel ast.SelectionSet, obj *Circle) graphql.Marshaler {
16604 fields := graphql.CollectFields(ec.OperationContext, sel, circleImplementors)
16605
16606 out := graphql.NewFieldSet(fields)
16607 deferred := make(map[string]*graphql.FieldSet)
16608 for i, field := range fields {
16609 switch field.Name {
16610 case "__typename":
16611 out.Values[i] = graphql.MarshalString("Circle")
16612 case "radius":
16613 out.Values[i] = ec._Circle_radius(ctx, field, obj)
16614 case "area":
16615 out.Values[i] = ec._Circle_area(ctx, field, obj)
16616 case "coordinates":
16617 out.Values[i] = ec._Circle_coordinates(ctx, field, obj)
16618 default:
16619 panic("unknown field " + strconv.Quote(field.Name))
16620 }
16621 }
16622 out.Dispatch(ctx)
16623 if out.Invalids > 0 {
16624 return graphql.Null
16625 }
16626
16627 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16628
16629 for label, dfs := range deferred {
16630 ec.processDeferredGroup(graphql.DeferredGroup{
16631 Label: label,
16632 Path: graphql.GetPath(ctx),
16633 FieldSet: dfs,
16634 Context: ctx,
16635 })
16636 }
16637
16638 return out
16639 }
16640
16641 var concreteNodeAImplementors = []string{"ConcreteNodeA", "Node"}
16642
16643 func (ec *executionContext) _ConcreteNodeA(ctx context.Context, sel ast.SelectionSet, obj *ConcreteNodeA) graphql.Marshaler {
16644 fields := graphql.CollectFields(ec.OperationContext, sel, concreteNodeAImplementors)
16645
16646 out := graphql.NewFieldSet(fields)
16647 deferred := make(map[string]*graphql.FieldSet)
16648 for i, field := range fields {
16649 switch field.Name {
16650 case "__typename":
16651 out.Values[i] = graphql.MarshalString("ConcreteNodeA")
16652 case "id":
16653 out.Values[i] = ec._ConcreteNodeA_id(ctx, field, obj)
16654 if out.Values[i] == graphql.Null {
16655 out.Invalids++
16656 }
16657 case "child":
16658 out.Values[i] = ec._ConcreteNodeA_child(ctx, field, obj)
16659 if out.Values[i] == graphql.Null {
16660 out.Invalids++
16661 }
16662 case "name":
16663 out.Values[i] = ec._ConcreteNodeA_name(ctx, field, obj)
16664 if out.Values[i] == graphql.Null {
16665 out.Invalids++
16666 }
16667 default:
16668 panic("unknown field " + strconv.Quote(field.Name))
16669 }
16670 }
16671 out.Dispatch(ctx)
16672 if out.Invalids > 0 {
16673 return graphql.Null
16674 }
16675
16676 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16677
16678 for label, dfs := range deferred {
16679 ec.processDeferredGroup(graphql.DeferredGroup{
16680 Label: label,
16681 Path: graphql.GetPath(ctx),
16682 FieldSet: dfs,
16683 Context: ctx,
16684 })
16685 }
16686
16687 return out
16688 }
16689
16690 var concreteNodeInterfaceImplementors = []string{"ConcreteNodeInterface", "Node"}
16691
16692 func (ec *executionContext) _ConcreteNodeInterface(ctx context.Context, sel ast.SelectionSet, obj ConcreteNodeInterface) graphql.Marshaler {
16693 fields := graphql.CollectFields(ec.OperationContext, sel, concreteNodeInterfaceImplementors)
16694
16695 out := graphql.NewFieldSet(fields)
16696 deferred := make(map[string]*graphql.FieldSet)
16697 for i, field := range fields {
16698 switch field.Name {
16699 case "__typename":
16700 out.Values[i] = graphql.MarshalString("ConcreteNodeInterface")
16701 case "id":
16702 out.Values[i] = ec._ConcreteNodeInterface_id(ctx, field, obj)
16703 if out.Values[i] == graphql.Null {
16704 out.Invalids++
16705 }
16706 case "child":
16707 out.Values[i] = ec._ConcreteNodeInterface_child(ctx, field, obj)
16708 if out.Values[i] == graphql.Null {
16709 out.Invalids++
16710 }
16711 default:
16712 panic("unknown field " + strconv.Quote(field.Name))
16713 }
16714 }
16715 out.Dispatch(ctx)
16716 if out.Invalids > 0 {
16717 return graphql.Null
16718 }
16719
16720 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16721
16722 for label, dfs := range deferred {
16723 ec.processDeferredGroup(graphql.DeferredGroup{
16724 Label: label,
16725 Path: graphql.GetPath(ctx),
16726 FieldSet: dfs,
16727 Context: ctx,
16728 })
16729 }
16730
16731 return out
16732 }
16733
16734 var content_PostImplementors = []string{"Content_Post", "Content_Child"}
16735
16736 func (ec *executionContext) _Content_Post(ctx context.Context, sel ast.SelectionSet, obj *ContentPost) graphql.Marshaler {
16737 fields := graphql.CollectFields(ec.OperationContext, sel, content_PostImplementors)
16738
16739 out := graphql.NewFieldSet(fields)
16740 deferred := make(map[string]*graphql.FieldSet)
16741 for i, field := range fields {
16742 switch field.Name {
16743 case "__typename":
16744 out.Values[i] = graphql.MarshalString("Content_Post")
16745 case "foo":
16746 out.Values[i] = ec._Content_Post_foo(ctx, field, obj)
16747 default:
16748 panic("unknown field " + strconv.Quote(field.Name))
16749 }
16750 }
16751 out.Dispatch(ctx)
16752 if out.Invalids > 0 {
16753 return graphql.Null
16754 }
16755
16756 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16757
16758 for label, dfs := range deferred {
16759 ec.processDeferredGroup(graphql.DeferredGroup{
16760 Label: label,
16761 Path: graphql.GetPath(ctx),
16762 FieldSet: dfs,
16763 Context: ctx,
16764 })
16765 }
16766
16767 return out
16768 }
16769
16770 var content_UserImplementors = []string{"Content_User", "Content_Child"}
16771
16772 func (ec *executionContext) _Content_User(ctx context.Context, sel ast.SelectionSet, obj *ContentUser) graphql.Marshaler {
16773 fields := graphql.CollectFields(ec.OperationContext, sel, content_UserImplementors)
16774
16775 out := graphql.NewFieldSet(fields)
16776 deferred := make(map[string]*graphql.FieldSet)
16777 for i, field := range fields {
16778 switch field.Name {
16779 case "__typename":
16780 out.Values[i] = graphql.MarshalString("Content_User")
16781 case "foo":
16782 out.Values[i] = ec._Content_User_foo(ctx, field, obj)
16783 default:
16784 panic("unknown field " + strconv.Quote(field.Name))
16785 }
16786 }
16787 out.Dispatch(ctx)
16788 if out.Invalids > 0 {
16789 return graphql.Null
16790 }
16791
16792 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16793
16794 for label, dfs := range deferred {
16795 ec.processDeferredGroup(graphql.DeferredGroup{
16796 Label: label,
16797 Path: graphql.GetPath(ctx),
16798 FieldSet: dfs,
16799 Context: ctx,
16800 })
16801 }
16802
16803 return out
16804 }
16805
16806 var coordinatesImplementors = []string{"Coordinates"}
16807
16808 func (ec *executionContext) _Coordinates(ctx context.Context, sel ast.SelectionSet, obj *Coordinates) graphql.Marshaler {
16809 fields := graphql.CollectFields(ec.OperationContext, sel, coordinatesImplementors)
16810
16811 out := graphql.NewFieldSet(fields)
16812 deferred := make(map[string]*graphql.FieldSet)
16813 for i, field := range fields {
16814 switch field.Name {
16815 case "__typename":
16816 out.Values[i] = graphql.MarshalString("Coordinates")
16817 case "x":
16818 out.Values[i] = ec._Coordinates_x(ctx, field, obj)
16819 if out.Values[i] == graphql.Null {
16820 out.Invalids++
16821 }
16822 case "y":
16823 out.Values[i] = ec._Coordinates_y(ctx, field, obj)
16824 if out.Values[i] == graphql.Null {
16825 out.Invalids++
16826 }
16827 default:
16828 panic("unknown field " + strconv.Quote(field.Name))
16829 }
16830 }
16831 out.Dispatch(ctx)
16832 if out.Invalids > 0 {
16833 return graphql.Null
16834 }
16835
16836 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16837
16838 for label, dfs := range deferred {
16839 ec.processDeferredGroup(graphql.DeferredGroup{
16840 Label: label,
16841 Path: graphql.GetPath(ctx),
16842 FieldSet: dfs,
16843 Context: ctx,
16844 })
16845 }
16846
16847 return out
16848 }
16849
16850 var defaultParametersMirrorImplementors = []string{"DefaultParametersMirror"}
16851
16852 func (ec *executionContext) _DefaultParametersMirror(ctx context.Context, sel ast.SelectionSet, obj *DefaultParametersMirror) graphql.Marshaler {
16853 fields := graphql.CollectFields(ec.OperationContext, sel, defaultParametersMirrorImplementors)
16854
16855 out := graphql.NewFieldSet(fields)
16856 deferred := make(map[string]*graphql.FieldSet)
16857 for i, field := range fields {
16858 switch field.Name {
16859 case "__typename":
16860 out.Values[i] = graphql.MarshalString("DefaultParametersMirror")
16861 case "falsyBoolean":
16862 out.Values[i] = ec._DefaultParametersMirror_falsyBoolean(ctx, field, obj)
16863 case "truthyBoolean":
16864 out.Values[i] = ec._DefaultParametersMirror_truthyBoolean(ctx, field, obj)
16865 default:
16866 panic("unknown field " + strconv.Quote(field.Name))
16867 }
16868 }
16869 out.Dispatch(ctx)
16870 if out.Invalids > 0 {
16871 return graphql.Null
16872 }
16873
16874 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16875
16876 for label, dfs := range deferred {
16877 ec.processDeferredGroup(graphql.DeferredGroup{
16878 Label: label,
16879 Path: graphql.GetPath(ctx),
16880 FieldSet: dfs,
16881 Context: ctx,
16882 })
16883 }
16884
16885 return out
16886 }
16887
16888 var deferModelImplementors = []string{"DeferModel"}
16889
16890 func (ec *executionContext) _DeferModel(ctx context.Context, sel ast.SelectionSet, obj *DeferModel) graphql.Marshaler {
16891 fields := graphql.CollectFields(ec.OperationContext, sel, deferModelImplementors)
16892
16893 out := graphql.NewFieldSet(fields)
16894 deferred := make(map[string]*graphql.FieldSet)
16895 for i, field := range fields {
16896 switch field.Name {
16897 case "__typename":
16898 out.Values[i] = graphql.MarshalString("DeferModel")
16899 case "id":
16900 out.Values[i] = ec._DeferModel_id(ctx, field, obj)
16901 if out.Values[i] == graphql.Null {
16902 atomic.AddUint32(&out.Invalids, 1)
16903 }
16904 case "name":
16905 out.Values[i] = ec._DeferModel_name(ctx, field, obj)
16906 if out.Values[i] == graphql.Null {
16907 atomic.AddUint32(&out.Invalids, 1)
16908 }
16909 case "values":
16910 field := field
16911
16912 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
16913 defer func() {
16914 if r := recover(); r != nil {
16915 ec.Error(ctx, ec.Recover(ctx, r))
16916 }
16917 }()
16918 res = ec._DeferModel_values(ctx, field, obj)
16919 if res == graphql.Null {
16920 atomic.AddUint32(&fs.Invalids, 1)
16921 }
16922 return res
16923 }
16924
16925 if field.Deferrable != nil {
16926 dfs, ok := deferred[field.Deferrable.Label]
16927 di := 0
16928 if ok {
16929 dfs.AddField(field)
16930 di = len(dfs.Values) - 1
16931 } else {
16932 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
16933 deferred[field.Deferrable.Label] = dfs
16934 }
16935 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
16936 return innerFunc(ctx, dfs)
16937 })
16938
16939
16940 out.Values[i] = graphql.Null
16941 continue
16942 }
16943
16944 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
16945 default:
16946 panic("unknown field " + strconv.Quote(field.Name))
16947 }
16948 }
16949 out.Dispatch(ctx)
16950 if out.Invalids > 0 {
16951 return graphql.Null
16952 }
16953
16954 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
16955
16956 for label, dfs := range deferred {
16957 ec.processDeferredGroup(graphql.DeferredGroup{
16958 Label: label,
16959 Path: graphql.GetPath(ctx),
16960 FieldSet: dfs,
16961 Context: ctx,
16962 })
16963 }
16964
16965 return out
16966 }
16967
16968 var dogImplementors = []string{"Dog", "Animal"}
16969
16970 func (ec *executionContext) _Dog(ctx context.Context, sel ast.SelectionSet, obj *Dog) graphql.Marshaler {
16971 fields := graphql.CollectFields(ec.OperationContext, sel, dogImplementors)
16972
16973 out := graphql.NewFieldSet(fields)
16974 deferred := make(map[string]*graphql.FieldSet)
16975 for i, field := range fields {
16976 switch field.Name {
16977 case "__typename":
16978 out.Values[i] = graphql.MarshalString("Dog")
16979 case "species":
16980 out.Values[i] = ec._Dog_species(ctx, field, obj)
16981 if out.Values[i] == graphql.Null {
16982 out.Invalids++
16983 }
16984 case "size":
16985 out.Values[i] = ec._Dog_size(ctx, field, obj)
16986 if out.Values[i] == graphql.Null {
16987 out.Invalids++
16988 }
16989 case "dogBreed":
16990 out.Values[i] = ec._Dog_dogBreed(ctx, field, obj)
16991 if out.Values[i] == graphql.Null {
16992 out.Invalids++
16993 }
16994 default:
16995 panic("unknown field " + strconv.Quote(field.Name))
16996 }
16997 }
16998 out.Dispatch(ctx)
16999 if out.Invalids > 0 {
17000 return graphql.Null
17001 }
17002
17003 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17004
17005 for label, dfs := range deferred {
17006 ec.processDeferredGroup(graphql.DeferredGroup{
17007 Label: label,
17008 Path: graphql.GetPath(ctx),
17009 FieldSet: dfs,
17010 Context: ctx,
17011 })
17012 }
17013
17014 return out
17015 }
17016
17017 var embeddedCase1Implementors = []string{"EmbeddedCase1"}
17018
17019 func (ec *executionContext) _EmbeddedCase1(ctx context.Context, sel ast.SelectionSet, obj *EmbeddedCase1) graphql.Marshaler {
17020 fields := graphql.CollectFields(ec.OperationContext, sel, embeddedCase1Implementors)
17021
17022 out := graphql.NewFieldSet(fields)
17023 deferred := make(map[string]*graphql.FieldSet)
17024 for i, field := range fields {
17025 switch field.Name {
17026 case "__typename":
17027 out.Values[i] = graphql.MarshalString("EmbeddedCase1")
17028 case "exportedEmbeddedPointerExportedMethod":
17029 out.Values[i] = ec._EmbeddedCase1_exportedEmbeddedPointerExportedMethod(ctx, field, obj)
17030 if out.Values[i] == graphql.Null {
17031 out.Invalids++
17032 }
17033 default:
17034 panic("unknown field " + strconv.Quote(field.Name))
17035 }
17036 }
17037 out.Dispatch(ctx)
17038 if out.Invalids > 0 {
17039 return graphql.Null
17040 }
17041
17042 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17043
17044 for label, dfs := range deferred {
17045 ec.processDeferredGroup(graphql.DeferredGroup{
17046 Label: label,
17047 Path: graphql.GetPath(ctx),
17048 FieldSet: dfs,
17049 Context: ctx,
17050 })
17051 }
17052
17053 return out
17054 }
17055
17056 var embeddedCase2Implementors = []string{"EmbeddedCase2"}
17057
17058 func (ec *executionContext) _EmbeddedCase2(ctx context.Context, sel ast.SelectionSet, obj *EmbeddedCase2) graphql.Marshaler {
17059 fields := graphql.CollectFields(ec.OperationContext, sel, embeddedCase2Implementors)
17060
17061 out := graphql.NewFieldSet(fields)
17062 deferred := make(map[string]*graphql.FieldSet)
17063 for i, field := range fields {
17064 switch field.Name {
17065 case "__typename":
17066 out.Values[i] = graphql.MarshalString("EmbeddedCase2")
17067 case "unexportedEmbeddedPointerExportedMethod":
17068 out.Values[i] = ec._EmbeddedCase2_unexportedEmbeddedPointerExportedMethod(ctx, field, obj)
17069 if out.Values[i] == graphql.Null {
17070 out.Invalids++
17071 }
17072 default:
17073 panic("unknown field " + strconv.Quote(field.Name))
17074 }
17075 }
17076 out.Dispatch(ctx)
17077 if out.Invalids > 0 {
17078 return graphql.Null
17079 }
17080
17081 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17082
17083 for label, dfs := range deferred {
17084 ec.processDeferredGroup(graphql.DeferredGroup{
17085 Label: label,
17086 Path: graphql.GetPath(ctx),
17087 FieldSet: dfs,
17088 Context: ctx,
17089 })
17090 }
17091
17092 return out
17093 }
17094
17095 var embeddedCase3Implementors = []string{"EmbeddedCase3"}
17096
17097 func (ec *executionContext) _EmbeddedCase3(ctx context.Context, sel ast.SelectionSet, obj *EmbeddedCase3) graphql.Marshaler {
17098 fields := graphql.CollectFields(ec.OperationContext, sel, embeddedCase3Implementors)
17099
17100 out := graphql.NewFieldSet(fields)
17101 deferred := make(map[string]*graphql.FieldSet)
17102 for i, field := range fields {
17103 switch field.Name {
17104 case "__typename":
17105 out.Values[i] = graphql.MarshalString("EmbeddedCase3")
17106 case "unexportedEmbeddedInterfaceExportedMethod":
17107 out.Values[i] = ec._EmbeddedCase3_unexportedEmbeddedInterfaceExportedMethod(ctx, field, obj)
17108 if out.Values[i] == graphql.Null {
17109 out.Invalids++
17110 }
17111 default:
17112 panic("unknown field " + strconv.Quote(field.Name))
17113 }
17114 }
17115 out.Dispatch(ctx)
17116 if out.Invalids > 0 {
17117 return graphql.Null
17118 }
17119
17120 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17121
17122 for label, dfs := range deferred {
17123 ec.processDeferredGroup(graphql.DeferredGroup{
17124 Label: label,
17125 Path: graphql.GetPath(ctx),
17126 FieldSet: dfs,
17127 Context: ctx,
17128 })
17129 }
17130
17131 return out
17132 }
17133
17134 var embeddedDefaultScalarImplementors = []string{"EmbeddedDefaultScalar"}
17135
17136 func (ec *executionContext) _EmbeddedDefaultScalar(ctx context.Context, sel ast.SelectionSet, obj *EmbeddedDefaultScalar) graphql.Marshaler {
17137 fields := graphql.CollectFields(ec.OperationContext, sel, embeddedDefaultScalarImplementors)
17138
17139 out := graphql.NewFieldSet(fields)
17140 deferred := make(map[string]*graphql.FieldSet)
17141 for i, field := range fields {
17142 switch field.Name {
17143 case "__typename":
17144 out.Values[i] = graphql.MarshalString("EmbeddedDefaultScalar")
17145 case "value":
17146 out.Values[i] = ec._EmbeddedDefaultScalar_value(ctx, field, obj)
17147 default:
17148 panic("unknown field " + strconv.Quote(field.Name))
17149 }
17150 }
17151 out.Dispatch(ctx)
17152 if out.Invalids > 0 {
17153 return graphql.Null
17154 }
17155
17156 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17157
17158 for label, dfs := range deferred {
17159 ec.processDeferredGroup(graphql.DeferredGroup{
17160 Label: label,
17161 Path: graphql.GetPath(ctx),
17162 FieldSet: dfs,
17163 Context: ctx,
17164 })
17165 }
17166
17167 return out
17168 }
17169
17170 var embeddedPointerImplementors = []string{"EmbeddedPointer"}
17171
17172 func (ec *executionContext) _EmbeddedPointer(ctx context.Context, sel ast.SelectionSet, obj *EmbeddedPointerModel) graphql.Marshaler {
17173 fields := graphql.CollectFields(ec.OperationContext, sel, embeddedPointerImplementors)
17174
17175 out := graphql.NewFieldSet(fields)
17176 deferred := make(map[string]*graphql.FieldSet)
17177 for i, field := range fields {
17178 switch field.Name {
17179 case "__typename":
17180 out.Values[i] = graphql.MarshalString("EmbeddedPointer")
17181 case "ID":
17182 out.Values[i] = ec._EmbeddedPointer_ID(ctx, field, obj)
17183 case "Title":
17184 out.Values[i] = ec._EmbeddedPointer_Title(ctx, field, obj)
17185 default:
17186 panic("unknown field " + strconv.Quote(field.Name))
17187 }
17188 }
17189 out.Dispatch(ctx)
17190 if out.Invalids > 0 {
17191 return graphql.Null
17192 }
17193
17194 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17195
17196 for label, dfs := range deferred {
17197 ec.processDeferredGroup(graphql.DeferredGroup{
17198 Label: label,
17199 Path: graphql.GetPath(ctx),
17200 FieldSet: dfs,
17201 Context: ctx,
17202 })
17203 }
17204
17205 return out
17206 }
17207
17208 var errorImplementors = []string{"Error"}
17209
17210 func (ec *executionContext) _Error(ctx context.Context, sel ast.SelectionSet, obj *Error) graphql.Marshaler {
17211 fields := graphql.CollectFields(ec.OperationContext, sel, errorImplementors)
17212
17213 out := graphql.NewFieldSet(fields)
17214 deferred := make(map[string]*graphql.FieldSet)
17215 for i, field := range fields {
17216 switch field.Name {
17217 case "__typename":
17218 out.Values[i] = graphql.MarshalString("Error")
17219 case "id":
17220 out.Values[i] = ec._Error_id(ctx, field, obj)
17221 if out.Values[i] == graphql.Null {
17222 out.Invalids++
17223 }
17224 case "errorOnNonRequiredField":
17225 out.Values[i] = ec._Error_errorOnNonRequiredField(ctx, field, obj)
17226 case "errorOnRequiredField":
17227 out.Values[i] = ec._Error_errorOnRequiredField(ctx, field, obj)
17228 if out.Values[i] == graphql.Null {
17229 out.Invalids++
17230 }
17231 case "nilOnRequiredField":
17232 out.Values[i] = ec._Error_nilOnRequiredField(ctx, field, obj)
17233 if out.Values[i] == graphql.Null {
17234 out.Invalids++
17235 }
17236 default:
17237 panic("unknown field " + strconv.Quote(field.Name))
17238 }
17239 }
17240 out.Dispatch(ctx)
17241 if out.Invalids > 0 {
17242 return graphql.Null
17243 }
17244
17245 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17246
17247 for label, dfs := range deferred {
17248 ec.processDeferredGroup(graphql.DeferredGroup{
17249 Label: label,
17250 Path: graphql.GetPath(ctx),
17251 FieldSet: dfs,
17252 Context: ctx,
17253 })
17254 }
17255
17256 return out
17257 }
17258
17259 var errorsImplementors = []string{"Errors"}
17260
17261 func (ec *executionContext) _Errors(ctx context.Context, sel ast.SelectionSet, obj *Errors) graphql.Marshaler {
17262 fields := graphql.CollectFields(ec.OperationContext, sel, errorsImplementors)
17263
17264 out := graphql.NewFieldSet(fields)
17265 deferred := make(map[string]*graphql.FieldSet)
17266 for i, field := range fields {
17267 switch field.Name {
17268 case "__typename":
17269 out.Values[i] = graphql.MarshalString("Errors")
17270 case "a":
17271 field := field
17272
17273 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
17274 defer func() {
17275 if r := recover(); r != nil {
17276 ec.Error(ctx, ec.Recover(ctx, r))
17277 }
17278 }()
17279 res = ec._Errors_a(ctx, field, obj)
17280 if res == graphql.Null {
17281 atomic.AddUint32(&fs.Invalids, 1)
17282 }
17283 return res
17284 }
17285
17286 if field.Deferrable != nil {
17287 dfs, ok := deferred[field.Deferrable.Label]
17288 di := 0
17289 if ok {
17290 dfs.AddField(field)
17291 di = len(dfs.Values) - 1
17292 } else {
17293 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
17294 deferred[field.Deferrable.Label] = dfs
17295 }
17296 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
17297 return innerFunc(ctx, dfs)
17298 })
17299
17300
17301 out.Values[i] = graphql.Null
17302 continue
17303 }
17304
17305 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
17306 case "b":
17307 field := field
17308
17309 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
17310 defer func() {
17311 if r := recover(); r != nil {
17312 ec.Error(ctx, ec.Recover(ctx, r))
17313 }
17314 }()
17315 res = ec._Errors_b(ctx, field, obj)
17316 if res == graphql.Null {
17317 atomic.AddUint32(&fs.Invalids, 1)
17318 }
17319 return res
17320 }
17321
17322 if field.Deferrable != nil {
17323 dfs, ok := deferred[field.Deferrable.Label]
17324 di := 0
17325 if ok {
17326 dfs.AddField(field)
17327 di = len(dfs.Values) - 1
17328 } else {
17329 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
17330 deferred[field.Deferrable.Label] = dfs
17331 }
17332 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
17333 return innerFunc(ctx, dfs)
17334 })
17335
17336
17337 out.Values[i] = graphql.Null
17338 continue
17339 }
17340
17341 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
17342 case "c":
17343 field := field
17344
17345 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
17346 defer func() {
17347 if r := recover(); r != nil {
17348 ec.Error(ctx, ec.Recover(ctx, r))
17349 }
17350 }()
17351 res = ec._Errors_c(ctx, field, obj)
17352 if res == graphql.Null {
17353 atomic.AddUint32(&fs.Invalids, 1)
17354 }
17355 return res
17356 }
17357
17358 if field.Deferrable != nil {
17359 dfs, ok := deferred[field.Deferrable.Label]
17360 di := 0
17361 if ok {
17362 dfs.AddField(field)
17363 di = len(dfs.Values) - 1
17364 } else {
17365 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
17366 deferred[field.Deferrable.Label] = dfs
17367 }
17368 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
17369 return innerFunc(ctx, dfs)
17370 })
17371
17372
17373 out.Values[i] = graphql.Null
17374 continue
17375 }
17376
17377 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
17378 case "d":
17379 field := field
17380
17381 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
17382 defer func() {
17383 if r := recover(); r != nil {
17384 ec.Error(ctx, ec.Recover(ctx, r))
17385 }
17386 }()
17387 res = ec._Errors_d(ctx, field, obj)
17388 if res == graphql.Null {
17389 atomic.AddUint32(&fs.Invalids, 1)
17390 }
17391 return res
17392 }
17393
17394 if field.Deferrable != nil {
17395 dfs, ok := deferred[field.Deferrable.Label]
17396 di := 0
17397 if ok {
17398 dfs.AddField(field)
17399 di = len(dfs.Values) - 1
17400 } else {
17401 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
17402 deferred[field.Deferrable.Label] = dfs
17403 }
17404 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
17405 return innerFunc(ctx, dfs)
17406 })
17407
17408
17409 out.Values[i] = graphql.Null
17410 continue
17411 }
17412
17413 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
17414 case "e":
17415 field := field
17416
17417 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
17418 defer func() {
17419 if r := recover(); r != nil {
17420 ec.Error(ctx, ec.Recover(ctx, r))
17421 }
17422 }()
17423 res = ec._Errors_e(ctx, field, obj)
17424 if res == graphql.Null {
17425 atomic.AddUint32(&fs.Invalids, 1)
17426 }
17427 return res
17428 }
17429
17430 if field.Deferrable != nil {
17431 dfs, ok := deferred[field.Deferrable.Label]
17432 di := 0
17433 if ok {
17434 dfs.AddField(field)
17435 di = len(dfs.Values) - 1
17436 } else {
17437 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
17438 deferred[field.Deferrable.Label] = dfs
17439 }
17440 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
17441 return innerFunc(ctx, dfs)
17442 })
17443
17444
17445 out.Values[i] = graphql.Null
17446 continue
17447 }
17448
17449 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
17450 default:
17451 panic("unknown field " + strconv.Quote(field.Name))
17452 }
17453 }
17454 out.Dispatch(ctx)
17455 if out.Invalids > 0 {
17456 return graphql.Null
17457 }
17458
17459 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17460
17461 for label, dfs := range deferred {
17462 ec.processDeferredGroup(graphql.DeferredGroup{
17463 Label: label,
17464 Path: graphql.GetPath(ctx),
17465 FieldSet: dfs,
17466 Context: ctx,
17467 })
17468 }
17469
17470 return out
17471 }
17472
17473 var fieldsOrderPayloadImplementors = []string{"FieldsOrderPayload"}
17474
17475 func (ec *executionContext) _FieldsOrderPayload(ctx context.Context, sel ast.SelectionSet, obj *FieldsOrderPayload) graphql.Marshaler {
17476 fields := graphql.CollectFields(ec.OperationContext, sel, fieldsOrderPayloadImplementors)
17477
17478 out := graphql.NewFieldSet(fields)
17479 deferred := make(map[string]*graphql.FieldSet)
17480 for i, field := range fields {
17481 switch field.Name {
17482 case "__typename":
17483 out.Values[i] = graphql.MarshalString("FieldsOrderPayload")
17484 case "firstFieldValue":
17485 out.Values[i] = ec._FieldsOrderPayload_firstFieldValue(ctx, field, obj)
17486 default:
17487 panic("unknown field " + strconv.Quote(field.Name))
17488 }
17489 }
17490 out.Dispatch(ctx)
17491 if out.Invalids > 0 {
17492 return graphql.Null
17493 }
17494
17495 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17496
17497 for label, dfs := range deferred {
17498 ec.processDeferredGroup(graphql.DeferredGroup{
17499 Label: label,
17500 Path: graphql.GetPath(ctx),
17501 FieldSet: dfs,
17502 Context: ctx,
17503 })
17504 }
17505
17506 return out
17507 }
17508
17509 var forcedResolverImplementors = []string{"ForcedResolver"}
17510
17511 func (ec *executionContext) _ForcedResolver(ctx context.Context, sel ast.SelectionSet, obj *ForcedResolver) graphql.Marshaler {
17512 fields := graphql.CollectFields(ec.OperationContext, sel, forcedResolverImplementors)
17513
17514 out := graphql.NewFieldSet(fields)
17515 deferred := make(map[string]*graphql.FieldSet)
17516 for i, field := range fields {
17517 switch field.Name {
17518 case "__typename":
17519 out.Values[i] = graphql.MarshalString("ForcedResolver")
17520 case "field":
17521 field := field
17522
17523 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
17524 defer func() {
17525 if r := recover(); r != nil {
17526 ec.Error(ctx, ec.Recover(ctx, r))
17527 }
17528 }()
17529 res = ec._ForcedResolver_field(ctx, field, obj)
17530 return res
17531 }
17532
17533 if field.Deferrable != nil {
17534 dfs, ok := deferred[field.Deferrable.Label]
17535 di := 0
17536 if ok {
17537 dfs.AddField(field)
17538 di = len(dfs.Values) - 1
17539 } else {
17540 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
17541 deferred[field.Deferrable.Label] = dfs
17542 }
17543 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
17544 return innerFunc(ctx, dfs)
17545 })
17546
17547
17548 out.Values[i] = graphql.Null
17549 continue
17550 }
17551
17552 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
17553 default:
17554 panic("unknown field " + strconv.Quote(field.Name))
17555 }
17556 }
17557 out.Dispatch(ctx)
17558 if out.Invalids > 0 {
17559 return graphql.Null
17560 }
17561
17562 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17563
17564 for label, dfs := range deferred {
17565 ec.processDeferredGroup(graphql.DeferredGroup{
17566 Label: label,
17567 Path: graphql.GetPath(ctx),
17568 FieldSet: dfs,
17569 Context: ctx,
17570 })
17571 }
17572
17573 return out
17574 }
17575
17576 var horseImplementors = []string{"Horse", "Mammalian", "Animal"}
17577
17578 func (ec *executionContext) _Horse(ctx context.Context, sel ast.SelectionSet, obj *Horse) graphql.Marshaler {
17579 fields := graphql.CollectFields(ec.OperationContext, sel, horseImplementors)
17580
17581 out := graphql.NewFieldSet(fields)
17582 deferred := make(map[string]*graphql.FieldSet)
17583 for i, field := range fields {
17584 switch field.Name {
17585 case "__typename":
17586 out.Values[i] = graphql.MarshalString("Horse")
17587 case "species":
17588 out.Values[i] = ec._Horse_species(ctx, field, obj)
17589 if out.Values[i] == graphql.Null {
17590 out.Invalids++
17591 }
17592 case "size":
17593 out.Values[i] = ec._Horse_size(ctx, field, obj)
17594 if out.Values[i] == graphql.Null {
17595 out.Invalids++
17596 }
17597 case "horseBreed":
17598 out.Values[i] = ec._Horse_horseBreed(ctx, field, obj)
17599 if out.Values[i] == graphql.Null {
17600 out.Invalids++
17601 }
17602 default:
17603 panic("unknown field " + strconv.Quote(field.Name))
17604 }
17605 }
17606 out.Dispatch(ctx)
17607 if out.Invalids > 0 {
17608 return graphql.Null
17609 }
17610
17611 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17612
17613 for label, dfs := range deferred {
17614 ec.processDeferredGroup(graphql.DeferredGroup{
17615 Label: label,
17616 Path: graphql.GetPath(ctx),
17617 FieldSet: dfs,
17618 Context: ctx,
17619 })
17620 }
17621
17622 return out
17623 }
17624
17625 var innerObjectImplementors = []string{"InnerObject"}
17626
17627 func (ec *executionContext) _InnerObject(ctx context.Context, sel ast.SelectionSet, obj *InnerObject) graphql.Marshaler {
17628 fields := graphql.CollectFields(ec.OperationContext, sel, innerObjectImplementors)
17629
17630 out := graphql.NewFieldSet(fields)
17631 deferred := make(map[string]*graphql.FieldSet)
17632 for i, field := range fields {
17633 switch field.Name {
17634 case "__typename":
17635 out.Values[i] = graphql.MarshalString("InnerObject")
17636 case "id":
17637 out.Values[i] = ec._InnerObject_id(ctx, field, obj)
17638 if out.Values[i] == graphql.Null {
17639 out.Invalids++
17640 }
17641 default:
17642 panic("unknown field " + strconv.Quote(field.Name))
17643 }
17644 }
17645 out.Dispatch(ctx)
17646 if out.Invalids > 0 {
17647 return graphql.Null
17648 }
17649
17650 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17651
17652 for label, dfs := range deferred {
17653 ec.processDeferredGroup(graphql.DeferredGroup{
17654 Label: label,
17655 Path: graphql.GetPath(ctx),
17656 FieldSet: dfs,
17657 Context: ctx,
17658 })
17659 }
17660
17661 return out
17662 }
17663
17664 var invalidIdentifierImplementors = []string{"InvalidIdentifier"}
17665
17666 func (ec *executionContext) _InvalidIdentifier(ctx context.Context, sel ast.SelectionSet, obj *invalid_packagename.InvalidIdentifier) graphql.Marshaler {
17667 fields := graphql.CollectFields(ec.OperationContext, sel, invalidIdentifierImplementors)
17668
17669 out := graphql.NewFieldSet(fields)
17670 deferred := make(map[string]*graphql.FieldSet)
17671 for i, field := range fields {
17672 switch field.Name {
17673 case "__typename":
17674 out.Values[i] = graphql.MarshalString("InvalidIdentifier")
17675 case "id":
17676 out.Values[i] = ec._InvalidIdentifier_id(ctx, field, obj)
17677 if out.Values[i] == graphql.Null {
17678 out.Invalids++
17679 }
17680 default:
17681 panic("unknown field " + strconv.Quote(field.Name))
17682 }
17683 }
17684 out.Dispatch(ctx)
17685 if out.Invalids > 0 {
17686 return graphql.Null
17687 }
17688
17689 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17690
17691 for label, dfs := range deferred {
17692 ec.processDeferredGroup(graphql.DeferredGroup{
17693 Label: label,
17694 Path: graphql.GetPath(ctx),
17695 FieldSet: dfs,
17696 Context: ctx,
17697 })
17698 }
17699
17700 return out
17701 }
17702
17703 var itImplementors = []string{"It"}
17704
17705 func (ec *executionContext) _It(ctx context.Context, sel ast.SelectionSet, obj *introspection1.It) graphql.Marshaler {
17706 fields := graphql.CollectFields(ec.OperationContext, sel, itImplementors)
17707
17708 out := graphql.NewFieldSet(fields)
17709 deferred := make(map[string]*graphql.FieldSet)
17710 for i, field := range fields {
17711 switch field.Name {
17712 case "__typename":
17713 out.Values[i] = graphql.MarshalString("It")
17714 case "id":
17715 out.Values[i] = ec._It_id(ctx, field, obj)
17716 if out.Values[i] == graphql.Null {
17717 out.Invalids++
17718 }
17719 default:
17720 panic("unknown field " + strconv.Quote(field.Name))
17721 }
17722 }
17723 out.Dispatch(ctx)
17724 if out.Invalids > 0 {
17725 return graphql.Null
17726 }
17727
17728 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17729
17730 for label, dfs := range deferred {
17731 ec.processDeferredGroup(graphql.DeferredGroup{
17732 Label: label,
17733 Path: graphql.GetPath(ctx),
17734 FieldSet: dfs,
17735 Context: ctx,
17736 })
17737 }
17738
17739 return out
17740 }
17741
17742 var loopAImplementors = []string{"LoopA"}
17743
17744 func (ec *executionContext) _LoopA(ctx context.Context, sel ast.SelectionSet, obj *LoopA) graphql.Marshaler {
17745 fields := graphql.CollectFields(ec.OperationContext, sel, loopAImplementors)
17746
17747 out := graphql.NewFieldSet(fields)
17748 deferred := make(map[string]*graphql.FieldSet)
17749 for i, field := range fields {
17750 switch field.Name {
17751 case "__typename":
17752 out.Values[i] = graphql.MarshalString("LoopA")
17753 case "b":
17754 out.Values[i] = ec._LoopA_b(ctx, field, obj)
17755 if out.Values[i] == graphql.Null {
17756 out.Invalids++
17757 }
17758 default:
17759 panic("unknown field " + strconv.Quote(field.Name))
17760 }
17761 }
17762 out.Dispatch(ctx)
17763 if out.Invalids > 0 {
17764 return graphql.Null
17765 }
17766
17767 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17768
17769 for label, dfs := range deferred {
17770 ec.processDeferredGroup(graphql.DeferredGroup{
17771 Label: label,
17772 Path: graphql.GetPath(ctx),
17773 FieldSet: dfs,
17774 Context: ctx,
17775 })
17776 }
17777
17778 return out
17779 }
17780
17781 var loopBImplementors = []string{"LoopB"}
17782
17783 func (ec *executionContext) _LoopB(ctx context.Context, sel ast.SelectionSet, obj *LoopB) graphql.Marshaler {
17784 fields := graphql.CollectFields(ec.OperationContext, sel, loopBImplementors)
17785
17786 out := graphql.NewFieldSet(fields)
17787 deferred := make(map[string]*graphql.FieldSet)
17788 for i, field := range fields {
17789 switch field.Name {
17790 case "__typename":
17791 out.Values[i] = graphql.MarshalString("LoopB")
17792 case "a":
17793 out.Values[i] = ec._LoopB_a(ctx, field, obj)
17794 if out.Values[i] == graphql.Null {
17795 out.Invalids++
17796 }
17797 default:
17798 panic("unknown field " + strconv.Quote(field.Name))
17799 }
17800 }
17801 out.Dispatch(ctx)
17802 if out.Invalids > 0 {
17803 return graphql.Null
17804 }
17805
17806 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17807
17808 for label, dfs := range deferred {
17809 ec.processDeferredGroup(graphql.DeferredGroup{
17810 Label: label,
17811 Path: graphql.GetPath(ctx),
17812 FieldSet: dfs,
17813 Context: ctx,
17814 })
17815 }
17816
17817 return out
17818 }
17819
17820 var mapImplementors = []string{"Map"}
17821
17822 func (ec *executionContext) _Map(ctx context.Context, sel ast.SelectionSet, obj *Map) graphql.Marshaler {
17823 fields := graphql.CollectFields(ec.OperationContext, sel, mapImplementors)
17824
17825 out := graphql.NewFieldSet(fields)
17826 deferred := make(map[string]*graphql.FieldSet)
17827 for i, field := range fields {
17828 switch field.Name {
17829 case "__typename":
17830 out.Values[i] = graphql.MarshalString("Map")
17831 case "id":
17832 out.Values[i] = ec._Map_id(ctx, field, obj)
17833 if out.Values[i] == graphql.Null {
17834 out.Invalids++
17835 }
17836 default:
17837 panic("unknown field " + strconv.Quote(field.Name))
17838 }
17839 }
17840 out.Dispatch(ctx)
17841 if out.Invalids > 0 {
17842 return graphql.Null
17843 }
17844
17845 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17846
17847 for label, dfs := range deferred {
17848 ec.processDeferredGroup(graphql.DeferredGroup{
17849 Label: label,
17850 Path: graphql.GetPath(ctx),
17851 FieldSet: dfs,
17852 Context: ctx,
17853 })
17854 }
17855
17856 return out
17857 }
17858
17859 var mapNestedImplementors = []string{"MapNested"}
17860
17861 func (ec *executionContext) _MapNested(ctx context.Context, sel ast.SelectionSet, obj *MapNested) graphql.Marshaler {
17862 fields := graphql.CollectFields(ec.OperationContext, sel, mapNestedImplementors)
17863
17864 out := graphql.NewFieldSet(fields)
17865 deferred := make(map[string]*graphql.FieldSet)
17866 for i, field := range fields {
17867 switch field.Name {
17868 case "__typename":
17869 out.Values[i] = graphql.MarshalString("MapNested")
17870 case "value":
17871 out.Values[i] = ec._MapNested_value(ctx, field, obj)
17872 if out.Values[i] == graphql.Null {
17873 out.Invalids++
17874 }
17875 default:
17876 panic("unknown field " + strconv.Quote(field.Name))
17877 }
17878 }
17879 out.Dispatch(ctx)
17880 if out.Invalids > 0 {
17881 return graphql.Null
17882 }
17883
17884 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17885
17886 for label, dfs := range deferred {
17887 ec.processDeferredGroup(graphql.DeferredGroup{
17888 Label: label,
17889 Path: graphql.GetPath(ctx),
17890 FieldSet: dfs,
17891 Context: ctx,
17892 })
17893 }
17894
17895 return out
17896 }
17897
17898 var mapStringInterfaceTypeImplementors = []string{"MapStringInterfaceType"}
17899
17900 func (ec *executionContext) _MapStringInterfaceType(ctx context.Context, sel ast.SelectionSet, obj map[string]interface{}) graphql.Marshaler {
17901 fields := graphql.CollectFields(ec.OperationContext, sel, mapStringInterfaceTypeImplementors)
17902
17903 out := graphql.NewFieldSet(fields)
17904 deferred := make(map[string]*graphql.FieldSet)
17905 for i, field := range fields {
17906 switch field.Name {
17907 case "__typename":
17908 out.Values[i] = graphql.MarshalString("MapStringInterfaceType")
17909 case "a":
17910 out.Values[i] = ec._MapStringInterfaceType_a(ctx, field, obj)
17911 case "b":
17912 out.Values[i] = ec._MapStringInterfaceType_b(ctx, field, obj)
17913 case "c":
17914 out.Values[i] = ec._MapStringInterfaceType_c(ctx, field, obj)
17915 case "nested":
17916 out.Values[i] = ec._MapStringInterfaceType_nested(ctx, field, obj)
17917 default:
17918 panic("unknown field " + strconv.Quote(field.Name))
17919 }
17920 }
17921 out.Dispatch(ctx)
17922 if out.Invalids > 0 {
17923 return graphql.Null
17924 }
17925
17926 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
17927
17928 for label, dfs := range deferred {
17929 ec.processDeferredGroup(graphql.DeferredGroup{
17930 Label: label,
17931 Path: graphql.GetPath(ctx),
17932 FieldSet: dfs,
17933 Context: ctx,
17934 })
17935 }
17936
17937 return out
17938 }
17939
17940 var modelMethodsImplementors = []string{"ModelMethods"}
17941
17942 func (ec *executionContext) _ModelMethods(ctx context.Context, sel ast.SelectionSet, obj *ModelMethods) graphql.Marshaler {
17943 fields := graphql.CollectFields(ec.OperationContext, sel, modelMethodsImplementors)
17944
17945 out := graphql.NewFieldSet(fields)
17946 deferred := make(map[string]*graphql.FieldSet)
17947 for i, field := range fields {
17948 switch field.Name {
17949 case "__typename":
17950 out.Values[i] = graphql.MarshalString("ModelMethods")
17951 case "resolverField":
17952 field := field
17953
17954 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
17955 defer func() {
17956 if r := recover(); r != nil {
17957 ec.Error(ctx, ec.Recover(ctx, r))
17958 }
17959 }()
17960 res = ec._ModelMethods_resolverField(ctx, field, obj)
17961 if res == graphql.Null {
17962 atomic.AddUint32(&fs.Invalids, 1)
17963 }
17964 return res
17965 }
17966
17967 if field.Deferrable != nil {
17968 dfs, ok := deferred[field.Deferrable.Label]
17969 di := 0
17970 if ok {
17971 dfs.AddField(field)
17972 di = len(dfs.Values) - 1
17973 } else {
17974 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
17975 deferred[field.Deferrable.Label] = dfs
17976 }
17977 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
17978 return innerFunc(ctx, dfs)
17979 })
17980
17981
17982 out.Values[i] = graphql.Null
17983 continue
17984 }
17985
17986 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
17987 case "noContext":
17988 out.Values[i] = ec._ModelMethods_noContext(ctx, field, obj)
17989 if out.Values[i] == graphql.Null {
17990 atomic.AddUint32(&out.Invalids, 1)
17991 }
17992 case "withContext":
17993 field := field
17994
17995 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
17996 defer func() {
17997 if r := recover(); r != nil {
17998 ec.Error(ctx, ec.Recover(ctx, r))
17999 }
18000 }()
18001 res = ec._ModelMethods_withContext(ctx, field, obj)
18002 if res == graphql.Null {
18003 atomic.AddUint32(&fs.Invalids, 1)
18004 }
18005 return res
18006 }
18007
18008 if field.Deferrable != nil {
18009 dfs, ok := deferred[field.Deferrable.Label]
18010 di := 0
18011 if ok {
18012 dfs.AddField(field)
18013 di = len(dfs.Values) - 1
18014 } else {
18015 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
18016 deferred[field.Deferrable.Label] = dfs
18017 }
18018 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
18019 return innerFunc(ctx, dfs)
18020 })
18021
18022
18023 out.Values[i] = graphql.Null
18024 continue
18025 }
18026
18027 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
18028 default:
18029 panic("unknown field " + strconv.Quote(field.Name))
18030 }
18031 }
18032 out.Dispatch(ctx)
18033 if out.Invalids > 0 {
18034 return graphql.Null
18035 }
18036
18037 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
18038
18039 for label, dfs := range deferred {
18040 ec.processDeferredGroup(graphql.DeferredGroup{
18041 Label: label,
18042 Path: graphql.GetPath(ctx),
18043 FieldSet: dfs,
18044 Context: ctx,
18045 })
18046 }
18047
18048 return out
18049 }
18050
18051 var mutationImplementors = []string{"Mutation"}
18052
18053 func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
18054 fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
18055 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
18056 Object: "Mutation",
18057 })
18058
18059 out := graphql.NewFieldSet(fields)
18060 deferred := make(map[string]*graphql.FieldSet)
18061 for i, field := range fields {
18062 innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
18063 Object: field.Name,
18064 Field: field,
18065 })
18066
18067 switch field.Name {
18068 case "__typename":
18069 out.Values[i] = graphql.MarshalString("Mutation")
18070 case "defaultInput":
18071 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
18072 return ec._Mutation_defaultInput(ctx, field)
18073 })
18074 if out.Values[i] == graphql.Null {
18075 out.Invalids++
18076 }
18077 case "overrideValueViaInput":
18078 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
18079 return ec._Mutation_overrideValueViaInput(ctx, field)
18080 })
18081 if out.Values[i] == graphql.Null {
18082 out.Invalids++
18083 }
18084 case "updateSomething":
18085 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
18086 return ec._Mutation_updateSomething(ctx, field)
18087 })
18088 if out.Values[i] == graphql.Null {
18089 out.Invalids++
18090 }
18091 case "updatePtrToPtr":
18092 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
18093 return ec._Mutation_updatePtrToPtr(ctx, field)
18094 })
18095 if out.Values[i] == graphql.Null {
18096 out.Invalids++
18097 }
18098 default:
18099 panic("unknown field " + strconv.Quote(field.Name))
18100 }
18101 }
18102 out.Dispatch(ctx)
18103 if out.Invalids > 0 {
18104 return graphql.Null
18105 }
18106
18107 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
18108
18109 for label, dfs := range deferred {
18110 ec.processDeferredGroup(graphql.DeferredGroup{
18111 Label: label,
18112 Path: graphql.GetPath(ctx),
18113 FieldSet: dfs,
18114 Context: ctx,
18115 })
18116 }
18117
18118 return out
18119 }
18120
18121 var objectDirectivesImplementors = []string{"ObjectDirectives"}
18122
18123 func (ec *executionContext) _ObjectDirectives(ctx context.Context, sel ast.SelectionSet, obj *ObjectDirectives) graphql.Marshaler {
18124 fields := graphql.CollectFields(ec.OperationContext, sel, objectDirectivesImplementors)
18125
18126 out := graphql.NewFieldSet(fields)
18127 deferred := make(map[string]*graphql.FieldSet)
18128 for i, field := range fields {
18129 switch field.Name {
18130 case "__typename":
18131 out.Values[i] = graphql.MarshalString("ObjectDirectives")
18132 case "text":
18133 out.Values[i] = ec._ObjectDirectives_text(ctx, field, obj)
18134 if out.Values[i] == graphql.Null {
18135 out.Invalids++
18136 }
18137 case "nullableText":
18138 out.Values[i] = ec._ObjectDirectives_nullableText(ctx, field, obj)
18139 case "order":
18140 out.Values[i] = ec._ObjectDirectives_order(ctx, field, obj)
18141 if out.Values[i] == graphql.Null {
18142 out.Invalids++
18143 }
18144 default:
18145 panic("unknown field " + strconv.Quote(field.Name))
18146 }
18147 }
18148 out.Dispatch(ctx)
18149 if out.Invalids > 0 {
18150 return graphql.Null
18151 }
18152
18153 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
18154
18155 for label, dfs := range deferred {
18156 ec.processDeferredGroup(graphql.DeferredGroup{
18157 Label: label,
18158 Path: graphql.GetPath(ctx),
18159 FieldSet: dfs,
18160 Context: ctx,
18161 })
18162 }
18163
18164 return out
18165 }
18166
18167 var objectDirectivesWithCustomGoModelImplementors = []string{"ObjectDirectivesWithCustomGoModel"}
18168
18169 func (ec *executionContext) _ObjectDirectivesWithCustomGoModel(ctx context.Context, sel ast.SelectionSet, obj *ObjectDirectivesWithCustomGoModel) graphql.Marshaler {
18170 fields := graphql.CollectFields(ec.OperationContext, sel, objectDirectivesWithCustomGoModelImplementors)
18171
18172 out := graphql.NewFieldSet(fields)
18173 deferred := make(map[string]*graphql.FieldSet)
18174 for i, field := range fields {
18175 switch field.Name {
18176 case "__typename":
18177 out.Values[i] = graphql.MarshalString("ObjectDirectivesWithCustomGoModel")
18178 case "nullableText":
18179 out.Values[i] = ec._ObjectDirectivesWithCustomGoModel_nullableText(ctx, field, obj)
18180 default:
18181 panic("unknown field " + strconv.Quote(field.Name))
18182 }
18183 }
18184 out.Dispatch(ctx)
18185 if out.Invalids > 0 {
18186 return graphql.Null
18187 }
18188
18189 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
18190
18191 for label, dfs := range deferred {
18192 ec.processDeferredGroup(graphql.DeferredGroup{
18193 Label: label,
18194 Path: graphql.GetPath(ctx),
18195 FieldSet: dfs,
18196 Context: ctx,
18197 })
18198 }
18199
18200 return out
18201 }
18202
18203 var outerObjectImplementors = []string{"OuterObject"}
18204
18205 func (ec *executionContext) _OuterObject(ctx context.Context, sel ast.SelectionSet, obj *OuterObject) graphql.Marshaler {
18206 fields := graphql.CollectFields(ec.OperationContext, sel, outerObjectImplementors)
18207
18208 out := graphql.NewFieldSet(fields)
18209 deferred := make(map[string]*graphql.FieldSet)
18210 for i, field := range fields {
18211 switch field.Name {
18212 case "__typename":
18213 out.Values[i] = graphql.MarshalString("OuterObject")
18214 case "inner":
18215 out.Values[i] = ec._OuterObject_inner(ctx, field, obj)
18216 if out.Values[i] == graphql.Null {
18217 out.Invalids++
18218 }
18219 default:
18220 panic("unknown field " + strconv.Quote(field.Name))
18221 }
18222 }
18223 out.Dispatch(ctx)
18224 if out.Invalids > 0 {
18225 return graphql.Null
18226 }
18227
18228 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
18229
18230 for label, dfs := range deferred {
18231 ec.processDeferredGroup(graphql.DeferredGroup{
18232 Label: label,
18233 Path: graphql.GetPath(ctx),
18234 FieldSet: dfs,
18235 Context: ctx,
18236 })
18237 }
18238
18239 return out
18240 }
18241
18242 var overlappingFieldsImplementors = []string{"OverlappingFields"}
18243
18244 func (ec *executionContext) _OverlappingFields(ctx context.Context, sel ast.SelectionSet, obj *OverlappingFields) graphql.Marshaler {
18245 fields := graphql.CollectFields(ec.OperationContext, sel, overlappingFieldsImplementors)
18246
18247 out := graphql.NewFieldSet(fields)
18248 deferred := make(map[string]*graphql.FieldSet)
18249 for i, field := range fields {
18250 switch field.Name {
18251 case "__typename":
18252 out.Values[i] = graphql.MarshalString("OverlappingFields")
18253 case "oneFoo":
18254 out.Values[i] = ec._OverlappingFields_oneFoo(ctx, field, obj)
18255 if out.Values[i] == graphql.Null {
18256 atomic.AddUint32(&out.Invalids, 1)
18257 }
18258 case "twoFoo":
18259 out.Values[i] = ec._OverlappingFields_twoFoo(ctx, field, obj)
18260 if out.Values[i] == graphql.Null {
18261 atomic.AddUint32(&out.Invalids, 1)
18262 }
18263 case "oldFoo":
18264 field := field
18265
18266 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
18267 defer func() {
18268 if r := recover(); r != nil {
18269 ec.Error(ctx, ec.Recover(ctx, r))
18270 }
18271 }()
18272 res = ec._OverlappingFields_oldFoo(ctx, field, obj)
18273 if res == graphql.Null {
18274 atomic.AddUint32(&fs.Invalids, 1)
18275 }
18276 return res
18277 }
18278
18279 if field.Deferrable != nil {
18280 dfs, ok := deferred[field.Deferrable.Label]
18281 di := 0
18282 if ok {
18283 dfs.AddField(field)
18284 di = len(dfs.Values) - 1
18285 } else {
18286 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
18287 deferred[field.Deferrable.Label] = dfs
18288 }
18289 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
18290 return innerFunc(ctx, dfs)
18291 })
18292
18293
18294 out.Values[i] = graphql.Null
18295 continue
18296 }
18297
18298 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
18299 case "newFoo":
18300 out.Values[i] = ec._OverlappingFields_newFoo(ctx, field, obj)
18301 if out.Values[i] == graphql.Null {
18302 atomic.AddUint32(&out.Invalids, 1)
18303 }
18304 case "new_foo":
18305 out.Values[i] = ec._OverlappingFields_new_foo(ctx, field, obj)
18306 if out.Values[i] == graphql.Null {
18307 atomic.AddUint32(&out.Invalids, 1)
18308 }
18309 default:
18310 panic("unknown field " + strconv.Quote(field.Name))
18311 }
18312 }
18313 out.Dispatch(ctx)
18314 if out.Invalids > 0 {
18315 return graphql.Null
18316 }
18317
18318 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
18319
18320 for label, dfs := range deferred {
18321 ec.processDeferredGroup(graphql.DeferredGroup{
18322 Label: label,
18323 Path: graphql.GetPath(ctx),
18324 FieldSet: dfs,
18325 Context: ctx,
18326 })
18327 }
18328
18329 return out
18330 }
18331
18332 var panicsImplementors = []string{"Panics"}
18333
18334 func (ec *executionContext) _Panics(ctx context.Context, sel ast.SelectionSet, obj *Panics) graphql.Marshaler {
18335 fields := graphql.CollectFields(ec.OperationContext, sel, panicsImplementors)
18336
18337 out := graphql.NewFieldSet(fields)
18338 deferred := make(map[string]*graphql.FieldSet)
18339 for i, field := range fields {
18340 switch field.Name {
18341 case "__typename":
18342 out.Values[i] = graphql.MarshalString("Panics")
18343 case "fieldScalarMarshal":
18344 field := field
18345
18346 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
18347 defer func() {
18348 if r := recover(); r != nil {
18349 ec.Error(ctx, ec.Recover(ctx, r))
18350 }
18351 }()
18352 res = ec._Panics_fieldScalarMarshal(ctx, field, obj)
18353 if res == graphql.Null {
18354 atomic.AddUint32(&fs.Invalids, 1)
18355 }
18356 return res
18357 }
18358
18359 if field.Deferrable != nil {
18360 dfs, ok := deferred[field.Deferrable.Label]
18361 di := 0
18362 if ok {
18363 dfs.AddField(field)
18364 di = len(dfs.Values) - 1
18365 } else {
18366 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
18367 deferred[field.Deferrable.Label] = dfs
18368 }
18369 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
18370 return innerFunc(ctx, dfs)
18371 })
18372
18373
18374 out.Values[i] = graphql.Null
18375 continue
18376 }
18377
18378 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
18379 case "fieldFuncMarshal":
18380 field := field
18381
18382 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
18383 defer func() {
18384 if r := recover(); r != nil {
18385 ec.Error(ctx, ec.Recover(ctx, r))
18386 }
18387 }()
18388 res = ec._Panics_fieldFuncMarshal(ctx, field, obj)
18389 if res == graphql.Null {
18390 atomic.AddUint32(&fs.Invalids, 1)
18391 }
18392 return res
18393 }
18394
18395 if field.Deferrable != nil {
18396 dfs, ok := deferred[field.Deferrable.Label]
18397 di := 0
18398 if ok {
18399 dfs.AddField(field)
18400 di = len(dfs.Values) - 1
18401 } else {
18402 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
18403 deferred[field.Deferrable.Label] = dfs
18404 }
18405 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
18406 return innerFunc(ctx, dfs)
18407 })
18408
18409
18410 out.Values[i] = graphql.Null
18411 continue
18412 }
18413
18414 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
18415 case "argUnmarshal":
18416 field := field
18417
18418 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
18419 defer func() {
18420 if r := recover(); r != nil {
18421 ec.Error(ctx, ec.Recover(ctx, r))
18422 }
18423 }()
18424 res = ec._Panics_argUnmarshal(ctx, field, obj)
18425 if res == graphql.Null {
18426 atomic.AddUint32(&fs.Invalids, 1)
18427 }
18428 return res
18429 }
18430
18431 if field.Deferrable != nil {
18432 dfs, ok := deferred[field.Deferrable.Label]
18433 di := 0
18434 if ok {
18435 dfs.AddField(field)
18436 di = len(dfs.Values) - 1
18437 } else {
18438 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
18439 deferred[field.Deferrable.Label] = dfs
18440 }
18441 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
18442 return innerFunc(ctx, dfs)
18443 })
18444
18445
18446 out.Values[i] = graphql.Null
18447 continue
18448 }
18449
18450 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
18451 default:
18452 panic("unknown field " + strconv.Quote(field.Name))
18453 }
18454 }
18455 out.Dispatch(ctx)
18456 if out.Invalids > 0 {
18457 return graphql.Null
18458 }
18459
18460 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
18461
18462 for label, dfs := range deferred {
18463 ec.processDeferredGroup(graphql.DeferredGroup{
18464 Label: label,
18465 Path: graphql.GetPath(ctx),
18466 FieldSet: dfs,
18467 Context: ctx,
18468 })
18469 }
18470
18471 return out
18472 }
18473
18474 var petImplementors = []string{"Pet"}
18475
18476 func (ec *executionContext) _Pet(ctx context.Context, sel ast.SelectionSet, obj *Pet) graphql.Marshaler {
18477 fields := graphql.CollectFields(ec.OperationContext, sel, petImplementors)
18478
18479 out := graphql.NewFieldSet(fields)
18480 deferred := make(map[string]*graphql.FieldSet)
18481 for i, field := range fields {
18482 switch field.Name {
18483 case "__typename":
18484 out.Values[i] = graphql.MarshalString("Pet")
18485 case "id":
18486 out.Values[i] = ec._Pet_id(ctx, field, obj)
18487 if out.Values[i] == graphql.Null {
18488 atomic.AddUint32(&out.Invalids, 1)
18489 }
18490 case "friends":
18491 field := field
18492
18493 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
18494 defer func() {
18495 if r := recover(); r != nil {
18496 ec.Error(ctx, ec.Recover(ctx, r))
18497 }
18498 }()
18499 res = ec._Pet_friends(ctx, field, obj)
18500 return res
18501 }
18502
18503 if field.Deferrable != nil {
18504 dfs, ok := deferred[field.Deferrable.Label]
18505 di := 0
18506 if ok {
18507 dfs.AddField(field)
18508 di = len(dfs.Values) - 1
18509 } else {
18510 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
18511 deferred[field.Deferrable.Label] = dfs
18512 }
18513 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
18514 return innerFunc(ctx, dfs)
18515 })
18516
18517
18518 out.Values[i] = graphql.Null
18519 continue
18520 }
18521
18522 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
18523 default:
18524 panic("unknown field " + strconv.Quote(field.Name))
18525 }
18526 }
18527 out.Dispatch(ctx)
18528 if out.Invalids > 0 {
18529 return graphql.Null
18530 }
18531
18532 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
18533
18534 for label, dfs := range deferred {
18535 ec.processDeferredGroup(graphql.DeferredGroup{
18536 Label: label,
18537 Path: graphql.GetPath(ctx),
18538 FieldSet: dfs,
18539 Context: ctx,
18540 })
18541 }
18542
18543 return out
18544 }
18545
18546 var primitiveImplementors = []string{"Primitive"}
18547
18548 func (ec *executionContext) _Primitive(ctx context.Context, sel ast.SelectionSet, obj *Primitive) graphql.Marshaler {
18549 fields := graphql.CollectFields(ec.OperationContext, sel, primitiveImplementors)
18550
18551 out := graphql.NewFieldSet(fields)
18552 deferred := make(map[string]*graphql.FieldSet)
18553 for i, field := range fields {
18554 switch field.Name {
18555 case "__typename":
18556 out.Values[i] = graphql.MarshalString("Primitive")
18557 case "value":
18558 field := field
18559
18560 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
18561 defer func() {
18562 if r := recover(); r != nil {
18563 ec.Error(ctx, ec.Recover(ctx, r))
18564 }
18565 }()
18566 res = ec._Primitive_value(ctx, field, obj)
18567 if res == graphql.Null {
18568 atomic.AddUint32(&fs.Invalids, 1)
18569 }
18570 return res
18571 }
18572
18573 if field.Deferrable != nil {
18574 dfs, ok := deferred[field.Deferrable.Label]
18575 di := 0
18576 if ok {
18577 dfs.AddField(field)
18578 di = len(dfs.Values) - 1
18579 } else {
18580 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
18581 deferred[field.Deferrable.Label] = dfs
18582 }
18583 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
18584 return innerFunc(ctx, dfs)
18585 })
18586
18587
18588 out.Values[i] = graphql.Null
18589 continue
18590 }
18591
18592 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
18593 case "squared":
18594 out.Values[i] = ec._Primitive_squared(ctx, field, obj)
18595 if out.Values[i] == graphql.Null {
18596 atomic.AddUint32(&out.Invalids, 1)
18597 }
18598 default:
18599 panic("unknown field " + strconv.Quote(field.Name))
18600 }
18601 }
18602 out.Dispatch(ctx)
18603 if out.Invalids > 0 {
18604 return graphql.Null
18605 }
18606
18607 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
18608
18609 for label, dfs := range deferred {
18610 ec.processDeferredGroup(graphql.DeferredGroup{
18611 Label: label,
18612 Path: graphql.GetPath(ctx),
18613 FieldSet: dfs,
18614 Context: ctx,
18615 })
18616 }
18617
18618 return out
18619 }
18620
18621 var primitiveStringImplementors = []string{"PrimitiveString"}
18622
18623 func (ec *executionContext) _PrimitiveString(ctx context.Context, sel ast.SelectionSet, obj *PrimitiveString) graphql.Marshaler {
18624 fields := graphql.CollectFields(ec.OperationContext, sel, primitiveStringImplementors)
18625
18626 out := graphql.NewFieldSet(fields)
18627 deferred := make(map[string]*graphql.FieldSet)
18628 for i, field := range fields {
18629 switch field.Name {
18630 case "__typename":
18631 out.Values[i] = graphql.MarshalString("PrimitiveString")
18632 case "value":
18633 field := field
18634
18635 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
18636 defer func() {
18637 if r := recover(); r != nil {
18638 ec.Error(ctx, ec.Recover(ctx, r))
18639 }
18640 }()
18641 res = ec._PrimitiveString_value(ctx, field, obj)
18642 if res == graphql.Null {
18643 atomic.AddUint32(&fs.Invalids, 1)
18644 }
18645 return res
18646 }
18647
18648 if field.Deferrable != nil {
18649 dfs, ok := deferred[field.Deferrable.Label]
18650 di := 0
18651 if ok {
18652 dfs.AddField(field)
18653 di = len(dfs.Values) - 1
18654 } else {
18655 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
18656 deferred[field.Deferrable.Label] = dfs
18657 }
18658 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
18659 return innerFunc(ctx, dfs)
18660 })
18661
18662
18663 out.Values[i] = graphql.Null
18664 continue
18665 }
18666
18667 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
18668 case "doubled":
18669 out.Values[i] = ec._PrimitiveString_doubled(ctx, field, obj)
18670 if out.Values[i] == graphql.Null {
18671 atomic.AddUint32(&out.Invalids, 1)
18672 }
18673 case "len":
18674 field := field
18675
18676 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
18677 defer func() {
18678 if r := recover(); r != nil {
18679 ec.Error(ctx, ec.Recover(ctx, r))
18680 }
18681 }()
18682 res = ec._PrimitiveString_len(ctx, field, obj)
18683 if res == graphql.Null {
18684 atomic.AddUint32(&fs.Invalids, 1)
18685 }
18686 return res
18687 }
18688
18689 if field.Deferrable != nil {
18690 dfs, ok := deferred[field.Deferrable.Label]
18691 di := 0
18692 if ok {
18693 dfs.AddField(field)
18694 di = len(dfs.Values) - 1
18695 } else {
18696 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
18697 deferred[field.Deferrable.Label] = dfs
18698 }
18699 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
18700 return innerFunc(ctx, dfs)
18701 })
18702
18703
18704 out.Values[i] = graphql.Null
18705 continue
18706 }
18707
18708 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
18709 default:
18710 panic("unknown field " + strconv.Quote(field.Name))
18711 }
18712 }
18713 out.Dispatch(ctx)
18714 if out.Invalids > 0 {
18715 return graphql.Null
18716 }
18717
18718 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
18719
18720 for label, dfs := range deferred {
18721 ec.processDeferredGroup(graphql.DeferredGroup{
18722 Label: label,
18723 Path: graphql.GetPath(ctx),
18724 FieldSet: dfs,
18725 Context: ctx,
18726 })
18727 }
18728
18729 return out
18730 }
18731
18732 var ptrToAnyContainerImplementors = []string{"PtrToAnyContainer"}
18733
18734 func (ec *executionContext) _PtrToAnyContainer(ctx context.Context, sel ast.SelectionSet, obj *PtrToAnyContainer) graphql.Marshaler {
18735 fields := graphql.CollectFields(ec.OperationContext, sel, ptrToAnyContainerImplementors)
18736
18737 out := graphql.NewFieldSet(fields)
18738 deferred := make(map[string]*graphql.FieldSet)
18739 for i, field := range fields {
18740 switch field.Name {
18741 case "__typename":
18742 out.Values[i] = graphql.MarshalString("PtrToAnyContainer")
18743 case "ptrToAny":
18744 out.Values[i] = ec._PtrToAnyContainer_ptrToAny(ctx, field, obj)
18745 case "binding":
18746 out.Values[i] = ec._PtrToAnyContainer_binding(ctx, field, obj)
18747 default:
18748 panic("unknown field " + strconv.Quote(field.Name))
18749 }
18750 }
18751 out.Dispatch(ctx)
18752 if out.Invalids > 0 {
18753 return graphql.Null
18754 }
18755
18756 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
18757
18758 for label, dfs := range deferred {
18759 ec.processDeferredGroup(graphql.DeferredGroup{
18760 Label: label,
18761 Path: graphql.GetPath(ctx),
18762 FieldSet: dfs,
18763 Context: ctx,
18764 })
18765 }
18766
18767 return out
18768 }
18769
18770 var ptrToPtrInnerImplementors = []string{"PtrToPtrInner"}
18771
18772 func (ec *executionContext) _PtrToPtrInner(ctx context.Context, sel ast.SelectionSet, obj *PtrToPtrInner) graphql.Marshaler {
18773 fields := graphql.CollectFields(ec.OperationContext, sel, ptrToPtrInnerImplementors)
18774
18775 out := graphql.NewFieldSet(fields)
18776 deferred := make(map[string]*graphql.FieldSet)
18777 for i, field := range fields {
18778 switch field.Name {
18779 case "__typename":
18780 out.Values[i] = graphql.MarshalString("PtrToPtrInner")
18781 case "key":
18782 out.Values[i] = ec._PtrToPtrInner_key(ctx, field, obj)
18783 if out.Values[i] == graphql.Null {
18784 out.Invalids++
18785 }
18786 case "value":
18787 out.Values[i] = ec._PtrToPtrInner_value(ctx, field, obj)
18788 if out.Values[i] == graphql.Null {
18789 out.Invalids++
18790 }
18791 default:
18792 panic("unknown field " + strconv.Quote(field.Name))
18793 }
18794 }
18795 out.Dispatch(ctx)
18796 if out.Invalids > 0 {
18797 return graphql.Null
18798 }
18799
18800 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
18801
18802 for label, dfs := range deferred {
18803 ec.processDeferredGroup(graphql.DeferredGroup{
18804 Label: label,
18805 Path: graphql.GetPath(ctx),
18806 FieldSet: dfs,
18807 Context: ctx,
18808 })
18809 }
18810
18811 return out
18812 }
18813
18814 var ptrToPtrOuterImplementors = []string{"PtrToPtrOuter"}
18815
18816 func (ec *executionContext) _PtrToPtrOuter(ctx context.Context, sel ast.SelectionSet, obj *PtrToPtrOuter) graphql.Marshaler {
18817 fields := graphql.CollectFields(ec.OperationContext, sel, ptrToPtrOuterImplementors)
18818
18819 out := graphql.NewFieldSet(fields)
18820 deferred := make(map[string]*graphql.FieldSet)
18821 for i, field := range fields {
18822 switch field.Name {
18823 case "__typename":
18824 out.Values[i] = graphql.MarshalString("PtrToPtrOuter")
18825 case "name":
18826 out.Values[i] = ec._PtrToPtrOuter_name(ctx, field, obj)
18827 if out.Values[i] == graphql.Null {
18828 out.Invalids++
18829 }
18830 case "inner":
18831 out.Values[i] = ec._PtrToPtrOuter_inner(ctx, field, obj)
18832 case "stupidInner":
18833 out.Values[i] = ec._PtrToPtrOuter_stupidInner(ctx, field, obj)
18834 default:
18835 panic("unknown field " + strconv.Quote(field.Name))
18836 }
18837 }
18838 out.Dispatch(ctx)
18839 if out.Invalids > 0 {
18840 return graphql.Null
18841 }
18842
18843 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
18844
18845 for label, dfs := range deferred {
18846 ec.processDeferredGroup(graphql.DeferredGroup{
18847 Label: label,
18848 Path: graphql.GetPath(ctx),
18849 FieldSet: dfs,
18850 Context: ctx,
18851 })
18852 }
18853
18854 return out
18855 }
18856
18857 var ptrToSliceContainerImplementors = []string{"PtrToSliceContainer"}
18858
18859 func (ec *executionContext) _PtrToSliceContainer(ctx context.Context, sel ast.SelectionSet, obj *PtrToSliceContainer) graphql.Marshaler {
18860 fields := graphql.CollectFields(ec.OperationContext, sel, ptrToSliceContainerImplementors)
18861
18862 out := graphql.NewFieldSet(fields)
18863 deferred := make(map[string]*graphql.FieldSet)
18864 for i, field := range fields {
18865 switch field.Name {
18866 case "__typename":
18867 out.Values[i] = graphql.MarshalString("PtrToSliceContainer")
18868 case "ptrToSlice":
18869 out.Values[i] = ec._PtrToSliceContainer_ptrToSlice(ctx, field, obj)
18870 default:
18871 panic("unknown field " + strconv.Quote(field.Name))
18872 }
18873 }
18874 out.Dispatch(ctx)
18875 if out.Invalids > 0 {
18876 return graphql.Null
18877 }
18878
18879 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
18880
18881 for label, dfs := range deferred {
18882 ec.processDeferredGroup(graphql.DeferredGroup{
18883 Label: label,
18884 Path: graphql.GetPath(ctx),
18885 FieldSet: dfs,
18886 Context: ctx,
18887 })
18888 }
18889
18890 return out
18891 }
18892
18893 var queryImplementors = []string{"Query"}
18894
18895 func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
18896 fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
18897 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
18898 Object: "Query",
18899 })
18900
18901 out := graphql.NewFieldSet(fields)
18902 deferred := make(map[string]*graphql.FieldSet)
18903 for i, field := range fields {
18904 innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
18905 Object: field.Name,
18906 Field: field,
18907 })
18908
18909 switch field.Name {
18910 case "__typename":
18911 out.Values[i] = graphql.MarshalString("Query")
18912 case "invalidIdentifier":
18913 field := field
18914
18915 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
18916 defer func() {
18917 if r := recover(); r != nil {
18918 ec.Error(ctx, ec.Recover(ctx, r))
18919 }
18920 }()
18921 res = ec._Query_invalidIdentifier(ctx, field)
18922 return res
18923 }
18924
18925 rrm := func(ctx context.Context) graphql.Marshaler {
18926 return ec.OperationContext.RootResolverMiddleware(ctx,
18927 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
18928 }
18929
18930 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
18931 case "collision":
18932 field := field
18933
18934 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
18935 defer func() {
18936 if r := recover(); r != nil {
18937 ec.Error(ctx, ec.Recover(ctx, r))
18938 }
18939 }()
18940 res = ec._Query_collision(ctx, field)
18941 return res
18942 }
18943
18944 rrm := func(ctx context.Context) graphql.Marshaler {
18945 return ec.OperationContext.RootResolverMiddleware(ctx,
18946 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
18947 }
18948
18949 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
18950 case "mapInput":
18951 field := field
18952
18953 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
18954 defer func() {
18955 if r := recover(); r != nil {
18956 ec.Error(ctx, ec.Recover(ctx, r))
18957 }
18958 }()
18959 res = ec._Query_mapInput(ctx, field)
18960 return res
18961 }
18962
18963 rrm := func(ctx context.Context) graphql.Marshaler {
18964 return ec.OperationContext.RootResolverMiddleware(ctx,
18965 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
18966 }
18967
18968 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
18969 case "recursive":
18970 field := field
18971
18972 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
18973 defer func() {
18974 if r := recover(); r != nil {
18975 ec.Error(ctx, ec.Recover(ctx, r))
18976 }
18977 }()
18978 res = ec._Query_recursive(ctx, field)
18979 return res
18980 }
18981
18982 rrm := func(ctx context.Context) graphql.Marshaler {
18983 return ec.OperationContext.RootResolverMiddleware(ctx,
18984 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
18985 }
18986
18987 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
18988 case "nestedInputs":
18989 field := field
18990
18991 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
18992 defer func() {
18993 if r := recover(); r != nil {
18994 ec.Error(ctx, ec.Recover(ctx, r))
18995 }
18996 }()
18997 res = ec._Query_nestedInputs(ctx, field)
18998 return res
18999 }
19000
19001 rrm := func(ctx context.Context) graphql.Marshaler {
19002 return ec.OperationContext.RootResolverMiddleware(ctx,
19003 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19004 }
19005
19006 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19007 case "nestedOutputs":
19008 field := field
19009
19010 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19011 defer func() {
19012 if r := recover(); r != nil {
19013 ec.Error(ctx, ec.Recover(ctx, r))
19014 }
19015 }()
19016 res = ec._Query_nestedOutputs(ctx, field)
19017 return res
19018 }
19019
19020 rrm := func(ctx context.Context) graphql.Marshaler {
19021 return ec.OperationContext.RootResolverMiddleware(ctx,
19022 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19023 }
19024
19025 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19026 case "modelMethods":
19027 field := field
19028
19029 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19030 defer func() {
19031 if r := recover(); r != nil {
19032 ec.Error(ctx, ec.Recover(ctx, r))
19033 }
19034 }()
19035 res = ec._Query_modelMethods(ctx, field)
19036 return res
19037 }
19038
19039 rrm := func(ctx context.Context) graphql.Marshaler {
19040 return ec.OperationContext.RootResolverMiddleware(ctx,
19041 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19042 }
19043
19044 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19045 case "user":
19046 field := field
19047
19048 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19049 defer func() {
19050 if r := recover(); r != nil {
19051 ec.Error(ctx, ec.Recover(ctx, r))
19052 }
19053 }()
19054 res = ec._Query_user(ctx, field)
19055 if res == graphql.Null {
19056 atomic.AddUint32(&fs.Invalids, 1)
19057 }
19058 return res
19059 }
19060
19061 rrm := func(ctx context.Context) graphql.Marshaler {
19062 return ec.OperationContext.RootResolverMiddleware(ctx,
19063 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19064 }
19065
19066 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19067 case "nullableArg":
19068 field := field
19069
19070 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19071 defer func() {
19072 if r := recover(); r != nil {
19073 ec.Error(ctx, ec.Recover(ctx, r))
19074 }
19075 }()
19076 res = ec._Query_nullableArg(ctx, field)
19077 return res
19078 }
19079
19080 rrm := func(ctx context.Context) graphql.Marshaler {
19081 return ec.OperationContext.RootResolverMiddleware(ctx,
19082 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19083 }
19084
19085 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19086 case "inputSlice":
19087 field := field
19088
19089 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19090 defer func() {
19091 if r := recover(); r != nil {
19092 ec.Error(ctx, ec.Recover(ctx, r))
19093 }
19094 }()
19095 res = ec._Query_inputSlice(ctx, field)
19096 if res == graphql.Null {
19097 atomic.AddUint32(&fs.Invalids, 1)
19098 }
19099 return res
19100 }
19101
19102 rrm := func(ctx context.Context) graphql.Marshaler {
19103 return ec.OperationContext.RootResolverMiddleware(ctx,
19104 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19105 }
19106
19107 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19108 case "inputNullableSlice":
19109 field := field
19110
19111 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19112 defer func() {
19113 if r := recover(); r != nil {
19114 ec.Error(ctx, ec.Recover(ctx, r))
19115 }
19116 }()
19117 res = ec._Query_inputNullableSlice(ctx, field)
19118 if res == graphql.Null {
19119 atomic.AddUint32(&fs.Invalids, 1)
19120 }
19121 return res
19122 }
19123
19124 rrm := func(ctx context.Context) graphql.Marshaler {
19125 return ec.OperationContext.RootResolverMiddleware(ctx,
19126 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19127 }
19128
19129 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19130 case "inputOmittable":
19131 field := field
19132
19133 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19134 defer func() {
19135 if r := recover(); r != nil {
19136 ec.Error(ctx, ec.Recover(ctx, r))
19137 }
19138 }()
19139 res = ec._Query_inputOmittable(ctx, field)
19140 if res == graphql.Null {
19141 atomic.AddUint32(&fs.Invalids, 1)
19142 }
19143 return res
19144 }
19145
19146 rrm := func(ctx context.Context) graphql.Marshaler {
19147 return ec.OperationContext.RootResolverMiddleware(ctx,
19148 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19149 }
19150
19151 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19152 case "shapeUnion":
19153 field := field
19154
19155 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19156 defer func() {
19157 if r := recover(); r != nil {
19158 ec.Error(ctx, ec.Recover(ctx, r))
19159 }
19160 }()
19161 res = ec._Query_shapeUnion(ctx, field)
19162 if res == graphql.Null {
19163 atomic.AddUint32(&fs.Invalids, 1)
19164 }
19165 return res
19166 }
19167
19168 rrm := func(ctx context.Context) graphql.Marshaler {
19169 return ec.OperationContext.RootResolverMiddleware(ctx,
19170 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19171 }
19172
19173 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19174 case "autobind":
19175 field := field
19176
19177 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19178 defer func() {
19179 if r := recover(); r != nil {
19180 ec.Error(ctx, ec.Recover(ctx, r))
19181 }
19182 }()
19183 res = ec._Query_autobind(ctx, field)
19184 return res
19185 }
19186
19187 rrm := func(ctx context.Context) graphql.Marshaler {
19188 return ec.OperationContext.RootResolverMiddleware(ctx,
19189 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19190 }
19191
19192 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19193 case "deprecatedField":
19194 field := field
19195
19196 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19197 defer func() {
19198 if r := recover(); r != nil {
19199 ec.Error(ctx, ec.Recover(ctx, r))
19200 }
19201 }()
19202 res = ec._Query_deprecatedField(ctx, field)
19203 if res == graphql.Null {
19204 atomic.AddUint32(&fs.Invalids, 1)
19205 }
19206 return res
19207 }
19208
19209 rrm := func(ctx context.Context) graphql.Marshaler {
19210 return ec.OperationContext.RootResolverMiddleware(ctx,
19211 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19212 }
19213
19214 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19215 case "overlapping":
19216 field := field
19217
19218 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19219 defer func() {
19220 if r := recover(); r != nil {
19221 ec.Error(ctx, ec.Recover(ctx, r))
19222 }
19223 }()
19224 res = ec._Query_overlapping(ctx, field)
19225 return res
19226 }
19227
19228 rrm := func(ctx context.Context) graphql.Marshaler {
19229 return ec.OperationContext.RootResolverMiddleware(ctx,
19230 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19231 }
19232
19233 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19234 case "defaultParameters":
19235 field := field
19236
19237 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19238 defer func() {
19239 if r := recover(); r != nil {
19240 ec.Error(ctx, ec.Recover(ctx, r))
19241 }
19242 }()
19243 res = ec._Query_defaultParameters(ctx, field)
19244 if res == graphql.Null {
19245 atomic.AddUint32(&fs.Invalids, 1)
19246 }
19247 return res
19248 }
19249
19250 rrm := func(ctx context.Context) graphql.Marshaler {
19251 return ec.OperationContext.RootResolverMiddleware(ctx,
19252 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19253 }
19254
19255 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19256 case "deferCase1":
19257 field := field
19258
19259 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19260 defer func() {
19261 if r := recover(); r != nil {
19262 ec.Error(ctx, ec.Recover(ctx, r))
19263 }
19264 }()
19265 res = ec._Query_deferCase1(ctx, field)
19266 return res
19267 }
19268
19269 rrm := func(ctx context.Context) graphql.Marshaler {
19270 return ec.OperationContext.RootResolverMiddleware(ctx,
19271 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19272 }
19273
19274 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19275 case "deferCase2":
19276 field := field
19277
19278 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19279 defer func() {
19280 if r := recover(); r != nil {
19281 ec.Error(ctx, ec.Recover(ctx, r))
19282 }
19283 }()
19284 res = ec._Query_deferCase2(ctx, field)
19285 return res
19286 }
19287
19288 rrm := func(ctx context.Context) graphql.Marshaler {
19289 return ec.OperationContext.RootResolverMiddleware(ctx,
19290 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19291 }
19292
19293 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19294 case "directiveArg":
19295 field := field
19296
19297 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19298 defer func() {
19299 if r := recover(); r != nil {
19300 ec.Error(ctx, ec.Recover(ctx, r))
19301 }
19302 }()
19303 res = ec._Query_directiveArg(ctx, field)
19304 return res
19305 }
19306
19307 rrm := func(ctx context.Context) graphql.Marshaler {
19308 return ec.OperationContext.RootResolverMiddleware(ctx,
19309 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19310 }
19311
19312 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19313 case "directiveNullableArg":
19314 field := field
19315
19316 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19317 defer func() {
19318 if r := recover(); r != nil {
19319 ec.Error(ctx, ec.Recover(ctx, r))
19320 }
19321 }()
19322 res = ec._Query_directiveNullableArg(ctx, field)
19323 return res
19324 }
19325
19326 rrm := func(ctx context.Context) graphql.Marshaler {
19327 return ec.OperationContext.RootResolverMiddleware(ctx,
19328 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19329 }
19330
19331 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19332 case "directiveInputNullable":
19333 field := field
19334
19335 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19336 defer func() {
19337 if r := recover(); r != nil {
19338 ec.Error(ctx, ec.Recover(ctx, r))
19339 }
19340 }()
19341 res = ec._Query_directiveInputNullable(ctx, field)
19342 return res
19343 }
19344
19345 rrm := func(ctx context.Context) graphql.Marshaler {
19346 return ec.OperationContext.RootResolverMiddleware(ctx,
19347 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19348 }
19349
19350 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19351 case "directiveInput":
19352 field := field
19353
19354 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19355 defer func() {
19356 if r := recover(); r != nil {
19357 ec.Error(ctx, ec.Recover(ctx, r))
19358 }
19359 }()
19360 res = ec._Query_directiveInput(ctx, field)
19361 return res
19362 }
19363
19364 rrm := func(ctx context.Context) graphql.Marshaler {
19365 return ec.OperationContext.RootResolverMiddleware(ctx,
19366 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19367 }
19368
19369 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19370 case "directiveInputType":
19371 field := field
19372
19373 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19374 defer func() {
19375 if r := recover(); r != nil {
19376 ec.Error(ctx, ec.Recover(ctx, r))
19377 }
19378 }()
19379 res = ec._Query_directiveInputType(ctx, field)
19380 return res
19381 }
19382
19383 rrm := func(ctx context.Context) graphql.Marshaler {
19384 return ec.OperationContext.RootResolverMiddleware(ctx,
19385 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19386 }
19387
19388 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19389 case "directiveObject":
19390 field := field
19391
19392 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19393 defer func() {
19394 if r := recover(); r != nil {
19395 ec.Error(ctx, ec.Recover(ctx, r))
19396 }
19397 }()
19398 res = ec._Query_directiveObject(ctx, field)
19399 return res
19400 }
19401
19402 rrm := func(ctx context.Context) graphql.Marshaler {
19403 return ec.OperationContext.RootResolverMiddleware(ctx,
19404 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19405 }
19406
19407 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19408 case "directiveObjectWithCustomGoModel":
19409 field := field
19410
19411 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19412 defer func() {
19413 if r := recover(); r != nil {
19414 ec.Error(ctx, ec.Recover(ctx, r))
19415 }
19416 }()
19417 res = ec._Query_directiveObjectWithCustomGoModel(ctx, field)
19418 return res
19419 }
19420
19421 rrm := func(ctx context.Context) graphql.Marshaler {
19422 return ec.OperationContext.RootResolverMiddleware(ctx,
19423 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19424 }
19425
19426 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19427 case "directiveFieldDef":
19428 field := field
19429
19430 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19431 defer func() {
19432 if r := recover(); r != nil {
19433 ec.Error(ctx, ec.Recover(ctx, r))
19434 }
19435 }()
19436 res = ec._Query_directiveFieldDef(ctx, field)
19437 if res == graphql.Null {
19438 atomic.AddUint32(&fs.Invalids, 1)
19439 }
19440 return res
19441 }
19442
19443 rrm := func(ctx context.Context) graphql.Marshaler {
19444 return ec.OperationContext.RootResolverMiddleware(ctx,
19445 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19446 }
19447
19448 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19449 case "directiveField":
19450 field := field
19451
19452 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19453 defer func() {
19454 if r := recover(); r != nil {
19455 ec.Error(ctx, ec.Recover(ctx, r))
19456 }
19457 }()
19458 res = ec._Query_directiveField(ctx, field)
19459 return res
19460 }
19461
19462 rrm := func(ctx context.Context) graphql.Marshaler {
19463 return ec.OperationContext.RootResolverMiddleware(ctx,
19464 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19465 }
19466
19467 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19468 case "directiveDouble":
19469 field := field
19470
19471 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19472 defer func() {
19473 if r := recover(); r != nil {
19474 ec.Error(ctx, ec.Recover(ctx, r))
19475 }
19476 }()
19477 res = ec._Query_directiveDouble(ctx, field)
19478 return res
19479 }
19480
19481 rrm := func(ctx context.Context) graphql.Marshaler {
19482 return ec.OperationContext.RootResolverMiddleware(ctx,
19483 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19484 }
19485
19486 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19487 case "directiveUnimplemented":
19488 field := field
19489
19490 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19491 defer func() {
19492 if r := recover(); r != nil {
19493 ec.Error(ctx, ec.Recover(ctx, r))
19494 }
19495 }()
19496 res = ec._Query_directiveUnimplemented(ctx, field)
19497 return res
19498 }
19499
19500 rrm := func(ctx context.Context) graphql.Marshaler {
19501 return ec.OperationContext.RootResolverMiddleware(ctx,
19502 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19503 }
19504
19505 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19506 case "embeddedCase1":
19507 field := field
19508
19509 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19510 defer func() {
19511 if r := recover(); r != nil {
19512 ec.Error(ctx, ec.Recover(ctx, r))
19513 }
19514 }()
19515 res = ec._Query_embeddedCase1(ctx, field)
19516 return res
19517 }
19518
19519 rrm := func(ctx context.Context) graphql.Marshaler {
19520 return ec.OperationContext.RootResolverMiddleware(ctx,
19521 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19522 }
19523
19524 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19525 case "embeddedCase2":
19526 field := field
19527
19528 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19529 defer func() {
19530 if r := recover(); r != nil {
19531 ec.Error(ctx, ec.Recover(ctx, r))
19532 }
19533 }()
19534 res = ec._Query_embeddedCase2(ctx, field)
19535 return res
19536 }
19537
19538 rrm := func(ctx context.Context) graphql.Marshaler {
19539 return ec.OperationContext.RootResolverMiddleware(ctx,
19540 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19541 }
19542
19543 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19544 case "embeddedCase3":
19545 field := field
19546
19547 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19548 defer func() {
19549 if r := recover(); r != nil {
19550 ec.Error(ctx, ec.Recover(ctx, r))
19551 }
19552 }()
19553 res = ec._Query_embeddedCase3(ctx, field)
19554 return res
19555 }
19556
19557 rrm := func(ctx context.Context) graphql.Marshaler {
19558 return ec.OperationContext.RootResolverMiddleware(ctx,
19559 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19560 }
19561
19562 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19563 case "enumInInput":
19564 field := field
19565
19566 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19567 defer func() {
19568 if r := recover(); r != nil {
19569 ec.Error(ctx, ec.Recover(ctx, r))
19570 }
19571 }()
19572 res = ec._Query_enumInInput(ctx, field)
19573 if res == graphql.Null {
19574 atomic.AddUint32(&fs.Invalids, 1)
19575 }
19576 return res
19577 }
19578
19579 rrm := func(ctx context.Context) graphql.Marshaler {
19580 return ec.OperationContext.RootResolverMiddleware(ctx,
19581 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19582 }
19583
19584 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19585 case "shapes":
19586 field := field
19587
19588 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19589 defer func() {
19590 if r := recover(); r != nil {
19591 ec.Error(ctx, ec.Recover(ctx, r))
19592 }
19593 }()
19594 res = ec._Query_shapes(ctx, field)
19595 return res
19596 }
19597
19598 rrm := func(ctx context.Context) graphql.Marshaler {
19599 return ec.OperationContext.RootResolverMiddleware(ctx,
19600 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19601 }
19602
19603 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19604 case "noShape":
19605 field := field
19606
19607 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19608 defer func() {
19609 if r := recover(); r != nil {
19610 ec.Error(ctx, ec.Recover(ctx, r))
19611 }
19612 }()
19613 res = ec._Query_noShape(ctx, field)
19614 return res
19615 }
19616
19617 rrm := func(ctx context.Context) graphql.Marshaler {
19618 return ec.OperationContext.RootResolverMiddleware(ctx,
19619 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19620 }
19621
19622 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19623 case "node":
19624 field := field
19625
19626 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19627 defer func() {
19628 if r := recover(); r != nil {
19629 ec.Error(ctx, ec.Recover(ctx, r))
19630 }
19631 }()
19632 res = ec._Query_node(ctx, field)
19633 if res == graphql.Null {
19634 atomic.AddUint32(&fs.Invalids, 1)
19635 }
19636 return res
19637 }
19638
19639 rrm := func(ctx context.Context) graphql.Marshaler {
19640 return ec.OperationContext.RootResolverMiddleware(ctx,
19641 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19642 }
19643
19644 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19645 case "noShapeTypedNil":
19646 field := field
19647
19648 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19649 defer func() {
19650 if r := recover(); r != nil {
19651 ec.Error(ctx, ec.Recover(ctx, r))
19652 }
19653 }()
19654 res = ec._Query_noShapeTypedNil(ctx, field)
19655 return res
19656 }
19657
19658 rrm := func(ctx context.Context) graphql.Marshaler {
19659 return ec.OperationContext.RootResolverMiddleware(ctx,
19660 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19661 }
19662
19663 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19664 case "animal":
19665 field := field
19666
19667 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19668 defer func() {
19669 if r := recover(); r != nil {
19670 ec.Error(ctx, ec.Recover(ctx, r))
19671 }
19672 }()
19673 res = ec._Query_animal(ctx, field)
19674 return res
19675 }
19676
19677 rrm := func(ctx context.Context) graphql.Marshaler {
19678 return ec.OperationContext.RootResolverMiddleware(ctx,
19679 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19680 }
19681
19682 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19683 case "notAnInterface":
19684 field := field
19685
19686 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19687 defer func() {
19688 if r := recover(); r != nil {
19689 ec.Error(ctx, ec.Recover(ctx, r))
19690 }
19691 }()
19692 res = ec._Query_notAnInterface(ctx, field)
19693 return res
19694 }
19695
19696 rrm := func(ctx context.Context) graphql.Marshaler {
19697 return ec.OperationContext.RootResolverMiddleware(ctx,
19698 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19699 }
19700
19701 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19702 case "dog":
19703 field := field
19704
19705 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19706 defer func() {
19707 if r := recover(); r != nil {
19708 ec.Error(ctx, ec.Recover(ctx, r))
19709 }
19710 }()
19711 res = ec._Query_dog(ctx, field)
19712 return res
19713 }
19714
19715 rrm := func(ctx context.Context) graphql.Marshaler {
19716 return ec.OperationContext.RootResolverMiddleware(ctx,
19717 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19718 }
19719
19720 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19721 case "issue896a":
19722 field := field
19723
19724 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19725 defer func() {
19726 if r := recover(); r != nil {
19727 ec.Error(ctx, ec.Recover(ctx, r))
19728 }
19729 }()
19730 res = ec._Query_issue896a(ctx, field)
19731 return res
19732 }
19733
19734 rrm := func(ctx context.Context) graphql.Marshaler {
19735 return ec.OperationContext.RootResolverMiddleware(ctx,
19736 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19737 }
19738
19739 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19740 case "mapStringInterface":
19741 field := field
19742
19743 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19744 defer func() {
19745 if r := recover(); r != nil {
19746 ec.Error(ctx, ec.Recover(ctx, r))
19747 }
19748 }()
19749 res = ec._Query_mapStringInterface(ctx, field)
19750 return res
19751 }
19752
19753 rrm := func(ctx context.Context) graphql.Marshaler {
19754 return ec.OperationContext.RootResolverMiddleware(ctx,
19755 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19756 }
19757
19758 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19759 case "mapNestedStringInterface":
19760 field := field
19761
19762 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19763 defer func() {
19764 if r := recover(); r != nil {
19765 ec.Error(ctx, ec.Recover(ctx, r))
19766 }
19767 }()
19768 res = ec._Query_mapNestedStringInterface(ctx, field)
19769 return res
19770 }
19771
19772 rrm := func(ctx context.Context) graphql.Marshaler {
19773 return ec.OperationContext.RootResolverMiddleware(ctx,
19774 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19775 }
19776
19777 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19778 case "errorBubble":
19779 field := field
19780
19781 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19782 defer func() {
19783 if r := recover(); r != nil {
19784 ec.Error(ctx, ec.Recover(ctx, r))
19785 }
19786 }()
19787 res = ec._Query_errorBubble(ctx, field)
19788 return res
19789 }
19790
19791 rrm := func(ctx context.Context) graphql.Marshaler {
19792 return ec.OperationContext.RootResolverMiddleware(ctx,
19793 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19794 }
19795
19796 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19797 case "errorBubbleList":
19798 field := field
19799
19800 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19801 defer func() {
19802 if r := recover(); r != nil {
19803 ec.Error(ctx, ec.Recover(ctx, r))
19804 }
19805 }()
19806 res = ec._Query_errorBubbleList(ctx, field)
19807 return res
19808 }
19809
19810 rrm := func(ctx context.Context) graphql.Marshaler {
19811 return ec.OperationContext.RootResolverMiddleware(ctx,
19812 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19813 }
19814
19815 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19816 case "errorList":
19817 field := field
19818
19819 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19820 defer func() {
19821 if r := recover(); r != nil {
19822 ec.Error(ctx, ec.Recover(ctx, r))
19823 }
19824 }()
19825 res = ec._Query_errorList(ctx, field)
19826 return res
19827 }
19828
19829 rrm := func(ctx context.Context) graphql.Marshaler {
19830 return ec.OperationContext.RootResolverMiddleware(ctx,
19831 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19832 }
19833
19834 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19835 case "errors":
19836 field := field
19837
19838 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19839 defer func() {
19840 if r := recover(); r != nil {
19841 ec.Error(ctx, ec.Recover(ctx, r))
19842 }
19843 }()
19844 res = ec._Query_errors(ctx, field)
19845 return res
19846 }
19847
19848 rrm := func(ctx context.Context) graphql.Marshaler {
19849 return ec.OperationContext.RootResolverMiddleware(ctx,
19850 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19851 }
19852
19853 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19854 case "valid":
19855 field := field
19856
19857 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19858 defer func() {
19859 if r := recover(); r != nil {
19860 ec.Error(ctx, ec.Recover(ctx, r))
19861 }
19862 }()
19863 res = ec._Query_valid(ctx, field)
19864 if res == graphql.Null {
19865 atomic.AddUint32(&fs.Invalids, 1)
19866 }
19867 return res
19868 }
19869
19870 rrm := func(ctx context.Context) graphql.Marshaler {
19871 return ec.OperationContext.RootResolverMiddleware(ctx,
19872 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19873 }
19874
19875 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19876 case "invalid":
19877 field := field
19878
19879 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19880 defer func() {
19881 if r := recover(); r != nil {
19882 ec.Error(ctx, ec.Recover(ctx, r))
19883 }
19884 }()
19885 res = ec._Query_invalid(ctx, field)
19886 if res == graphql.Null {
19887 atomic.AddUint32(&fs.Invalids, 1)
19888 }
19889 return res
19890 }
19891
19892 rrm := func(ctx context.Context) graphql.Marshaler {
19893 return ec.OperationContext.RootResolverMiddleware(ctx,
19894 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19895 }
19896
19897 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19898 case "panics":
19899 field := field
19900
19901 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19902 defer func() {
19903 if r := recover(); r != nil {
19904 ec.Error(ctx, ec.Recover(ctx, r))
19905 }
19906 }()
19907 res = ec._Query_panics(ctx, field)
19908 return res
19909 }
19910
19911 rrm := func(ctx context.Context) graphql.Marshaler {
19912 return ec.OperationContext.RootResolverMiddleware(ctx,
19913 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19914 }
19915
19916 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19917 case "primitiveObject":
19918 field := field
19919
19920 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19921 defer func() {
19922 if r := recover(); r != nil {
19923 ec.Error(ctx, ec.Recover(ctx, r))
19924 }
19925 }()
19926 res = ec._Query_primitiveObject(ctx, field)
19927 if res == graphql.Null {
19928 atomic.AddUint32(&fs.Invalids, 1)
19929 }
19930 return res
19931 }
19932
19933 rrm := func(ctx context.Context) graphql.Marshaler {
19934 return ec.OperationContext.RootResolverMiddleware(ctx,
19935 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19936 }
19937
19938 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19939 case "primitiveStringObject":
19940 field := field
19941
19942 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19943 defer func() {
19944 if r := recover(); r != nil {
19945 ec.Error(ctx, ec.Recover(ctx, r))
19946 }
19947 }()
19948 res = ec._Query_primitiveStringObject(ctx, field)
19949 if res == graphql.Null {
19950 atomic.AddUint32(&fs.Invalids, 1)
19951 }
19952 return res
19953 }
19954
19955 rrm := func(ctx context.Context) graphql.Marshaler {
19956 return ec.OperationContext.RootResolverMiddleware(ctx,
19957 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19958 }
19959
19960 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19961 case "ptrToAnyContainer":
19962 field := field
19963
19964 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19965 defer func() {
19966 if r := recover(); r != nil {
19967 ec.Error(ctx, ec.Recover(ctx, r))
19968 }
19969 }()
19970 res = ec._Query_ptrToAnyContainer(ctx, field)
19971 if res == graphql.Null {
19972 atomic.AddUint32(&fs.Invalids, 1)
19973 }
19974 return res
19975 }
19976
19977 rrm := func(ctx context.Context) graphql.Marshaler {
19978 return ec.OperationContext.RootResolverMiddleware(ctx,
19979 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
19980 }
19981
19982 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
19983 case "ptrToSliceContainer":
19984 field := field
19985
19986 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
19987 defer func() {
19988 if r := recover(); r != nil {
19989 ec.Error(ctx, ec.Recover(ctx, r))
19990 }
19991 }()
19992 res = ec._Query_ptrToSliceContainer(ctx, field)
19993 if res == graphql.Null {
19994 atomic.AddUint32(&fs.Invalids, 1)
19995 }
19996 return res
19997 }
19998
19999 rrm := func(ctx context.Context) graphql.Marshaler {
20000 return ec.OperationContext.RootResolverMiddleware(ctx,
20001 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20002 }
20003
20004 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20005 case "infinity":
20006 field := field
20007
20008 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20009 defer func() {
20010 if r := recover(); r != nil {
20011 ec.Error(ctx, ec.Recover(ctx, r))
20012 }
20013 }()
20014 res = ec._Query_infinity(ctx, field)
20015 if res == graphql.Null {
20016 atomic.AddUint32(&fs.Invalids, 1)
20017 }
20018 return res
20019 }
20020
20021 rrm := func(ctx context.Context) graphql.Marshaler {
20022 return ec.OperationContext.RootResolverMiddleware(ctx,
20023 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20024 }
20025
20026 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20027 case "stringFromContextInterface":
20028 field := field
20029
20030 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20031 defer func() {
20032 if r := recover(); r != nil {
20033 ec.Error(ctx, ec.Recover(ctx, r))
20034 }
20035 }()
20036 res = ec._Query_stringFromContextInterface(ctx, field)
20037 if res == graphql.Null {
20038 atomic.AddUint32(&fs.Invalids, 1)
20039 }
20040 return res
20041 }
20042
20043 rrm := func(ctx context.Context) graphql.Marshaler {
20044 return ec.OperationContext.RootResolverMiddleware(ctx,
20045 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20046 }
20047
20048 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20049 case "stringFromContextFunction":
20050 field := field
20051
20052 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20053 defer func() {
20054 if r := recover(); r != nil {
20055 ec.Error(ctx, ec.Recover(ctx, r))
20056 }
20057 }()
20058 res = ec._Query_stringFromContextFunction(ctx, field)
20059 if res == graphql.Null {
20060 atomic.AddUint32(&fs.Invalids, 1)
20061 }
20062 return res
20063 }
20064
20065 rrm := func(ctx context.Context) graphql.Marshaler {
20066 return ec.OperationContext.RootResolverMiddleware(ctx,
20067 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20068 }
20069
20070 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20071 case "defaultScalar":
20072 field := field
20073
20074 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20075 defer func() {
20076 if r := recover(); r != nil {
20077 ec.Error(ctx, ec.Recover(ctx, r))
20078 }
20079 }()
20080 res = ec._Query_defaultScalar(ctx, field)
20081 if res == graphql.Null {
20082 atomic.AddUint32(&fs.Invalids, 1)
20083 }
20084 return res
20085 }
20086
20087 rrm := func(ctx context.Context) graphql.Marshaler {
20088 return ec.OperationContext.RootResolverMiddleware(ctx,
20089 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20090 }
20091
20092 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20093 case "slices":
20094 field := field
20095
20096 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20097 defer func() {
20098 if r := recover(); r != nil {
20099 ec.Error(ctx, ec.Recover(ctx, r))
20100 }
20101 }()
20102 res = ec._Query_slices(ctx, field)
20103 return res
20104 }
20105
20106 rrm := func(ctx context.Context) graphql.Marshaler {
20107 return ec.OperationContext.RootResolverMiddleware(ctx,
20108 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20109 }
20110
20111 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20112 case "scalarSlice":
20113 field := field
20114
20115 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20116 defer func() {
20117 if r := recover(); r != nil {
20118 ec.Error(ctx, ec.Recover(ctx, r))
20119 }
20120 }()
20121 res = ec._Query_scalarSlice(ctx, field)
20122 if res == graphql.Null {
20123 atomic.AddUint32(&fs.Invalids, 1)
20124 }
20125 return res
20126 }
20127
20128 rrm := func(ctx context.Context) graphql.Marshaler {
20129 return ec.OperationContext.RootResolverMiddleware(ctx,
20130 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20131 }
20132
20133 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20134 case "fallback":
20135 field := field
20136
20137 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20138 defer func() {
20139 if r := recover(); r != nil {
20140 ec.Error(ctx, ec.Recover(ctx, r))
20141 }
20142 }()
20143 res = ec._Query_fallback(ctx, field)
20144 if res == graphql.Null {
20145 atomic.AddUint32(&fs.Invalids, 1)
20146 }
20147 return res
20148 }
20149
20150 rrm := func(ctx context.Context) graphql.Marshaler {
20151 return ec.OperationContext.RootResolverMiddleware(ctx,
20152 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20153 }
20154
20155 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20156 case "optionalUnion":
20157 field := field
20158
20159 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20160 defer func() {
20161 if r := recover(); r != nil {
20162 ec.Error(ctx, ec.Recover(ctx, r))
20163 }
20164 }()
20165 res = ec._Query_optionalUnion(ctx, field)
20166 return res
20167 }
20168
20169 rrm := func(ctx context.Context) graphql.Marshaler {
20170 return ec.OperationContext.RootResolverMiddleware(ctx,
20171 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20172 }
20173
20174 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20175 case "vOkCaseValue":
20176 field := field
20177
20178 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20179 defer func() {
20180 if r := recover(); r != nil {
20181 ec.Error(ctx, ec.Recover(ctx, r))
20182 }
20183 }()
20184 res = ec._Query_vOkCaseValue(ctx, field)
20185 return res
20186 }
20187
20188 rrm := func(ctx context.Context) graphql.Marshaler {
20189 return ec.OperationContext.RootResolverMiddleware(ctx,
20190 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20191 }
20192
20193 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20194 case "vOkCaseNil":
20195 field := field
20196
20197 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20198 defer func() {
20199 if r := recover(); r != nil {
20200 ec.Error(ctx, ec.Recover(ctx, r))
20201 }
20202 }()
20203 res = ec._Query_vOkCaseNil(ctx, field)
20204 return res
20205 }
20206
20207 rrm := func(ctx context.Context) graphql.Marshaler {
20208 return ec.OperationContext.RootResolverMiddleware(ctx,
20209 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20210 }
20211
20212 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20213 case "validType":
20214 field := field
20215
20216 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20217 defer func() {
20218 if r := recover(); r != nil {
20219 ec.Error(ctx, ec.Recover(ctx, r))
20220 }
20221 }()
20222 res = ec._Query_validType(ctx, field)
20223 return res
20224 }
20225
20226 rrm := func(ctx context.Context) graphql.Marshaler {
20227 return ec.OperationContext.RootResolverMiddleware(ctx,
20228 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20229 }
20230
20231 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20232 case "variadicModel":
20233 field := field
20234
20235 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20236 defer func() {
20237 if r := recover(); r != nil {
20238 ec.Error(ctx, ec.Recover(ctx, r))
20239 }
20240 }()
20241 res = ec._Query_variadicModel(ctx, field)
20242 return res
20243 }
20244
20245 rrm := func(ctx context.Context) graphql.Marshaler {
20246 return ec.OperationContext.RootResolverMiddleware(ctx,
20247 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20248 }
20249
20250 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20251 case "wrappedStruct":
20252 field := field
20253
20254 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20255 defer func() {
20256 if r := recover(); r != nil {
20257 ec.Error(ctx, ec.Recover(ctx, r))
20258 }
20259 }()
20260 res = ec._Query_wrappedStruct(ctx, field)
20261 if res == graphql.Null {
20262 atomic.AddUint32(&fs.Invalids, 1)
20263 }
20264 return res
20265 }
20266
20267 rrm := func(ctx context.Context) graphql.Marshaler {
20268 return ec.OperationContext.RootResolverMiddleware(ctx,
20269 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20270 }
20271
20272 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20273 case "wrappedScalar":
20274 field := field
20275
20276 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20277 defer func() {
20278 if r := recover(); r != nil {
20279 ec.Error(ctx, ec.Recover(ctx, r))
20280 }
20281 }()
20282 res = ec._Query_wrappedScalar(ctx, field)
20283 if res == graphql.Null {
20284 atomic.AddUint32(&fs.Invalids, 1)
20285 }
20286 return res
20287 }
20288
20289 rrm := func(ctx context.Context) graphql.Marshaler {
20290 return ec.OperationContext.RootResolverMiddleware(ctx,
20291 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20292 }
20293
20294 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20295 case "wrappedMap":
20296 field := field
20297
20298 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20299 defer func() {
20300 if r := recover(); r != nil {
20301 ec.Error(ctx, ec.Recover(ctx, r))
20302 }
20303 }()
20304 res = ec._Query_wrappedMap(ctx, field)
20305 if res == graphql.Null {
20306 atomic.AddUint32(&fs.Invalids, 1)
20307 }
20308 return res
20309 }
20310
20311 rrm := func(ctx context.Context) graphql.Marshaler {
20312 return ec.OperationContext.RootResolverMiddleware(ctx,
20313 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20314 }
20315
20316 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20317 case "wrappedSlice":
20318 field := field
20319
20320 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20321 defer func() {
20322 if r := recover(); r != nil {
20323 ec.Error(ctx, ec.Recover(ctx, r))
20324 }
20325 }()
20326 res = ec._Query_wrappedSlice(ctx, field)
20327 if res == graphql.Null {
20328 atomic.AddUint32(&fs.Invalids, 1)
20329 }
20330 return res
20331 }
20332
20333 rrm := func(ctx context.Context) graphql.Marshaler {
20334 return ec.OperationContext.RootResolverMiddleware(ctx,
20335 func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20336 }
20337
20338 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
20339 case "__type":
20340 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
20341 return ec._Query___type(ctx, field)
20342 })
20343 case "__schema":
20344 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
20345 return ec._Query___schema(ctx, field)
20346 })
20347 default:
20348 panic("unknown field " + strconv.Quote(field.Name))
20349 }
20350 }
20351 out.Dispatch(ctx)
20352 if out.Invalids > 0 {
20353 return graphql.Null
20354 }
20355
20356 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
20357
20358 for label, dfs := range deferred {
20359 ec.processDeferredGroup(graphql.DeferredGroup{
20360 Label: label,
20361 Path: graphql.GetPath(ctx),
20362 FieldSet: dfs,
20363 Context: ctx,
20364 })
20365 }
20366
20367 return out
20368 }
20369
20370 var rectangleImplementors = []string{"Rectangle", "Shape", "ShapeUnion"}
20371
20372 func (ec *executionContext) _Rectangle(ctx context.Context, sel ast.SelectionSet, obj *Rectangle) graphql.Marshaler {
20373 fields := graphql.CollectFields(ec.OperationContext, sel, rectangleImplementors)
20374
20375 out := graphql.NewFieldSet(fields)
20376 deferred := make(map[string]*graphql.FieldSet)
20377 for i, field := range fields {
20378 switch field.Name {
20379 case "__typename":
20380 out.Values[i] = graphql.MarshalString("Rectangle")
20381 case "length":
20382 out.Values[i] = ec._Rectangle_length(ctx, field, obj)
20383 case "width":
20384 out.Values[i] = ec._Rectangle_width(ctx, field, obj)
20385 case "area":
20386 out.Values[i] = ec._Rectangle_area(ctx, field, obj)
20387 case "coordinates":
20388 out.Values[i] = ec._Rectangle_coordinates(ctx, field, obj)
20389 default:
20390 panic("unknown field " + strconv.Quote(field.Name))
20391 }
20392 }
20393 out.Dispatch(ctx)
20394 if out.Invalids > 0 {
20395 return graphql.Null
20396 }
20397
20398 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
20399
20400 for label, dfs := range deferred {
20401 ec.processDeferredGroup(graphql.DeferredGroup{
20402 Label: label,
20403 Path: graphql.GetPath(ctx),
20404 FieldSet: dfs,
20405 Context: ctx,
20406 })
20407 }
20408
20409 return out
20410 }
20411
20412 var sizeImplementors = []string{"Size"}
20413
20414 func (ec *executionContext) _Size(ctx context.Context, sel ast.SelectionSet, obj *Size) graphql.Marshaler {
20415 fields := graphql.CollectFields(ec.OperationContext, sel, sizeImplementors)
20416
20417 out := graphql.NewFieldSet(fields)
20418 deferred := make(map[string]*graphql.FieldSet)
20419 for i, field := range fields {
20420 switch field.Name {
20421 case "__typename":
20422 out.Values[i] = graphql.MarshalString("Size")
20423 case "height":
20424 out.Values[i] = ec._Size_height(ctx, field, obj)
20425 if out.Values[i] == graphql.Null {
20426 out.Invalids++
20427 }
20428 case "weight":
20429 out.Values[i] = ec._Size_weight(ctx, field, obj)
20430 if out.Values[i] == graphql.Null {
20431 out.Invalids++
20432 }
20433 default:
20434 panic("unknown field " + strconv.Quote(field.Name))
20435 }
20436 }
20437 out.Dispatch(ctx)
20438 if out.Invalids > 0 {
20439 return graphql.Null
20440 }
20441
20442 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
20443
20444 for label, dfs := range deferred {
20445 ec.processDeferredGroup(graphql.DeferredGroup{
20446 Label: label,
20447 Path: graphql.GetPath(ctx),
20448 FieldSet: dfs,
20449 Context: ctx,
20450 })
20451 }
20452
20453 return out
20454 }
20455
20456 var slicesImplementors = []string{"Slices"}
20457
20458 func (ec *executionContext) _Slices(ctx context.Context, sel ast.SelectionSet, obj *Slices) graphql.Marshaler {
20459 fields := graphql.CollectFields(ec.OperationContext, sel, slicesImplementors)
20460
20461 out := graphql.NewFieldSet(fields)
20462 deferred := make(map[string]*graphql.FieldSet)
20463 for i, field := range fields {
20464 switch field.Name {
20465 case "__typename":
20466 out.Values[i] = graphql.MarshalString("Slices")
20467 case "test1":
20468 out.Values[i] = ec._Slices_test1(ctx, field, obj)
20469 case "test2":
20470 out.Values[i] = ec._Slices_test2(ctx, field, obj)
20471 case "test3":
20472 out.Values[i] = ec._Slices_test3(ctx, field, obj)
20473 if out.Values[i] == graphql.Null {
20474 out.Invalids++
20475 }
20476 case "test4":
20477 out.Values[i] = ec._Slices_test4(ctx, field, obj)
20478 if out.Values[i] == graphql.Null {
20479 out.Invalids++
20480 }
20481 default:
20482 panic("unknown field " + strconv.Quote(field.Name))
20483 }
20484 }
20485 out.Dispatch(ctx)
20486 if out.Invalids > 0 {
20487 return graphql.Null
20488 }
20489
20490 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
20491
20492 for label, dfs := range deferred {
20493 ec.processDeferredGroup(graphql.DeferredGroup{
20494 Label: label,
20495 Path: graphql.GetPath(ctx),
20496 FieldSet: dfs,
20497 Context: ctx,
20498 })
20499 }
20500
20501 return out
20502 }
20503
20504 var subscriptionImplementors = []string{"Subscription"}
20505
20506 func (ec *executionContext) _Subscription(ctx context.Context, sel ast.SelectionSet) func(ctx context.Context) graphql.Marshaler {
20507 fields := graphql.CollectFields(ec.OperationContext, sel, subscriptionImplementors)
20508 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
20509 Object: "Subscription",
20510 })
20511 if len(fields) != 1 {
20512 ec.Errorf(ctx, "must subscribe to exactly one stream")
20513 return nil
20514 }
20515
20516 switch fields[0].Name {
20517 case "updated":
20518 return ec._Subscription_updated(ctx, fields[0])
20519 case "initPayload":
20520 return ec._Subscription_initPayload(ctx, fields[0])
20521 case "directiveArg":
20522 return ec._Subscription_directiveArg(ctx, fields[0])
20523 case "directiveNullableArg":
20524 return ec._Subscription_directiveNullableArg(ctx, fields[0])
20525 case "directiveDouble":
20526 return ec._Subscription_directiveDouble(ctx, fields[0])
20527 case "directiveUnimplemented":
20528 return ec._Subscription_directiveUnimplemented(ctx, fields[0])
20529 case "issue896b":
20530 return ec._Subscription_issue896b(ctx, fields[0])
20531 case "errorRequired":
20532 return ec._Subscription_errorRequired(ctx, fields[0])
20533 default:
20534 panic("unknown field " + strconv.Quote(fields[0].Name))
20535 }
20536 }
20537
20538 var userImplementors = []string{"User"}
20539
20540 func (ec *executionContext) _User(ctx context.Context, sel ast.SelectionSet, obj *User) graphql.Marshaler {
20541 fields := graphql.CollectFields(ec.OperationContext, sel, userImplementors)
20542
20543 out := graphql.NewFieldSet(fields)
20544 deferred := make(map[string]*graphql.FieldSet)
20545 for i, field := range fields {
20546 switch field.Name {
20547 case "__typename":
20548 out.Values[i] = graphql.MarshalString("User")
20549 case "id":
20550 out.Values[i] = ec._User_id(ctx, field, obj)
20551 if out.Values[i] == graphql.Null {
20552 atomic.AddUint32(&out.Invalids, 1)
20553 }
20554 case "friends":
20555 field := field
20556
20557 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20558 defer func() {
20559 if r := recover(); r != nil {
20560 ec.Error(ctx, ec.Recover(ctx, r))
20561 }
20562 }()
20563 res = ec._User_friends(ctx, field, obj)
20564 if res == graphql.Null {
20565 atomic.AddUint32(&fs.Invalids, 1)
20566 }
20567 return res
20568 }
20569
20570 if field.Deferrable != nil {
20571 dfs, ok := deferred[field.Deferrable.Label]
20572 di := 0
20573 if ok {
20574 dfs.AddField(field)
20575 di = len(dfs.Values) - 1
20576 } else {
20577 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
20578 deferred[field.Deferrable.Label] = dfs
20579 }
20580 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
20581 return innerFunc(ctx, dfs)
20582 })
20583
20584
20585 out.Values[i] = graphql.Null
20586 continue
20587 }
20588
20589 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20590 case "created":
20591 out.Values[i] = ec._User_created(ctx, field, obj)
20592 if out.Values[i] == graphql.Null {
20593 atomic.AddUint32(&out.Invalids, 1)
20594 }
20595 case "updated":
20596 out.Values[i] = ec._User_updated(ctx, field, obj)
20597 case "pets":
20598 field := field
20599
20600 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20601 defer func() {
20602 if r := recover(); r != nil {
20603 ec.Error(ctx, ec.Recover(ctx, r))
20604 }
20605 }()
20606 res = ec._User_pets(ctx, field, obj)
20607 return res
20608 }
20609
20610 if field.Deferrable != nil {
20611 dfs, ok := deferred[field.Deferrable.Label]
20612 di := 0
20613 if ok {
20614 dfs.AddField(field)
20615 di = len(dfs.Values) - 1
20616 } else {
20617 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
20618 deferred[field.Deferrable.Label] = dfs
20619 }
20620 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
20621 return innerFunc(ctx, dfs)
20622 })
20623
20624
20625 out.Values[i] = graphql.Null
20626 continue
20627 }
20628
20629 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20630 default:
20631 panic("unknown field " + strconv.Quote(field.Name))
20632 }
20633 }
20634 out.Dispatch(ctx)
20635 if out.Invalids > 0 {
20636 return graphql.Null
20637 }
20638
20639 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
20640
20641 for label, dfs := range deferred {
20642 ec.processDeferredGroup(graphql.DeferredGroup{
20643 Label: label,
20644 Path: graphql.GetPath(ctx),
20645 FieldSet: dfs,
20646 Context: ctx,
20647 })
20648 }
20649
20650 return out
20651 }
20652
20653 var vOkCaseNilImplementors = []string{"VOkCaseNil"}
20654
20655 func (ec *executionContext) _VOkCaseNil(ctx context.Context, sel ast.SelectionSet, obj *VOkCaseNil) graphql.Marshaler {
20656 fields := graphql.CollectFields(ec.OperationContext, sel, vOkCaseNilImplementors)
20657
20658 out := graphql.NewFieldSet(fields)
20659 deferred := make(map[string]*graphql.FieldSet)
20660 for i, field := range fields {
20661 switch field.Name {
20662 case "__typename":
20663 out.Values[i] = graphql.MarshalString("VOkCaseNil")
20664 case "value":
20665 out.Values[i] = ec._VOkCaseNil_value(ctx, field, obj)
20666 default:
20667 panic("unknown field " + strconv.Quote(field.Name))
20668 }
20669 }
20670 out.Dispatch(ctx)
20671 if out.Invalids > 0 {
20672 return graphql.Null
20673 }
20674
20675 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
20676
20677 for label, dfs := range deferred {
20678 ec.processDeferredGroup(graphql.DeferredGroup{
20679 Label: label,
20680 Path: graphql.GetPath(ctx),
20681 FieldSet: dfs,
20682 Context: ctx,
20683 })
20684 }
20685
20686 return out
20687 }
20688
20689 var vOkCaseValueImplementors = []string{"VOkCaseValue"}
20690
20691 func (ec *executionContext) _VOkCaseValue(ctx context.Context, sel ast.SelectionSet, obj *VOkCaseValue) graphql.Marshaler {
20692 fields := graphql.CollectFields(ec.OperationContext, sel, vOkCaseValueImplementors)
20693
20694 out := graphql.NewFieldSet(fields)
20695 deferred := make(map[string]*graphql.FieldSet)
20696 for i, field := range fields {
20697 switch field.Name {
20698 case "__typename":
20699 out.Values[i] = graphql.MarshalString("VOkCaseValue")
20700 case "value":
20701 out.Values[i] = ec._VOkCaseValue_value(ctx, field, obj)
20702 default:
20703 panic("unknown field " + strconv.Quote(field.Name))
20704 }
20705 }
20706 out.Dispatch(ctx)
20707 if out.Invalids > 0 {
20708 return graphql.Null
20709 }
20710
20711 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
20712
20713 for label, dfs := range deferred {
20714 ec.processDeferredGroup(graphql.DeferredGroup{
20715 Label: label,
20716 Path: graphql.GetPath(ctx),
20717 FieldSet: dfs,
20718 Context: ctx,
20719 })
20720 }
20721
20722 return out
20723 }
20724
20725 var validTypeImplementors = []string{"ValidType"}
20726
20727 func (ec *executionContext) _ValidType(ctx context.Context, sel ast.SelectionSet, obj *ValidType) graphql.Marshaler {
20728 fields := graphql.CollectFields(ec.OperationContext, sel, validTypeImplementors)
20729
20730 out := graphql.NewFieldSet(fields)
20731 deferred := make(map[string]*graphql.FieldSet)
20732 for i, field := range fields {
20733 switch field.Name {
20734 case "__typename":
20735 out.Values[i] = graphql.MarshalString("ValidType")
20736 case "differentCase":
20737 out.Values[i] = ec._ValidType_differentCase(ctx, field, obj)
20738 if out.Values[i] == graphql.Null {
20739 out.Invalids++
20740 }
20741 case "different_case":
20742 out.Values[i] = ec._ValidType_different_case(ctx, field, obj)
20743 if out.Values[i] == graphql.Null {
20744 out.Invalids++
20745 }
20746 case "validInputKeywords":
20747 out.Values[i] = ec._ValidType_validInputKeywords(ctx, field, obj)
20748 if out.Values[i] == graphql.Null {
20749 out.Invalids++
20750 }
20751 case "validArgs":
20752 out.Values[i] = ec._ValidType_validArgs(ctx, field, obj)
20753 if out.Values[i] == graphql.Null {
20754 out.Invalids++
20755 }
20756 default:
20757 panic("unknown field " + strconv.Quote(field.Name))
20758 }
20759 }
20760 out.Dispatch(ctx)
20761 if out.Invalids > 0 {
20762 return graphql.Null
20763 }
20764
20765 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
20766
20767 for label, dfs := range deferred {
20768 ec.processDeferredGroup(graphql.DeferredGroup{
20769 Label: label,
20770 Path: graphql.GetPath(ctx),
20771 FieldSet: dfs,
20772 Context: ctx,
20773 })
20774 }
20775
20776 return out
20777 }
20778
20779 var variadicModelImplementors = []string{"VariadicModel"}
20780
20781 func (ec *executionContext) _VariadicModel(ctx context.Context, sel ast.SelectionSet, obj *VariadicModel) graphql.Marshaler {
20782 fields := graphql.CollectFields(ec.OperationContext, sel, variadicModelImplementors)
20783
20784 out := graphql.NewFieldSet(fields)
20785 deferred := make(map[string]*graphql.FieldSet)
20786 for i, field := range fields {
20787 switch field.Name {
20788 case "__typename":
20789 out.Values[i] = graphql.MarshalString("VariadicModel")
20790 case "value":
20791 field := field
20792
20793 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20794 defer func() {
20795 if r := recover(); r != nil {
20796 ec.Error(ctx, ec.Recover(ctx, r))
20797 }
20798 }()
20799 res = ec._VariadicModel_value(ctx, field, obj)
20800 return res
20801 }
20802
20803 if field.Deferrable != nil {
20804 dfs, ok := deferred[field.Deferrable.Label]
20805 di := 0
20806 if ok {
20807 dfs.AddField(field)
20808 di = len(dfs.Values) - 1
20809 } else {
20810 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
20811 deferred[field.Deferrable.Label] = dfs
20812 }
20813 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
20814 return innerFunc(ctx, dfs)
20815 })
20816
20817
20818 out.Values[i] = graphql.Null
20819 continue
20820 }
20821
20822 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20823 default:
20824 panic("unknown field " + strconv.Quote(field.Name))
20825 }
20826 }
20827 out.Dispatch(ctx)
20828 if out.Invalids > 0 {
20829 return graphql.Null
20830 }
20831
20832 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
20833
20834 for label, dfs := range deferred {
20835 ec.processDeferredGroup(graphql.DeferredGroup{
20836 Label: label,
20837 Path: graphql.GetPath(ctx),
20838 FieldSet: dfs,
20839 Context: ctx,
20840 })
20841 }
20842
20843 return out
20844 }
20845
20846 var wrappedMapImplementors = []string{"WrappedMap"}
20847
20848 func (ec *executionContext) _WrappedMap(ctx context.Context, sel ast.SelectionSet, obj WrappedMap) graphql.Marshaler {
20849 fields := graphql.CollectFields(ec.OperationContext, sel, wrappedMapImplementors)
20850
20851 out := graphql.NewFieldSet(fields)
20852 deferred := make(map[string]*graphql.FieldSet)
20853 for i, field := range fields {
20854 switch field.Name {
20855 case "__typename":
20856 out.Values[i] = graphql.MarshalString("WrappedMap")
20857 case "get":
20858 field := field
20859
20860 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20861 defer func() {
20862 if r := recover(); r != nil {
20863 ec.Error(ctx, ec.Recover(ctx, r))
20864 }
20865 }()
20866 res = ec._WrappedMap_get(ctx, field, obj)
20867 if res == graphql.Null {
20868 atomic.AddUint32(&fs.Invalids, 1)
20869 }
20870 return res
20871 }
20872
20873 if field.Deferrable != nil {
20874 dfs, ok := deferred[field.Deferrable.Label]
20875 di := 0
20876 if ok {
20877 dfs.AddField(field)
20878 di = len(dfs.Values) - 1
20879 } else {
20880 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
20881 deferred[field.Deferrable.Label] = dfs
20882 }
20883 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
20884 return innerFunc(ctx, dfs)
20885 })
20886
20887
20888 out.Values[i] = graphql.Null
20889 continue
20890 }
20891
20892 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20893 default:
20894 panic("unknown field " + strconv.Quote(field.Name))
20895 }
20896 }
20897 out.Dispatch(ctx)
20898 if out.Invalids > 0 {
20899 return graphql.Null
20900 }
20901
20902 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
20903
20904 for label, dfs := range deferred {
20905 ec.processDeferredGroup(graphql.DeferredGroup{
20906 Label: label,
20907 Path: graphql.GetPath(ctx),
20908 FieldSet: dfs,
20909 Context: ctx,
20910 })
20911 }
20912
20913 return out
20914 }
20915
20916 var wrappedSliceImplementors = []string{"WrappedSlice"}
20917
20918 func (ec *executionContext) _WrappedSlice(ctx context.Context, sel ast.SelectionSet, obj WrappedSlice) graphql.Marshaler {
20919 fields := graphql.CollectFields(ec.OperationContext, sel, wrappedSliceImplementors)
20920
20921 out := graphql.NewFieldSet(fields)
20922 deferred := make(map[string]*graphql.FieldSet)
20923 for i, field := range fields {
20924 switch field.Name {
20925 case "__typename":
20926 out.Values[i] = graphql.MarshalString("WrappedSlice")
20927 case "get":
20928 field := field
20929
20930 innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
20931 defer func() {
20932 if r := recover(); r != nil {
20933 ec.Error(ctx, ec.Recover(ctx, r))
20934 }
20935 }()
20936 res = ec._WrappedSlice_get(ctx, field, obj)
20937 if res == graphql.Null {
20938 atomic.AddUint32(&fs.Invalids, 1)
20939 }
20940 return res
20941 }
20942
20943 if field.Deferrable != nil {
20944 dfs, ok := deferred[field.Deferrable.Label]
20945 di := 0
20946 if ok {
20947 dfs.AddField(field)
20948 di = len(dfs.Values) - 1
20949 } else {
20950 dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
20951 deferred[field.Deferrable.Label] = dfs
20952 }
20953 dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
20954 return innerFunc(ctx, dfs)
20955 })
20956
20957
20958 out.Values[i] = graphql.Null
20959 continue
20960 }
20961
20962 out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
20963 default:
20964 panic("unknown field " + strconv.Quote(field.Name))
20965 }
20966 }
20967 out.Dispatch(ctx)
20968 if out.Invalids > 0 {
20969 return graphql.Null
20970 }
20971
20972 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
20973
20974 for label, dfs := range deferred {
20975 ec.processDeferredGroup(graphql.DeferredGroup{
20976 Label: label,
20977 Path: graphql.GetPath(ctx),
20978 FieldSet: dfs,
20979 Context: ctx,
20980 })
20981 }
20982
20983 return out
20984 }
20985
20986 var wrappedStructImplementors = []string{"WrappedStruct"}
20987
20988 func (ec *executionContext) _WrappedStruct(ctx context.Context, sel ast.SelectionSet, obj *WrappedStruct) graphql.Marshaler {
20989 fields := graphql.CollectFields(ec.OperationContext, sel, wrappedStructImplementors)
20990
20991 out := graphql.NewFieldSet(fields)
20992 deferred := make(map[string]*graphql.FieldSet)
20993 for i, field := range fields {
20994 switch field.Name {
20995 case "__typename":
20996 out.Values[i] = graphql.MarshalString("WrappedStruct")
20997 case "name":
20998 out.Values[i] = ec._WrappedStruct_name(ctx, field, obj)
20999 if out.Values[i] == graphql.Null {
21000 out.Invalids++
21001 }
21002 case "desc":
21003 out.Values[i] = ec._WrappedStruct_desc(ctx, field, obj)
21004 default:
21005 panic("unknown field " + strconv.Quote(field.Name))
21006 }
21007 }
21008 out.Dispatch(ctx)
21009 if out.Invalids > 0 {
21010 return graphql.Null
21011 }
21012
21013 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
21014
21015 for label, dfs := range deferred {
21016 ec.processDeferredGroup(graphql.DeferredGroup{
21017 Label: label,
21018 Path: graphql.GetPath(ctx),
21019 FieldSet: dfs,
21020 Context: ctx,
21021 })
21022 }
21023
21024 return out
21025 }
21026
21027 var xXItImplementors = []string{"XXIt"}
21028
21029 func (ec *executionContext) _XXIt(ctx context.Context, sel ast.SelectionSet, obj *XXIt) graphql.Marshaler {
21030 fields := graphql.CollectFields(ec.OperationContext, sel, xXItImplementors)
21031
21032 out := graphql.NewFieldSet(fields)
21033 deferred := make(map[string]*graphql.FieldSet)
21034 for i, field := range fields {
21035 switch field.Name {
21036 case "__typename":
21037 out.Values[i] = graphql.MarshalString("XXIt")
21038 case "id":
21039 out.Values[i] = ec._XXIt_id(ctx, field, obj)
21040 if out.Values[i] == graphql.Null {
21041 out.Invalids++
21042 }
21043 default:
21044 panic("unknown field " + strconv.Quote(field.Name))
21045 }
21046 }
21047 out.Dispatch(ctx)
21048 if out.Invalids > 0 {
21049 return graphql.Null
21050 }
21051
21052 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
21053
21054 for label, dfs := range deferred {
21055 ec.processDeferredGroup(graphql.DeferredGroup{
21056 Label: label,
21057 Path: graphql.GetPath(ctx),
21058 FieldSet: dfs,
21059 Context: ctx,
21060 })
21061 }
21062
21063 return out
21064 }
21065
21066 var xxItImplementors = []string{"XxIt"}
21067
21068 func (ec *executionContext) _XxIt(ctx context.Context, sel ast.SelectionSet, obj *XxIt) graphql.Marshaler {
21069 fields := graphql.CollectFields(ec.OperationContext, sel, xxItImplementors)
21070
21071 out := graphql.NewFieldSet(fields)
21072 deferred := make(map[string]*graphql.FieldSet)
21073 for i, field := range fields {
21074 switch field.Name {
21075 case "__typename":
21076 out.Values[i] = graphql.MarshalString("XxIt")
21077 case "id":
21078 out.Values[i] = ec._XxIt_id(ctx, field, obj)
21079 if out.Values[i] == graphql.Null {
21080 out.Invalids++
21081 }
21082 default:
21083 panic("unknown field " + strconv.Quote(field.Name))
21084 }
21085 }
21086 out.Dispatch(ctx)
21087 if out.Invalids > 0 {
21088 return graphql.Null
21089 }
21090
21091 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
21092
21093 for label, dfs := range deferred {
21094 ec.processDeferredGroup(graphql.DeferredGroup{
21095 Label: label,
21096 Path: graphql.GetPath(ctx),
21097 FieldSet: dfs,
21098 Context: ctx,
21099 })
21100 }
21101
21102 return out
21103 }
21104
21105 var __DirectiveImplementors = []string{"__Directive"}
21106
21107 func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
21108 fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
21109
21110 out := graphql.NewFieldSet(fields)
21111 deferred := make(map[string]*graphql.FieldSet)
21112 for i, field := range fields {
21113 switch field.Name {
21114 case "__typename":
21115 out.Values[i] = graphql.MarshalString("__Directive")
21116 case "name":
21117 out.Values[i] = ec.___Directive_name(ctx, field, obj)
21118 if out.Values[i] == graphql.Null {
21119 out.Invalids++
21120 }
21121 case "description":
21122 out.Values[i] = ec.___Directive_description(ctx, field, obj)
21123 case "locations":
21124 out.Values[i] = ec.___Directive_locations(ctx, field, obj)
21125 if out.Values[i] == graphql.Null {
21126 out.Invalids++
21127 }
21128 case "args":
21129 out.Values[i] = ec.___Directive_args(ctx, field, obj)
21130 if out.Values[i] == graphql.Null {
21131 out.Invalids++
21132 }
21133 case "isRepeatable":
21134 out.Values[i] = ec.___Directive_isRepeatable(ctx, field, obj)
21135 if out.Values[i] == graphql.Null {
21136 out.Invalids++
21137 }
21138 default:
21139 panic("unknown field " + strconv.Quote(field.Name))
21140 }
21141 }
21142 out.Dispatch(ctx)
21143 if out.Invalids > 0 {
21144 return graphql.Null
21145 }
21146
21147 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
21148
21149 for label, dfs := range deferred {
21150 ec.processDeferredGroup(graphql.DeferredGroup{
21151 Label: label,
21152 Path: graphql.GetPath(ctx),
21153 FieldSet: dfs,
21154 Context: ctx,
21155 })
21156 }
21157
21158 return out
21159 }
21160
21161 var __EnumValueImplementors = []string{"__EnumValue"}
21162
21163 func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
21164 fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
21165
21166 out := graphql.NewFieldSet(fields)
21167 deferred := make(map[string]*graphql.FieldSet)
21168 for i, field := range fields {
21169 switch field.Name {
21170 case "__typename":
21171 out.Values[i] = graphql.MarshalString("__EnumValue")
21172 case "name":
21173 out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
21174 if out.Values[i] == graphql.Null {
21175 out.Invalids++
21176 }
21177 case "description":
21178 out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
21179 case "isDeprecated":
21180 out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
21181 if out.Values[i] == graphql.Null {
21182 out.Invalids++
21183 }
21184 case "deprecationReason":
21185 out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
21186 default:
21187 panic("unknown field " + strconv.Quote(field.Name))
21188 }
21189 }
21190 out.Dispatch(ctx)
21191 if out.Invalids > 0 {
21192 return graphql.Null
21193 }
21194
21195 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
21196
21197 for label, dfs := range deferred {
21198 ec.processDeferredGroup(graphql.DeferredGroup{
21199 Label: label,
21200 Path: graphql.GetPath(ctx),
21201 FieldSet: dfs,
21202 Context: ctx,
21203 })
21204 }
21205
21206 return out
21207 }
21208
21209 var __FieldImplementors = []string{"__Field"}
21210
21211 func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
21212 fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
21213
21214 out := graphql.NewFieldSet(fields)
21215 deferred := make(map[string]*graphql.FieldSet)
21216 for i, field := range fields {
21217 switch field.Name {
21218 case "__typename":
21219 out.Values[i] = graphql.MarshalString("__Field")
21220 case "name":
21221 out.Values[i] = ec.___Field_name(ctx, field, obj)
21222 if out.Values[i] == graphql.Null {
21223 out.Invalids++
21224 }
21225 case "description":
21226 out.Values[i] = ec.___Field_description(ctx, field, obj)
21227 case "args":
21228 out.Values[i] = ec.___Field_args(ctx, field, obj)
21229 if out.Values[i] == graphql.Null {
21230 out.Invalids++
21231 }
21232 case "type":
21233 out.Values[i] = ec.___Field_type(ctx, field, obj)
21234 if out.Values[i] == graphql.Null {
21235 out.Invalids++
21236 }
21237 case "isDeprecated":
21238 out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
21239 if out.Values[i] == graphql.Null {
21240 out.Invalids++
21241 }
21242 case "deprecationReason":
21243 out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
21244 default:
21245 panic("unknown field " + strconv.Quote(field.Name))
21246 }
21247 }
21248 out.Dispatch(ctx)
21249 if out.Invalids > 0 {
21250 return graphql.Null
21251 }
21252
21253 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
21254
21255 for label, dfs := range deferred {
21256 ec.processDeferredGroup(graphql.DeferredGroup{
21257 Label: label,
21258 Path: graphql.GetPath(ctx),
21259 FieldSet: dfs,
21260 Context: ctx,
21261 })
21262 }
21263
21264 return out
21265 }
21266
21267 var __InputValueImplementors = []string{"__InputValue"}
21268
21269 func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
21270 fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
21271
21272 out := graphql.NewFieldSet(fields)
21273 deferred := make(map[string]*graphql.FieldSet)
21274 for i, field := range fields {
21275 switch field.Name {
21276 case "__typename":
21277 out.Values[i] = graphql.MarshalString("__InputValue")
21278 case "name":
21279 out.Values[i] = ec.___InputValue_name(ctx, field, obj)
21280 if out.Values[i] == graphql.Null {
21281 out.Invalids++
21282 }
21283 case "description":
21284 out.Values[i] = ec.___InputValue_description(ctx, field, obj)
21285 case "type":
21286 out.Values[i] = ec.___InputValue_type(ctx, field, obj)
21287 if out.Values[i] == graphql.Null {
21288 out.Invalids++
21289 }
21290 case "defaultValue":
21291 out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
21292 default:
21293 panic("unknown field " + strconv.Quote(field.Name))
21294 }
21295 }
21296 out.Dispatch(ctx)
21297 if out.Invalids > 0 {
21298 return graphql.Null
21299 }
21300
21301 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
21302
21303 for label, dfs := range deferred {
21304 ec.processDeferredGroup(graphql.DeferredGroup{
21305 Label: label,
21306 Path: graphql.GetPath(ctx),
21307 FieldSet: dfs,
21308 Context: ctx,
21309 })
21310 }
21311
21312 return out
21313 }
21314
21315 var __SchemaImplementors = []string{"__Schema"}
21316
21317 func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
21318 fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
21319
21320 out := graphql.NewFieldSet(fields)
21321 deferred := make(map[string]*graphql.FieldSet)
21322 for i, field := range fields {
21323 switch field.Name {
21324 case "__typename":
21325 out.Values[i] = graphql.MarshalString("__Schema")
21326 case "description":
21327 out.Values[i] = ec.___Schema_description(ctx, field, obj)
21328 case "types":
21329 out.Values[i] = ec.___Schema_types(ctx, field, obj)
21330 if out.Values[i] == graphql.Null {
21331 out.Invalids++
21332 }
21333 case "queryType":
21334 out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
21335 if out.Values[i] == graphql.Null {
21336 out.Invalids++
21337 }
21338 case "mutationType":
21339 out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
21340 case "subscriptionType":
21341 out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
21342 case "directives":
21343 out.Values[i] = ec.___Schema_directives(ctx, field, obj)
21344 if out.Values[i] == graphql.Null {
21345 out.Invalids++
21346 }
21347 default:
21348 panic("unknown field " + strconv.Quote(field.Name))
21349 }
21350 }
21351 out.Dispatch(ctx)
21352 if out.Invalids > 0 {
21353 return graphql.Null
21354 }
21355
21356 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
21357
21358 for label, dfs := range deferred {
21359 ec.processDeferredGroup(graphql.DeferredGroup{
21360 Label: label,
21361 Path: graphql.GetPath(ctx),
21362 FieldSet: dfs,
21363 Context: ctx,
21364 })
21365 }
21366
21367 return out
21368 }
21369
21370 var __TypeImplementors = []string{"__Type"}
21371
21372 func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
21373 fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
21374
21375 out := graphql.NewFieldSet(fields)
21376 deferred := make(map[string]*graphql.FieldSet)
21377 for i, field := range fields {
21378 switch field.Name {
21379 case "__typename":
21380 out.Values[i] = graphql.MarshalString("__Type")
21381 case "kind":
21382 out.Values[i] = ec.___Type_kind(ctx, field, obj)
21383 if out.Values[i] == graphql.Null {
21384 out.Invalids++
21385 }
21386 case "name":
21387 out.Values[i] = ec.___Type_name(ctx, field, obj)
21388 case "description":
21389 out.Values[i] = ec.___Type_description(ctx, field, obj)
21390 case "fields":
21391 out.Values[i] = ec.___Type_fields(ctx, field, obj)
21392 case "interfaces":
21393 out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
21394 case "possibleTypes":
21395 out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
21396 case "enumValues":
21397 out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
21398 case "inputFields":
21399 out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
21400 case "ofType":
21401 out.Values[i] = ec.___Type_ofType(ctx, field, obj)
21402 case "specifiedByURL":
21403 out.Values[i] = ec.___Type_specifiedByURL(ctx, field, obj)
21404 default:
21405 panic("unknown field " + strconv.Quote(field.Name))
21406 }
21407 }
21408 out.Dispatch(ctx)
21409 if out.Invalids > 0 {
21410 return graphql.Null
21411 }
21412
21413 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
21414
21415 for label, dfs := range deferred {
21416 ec.processDeferredGroup(graphql.DeferredGroup{
21417 Label: label,
21418 Path: graphql.GetPath(ctx),
21419 FieldSet: dfs,
21420 Context: ctx,
21421 })
21422 }
21423
21424 return out
21425 }
21426
21427 var asdfItImplementors = []string{"asdfIt"}
21428
21429 func (ec *executionContext) _asdfIt(ctx context.Context, sel ast.SelectionSet, obj *AsdfIt) graphql.Marshaler {
21430 fields := graphql.CollectFields(ec.OperationContext, sel, asdfItImplementors)
21431
21432 out := graphql.NewFieldSet(fields)
21433 deferred := make(map[string]*graphql.FieldSet)
21434 for i, field := range fields {
21435 switch field.Name {
21436 case "__typename":
21437 out.Values[i] = graphql.MarshalString("asdfIt")
21438 case "id":
21439 out.Values[i] = ec._asdfIt_id(ctx, field, obj)
21440 if out.Values[i] == graphql.Null {
21441 out.Invalids++
21442 }
21443 default:
21444 panic("unknown field " + strconv.Quote(field.Name))
21445 }
21446 }
21447 out.Dispatch(ctx)
21448 if out.Invalids > 0 {
21449 return graphql.Null
21450 }
21451
21452 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
21453
21454 for label, dfs := range deferred {
21455 ec.processDeferredGroup(graphql.DeferredGroup{
21456 Label: label,
21457 Path: graphql.GetPath(ctx),
21458 FieldSet: dfs,
21459 Context: ctx,
21460 })
21461 }
21462
21463 return out
21464 }
21465
21466 var iItImplementors = []string{"iIt"}
21467
21468 func (ec *executionContext) _iIt(ctx context.Context, sel ast.SelectionSet, obj *IIt) graphql.Marshaler {
21469 fields := graphql.CollectFields(ec.OperationContext, sel, iItImplementors)
21470
21471 out := graphql.NewFieldSet(fields)
21472 deferred := make(map[string]*graphql.FieldSet)
21473 for i, field := range fields {
21474 switch field.Name {
21475 case "__typename":
21476 out.Values[i] = graphql.MarshalString("iIt")
21477 case "id":
21478 out.Values[i] = ec._iIt_id(ctx, field, obj)
21479 if out.Values[i] == graphql.Null {
21480 out.Invalids++
21481 }
21482 default:
21483 panic("unknown field " + strconv.Quote(field.Name))
21484 }
21485 }
21486 out.Dispatch(ctx)
21487 if out.Invalids > 0 {
21488 return graphql.Null
21489 }
21490
21491 atomic.AddInt32(&ec.deferred, int32(len(deferred)))
21492
21493 for label, dfs := range deferred {
21494 ec.processDeferredGroup(graphql.DeferredGroup{
21495 Label: label,
21496 Path: graphql.GetPath(ctx),
21497 FieldSet: dfs,
21498 Context: ctx,
21499 })
21500 }
21501
21502 return out
21503 }
21504
21505
21506
21507
21508
21509 func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
21510 res, err := graphql.UnmarshalBoolean(v)
21511 return res, graphql.ErrorOnPath(ctx, err)
21512 }
21513
21514 func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
21515 res := graphql.MarshalBoolean(v)
21516 if res == graphql.Null {
21517 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21518 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21519 }
21520 }
21521 return res
21522 }
21523
21524 func (ec *executionContext) unmarshalNBytes2ᚕbyte(ctx context.Context, v interface{}) ([]byte, error) {
21525 res, err := UnmarshalBytes(v)
21526 return res, graphql.ErrorOnPath(ctx, err)
21527 }
21528
21529 func (ec *executionContext) marshalNBytes2ᚕbyte(ctx context.Context, sel ast.SelectionSet, v []byte) graphql.Marshaler {
21530 if v == nil {
21531 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21532 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21533 }
21534 return graphql.Null
21535 }
21536 res := MarshalBytes(v)
21537 if res == graphql.Null {
21538 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21539 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21540 }
21541 }
21542 return res
21543 }
21544
21545 func (ec *executionContext) marshalNCheckIssue8962ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCheckIssue896(ctx context.Context, sel ast.SelectionSet, v *CheckIssue896) graphql.Marshaler {
21546 if v == nil {
21547 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21548 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21549 }
21550 return graphql.Null
21551 }
21552 return ec._CheckIssue896(ctx, sel, v)
21553 }
21554
21555 func (ec *executionContext) unmarshalNCustomScalar2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCustomScalar(ctx context.Context, v interface{}) (CustomScalar, error) {
21556 var res CustomScalar
21557 err := res.UnmarshalGQL(v)
21558 return res, graphql.ErrorOnPath(ctx, err)
21559 }
21560
21561 func (ec *executionContext) marshalNCustomScalar2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCustomScalar(ctx context.Context, sel ast.SelectionSet, v CustomScalar) graphql.Marshaler {
21562 return v
21563 }
21564
21565 func (ec *executionContext) unmarshalNDefaultInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐDefaultInput(ctx context.Context, v interface{}) (DefaultInput, error) {
21566 res, err := ec.unmarshalInputDefaultInput(ctx, v)
21567 return res, graphql.ErrorOnPath(ctx, err)
21568 }
21569
21570 func (ec *executionContext) marshalNDefaultParametersMirror2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐDefaultParametersMirror(ctx context.Context, sel ast.SelectionSet, v DefaultParametersMirror) graphql.Marshaler {
21571 return ec._DefaultParametersMirror(ctx, sel, &v)
21572 }
21573
21574 func (ec *executionContext) marshalNDefaultParametersMirror2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐDefaultParametersMirror(ctx context.Context, sel ast.SelectionSet, v *DefaultParametersMirror) graphql.Marshaler {
21575 if v == nil {
21576 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21577 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21578 }
21579 return graphql.Null
21580 }
21581 return ec._DefaultParametersMirror(ctx, sel, v)
21582 }
21583
21584 func (ec *executionContext) unmarshalNDefaultScalarImplementation2string(ctx context.Context, v interface{}) (string, error) {
21585 res, err := graphql.UnmarshalString(v)
21586 return res, graphql.ErrorOnPath(ctx, err)
21587 }
21588
21589 func (ec *executionContext) marshalNDefaultScalarImplementation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
21590 res := graphql.MarshalString(v)
21591 if res == graphql.Null {
21592 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21593 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21594 }
21595 }
21596 return res
21597 }
21598
21599 func (ec *executionContext) marshalNDeferModel2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐDeferModel(ctx context.Context, sel ast.SelectionSet, v *DeferModel) graphql.Marshaler {
21600 if v == nil {
21601 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21602 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21603 }
21604 return graphql.Null
21605 }
21606 return ec._DeferModel(ctx, sel, v)
21607 }
21608
21609 func (ec *executionContext) unmarshalNEmail2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐEmail(ctx context.Context, v interface{}) (Email, error) {
21610 var res Email
21611 err := res.UnmarshalGQL(v)
21612 return res, graphql.ErrorOnPath(ctx, err)
21613 }
21614
21615 func (ec *executionContext) marshalNEmail2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐEmail(ctx context.Context, sel ast.SelectionSet, v Email) graphql.Marshaler {
21616 return v
21617 }
21618
21619 func (ec *executionContext) unmarshalNEnumTest2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐEnumTest(ctx context.Context, v interface{}) (EnumTest, error) {
21620 var res EnumTest
21621 err := res.UnmarshalGQL(v)
21622 return res, graphql.ErrorOnPath(ctx, err)
21623 }
21624
21625 func (ec *executionContext) marshalNEnumTest2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐEnumTest(ctx context.Context, sel ast.SelectionSet, v EnumTest) graphql.Marshaler {
21626 return v
21627 }
21628
21629 func (ec *executionContext) marshalNError2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐError(ctx context.Context, sel ast.SelectionSet, v Error) graphql.Marshaler {
21630 return ec._Error(ctx, sel, &v)
21631 }
21632
21633 func (ec *executionContext) marshalNError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐError(ctx context.Context, sel ast.SelectionSet, v *Error) graphql.Marshaler {
21634 if v == nil {
21635 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21636 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21637 }
21638 return graphql.Null
21639 }
21640 return ec._Error(ctx, sel, v)
21641 }
21642
21643 func (ec *executionContext) unmarshalNFallbackToStringEncoding2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐFallbackToStringEncoding(ctx context.Context, v interface{}) (FallbackToStringEncoding, error) {
21644 tmp, err := graphql.UnmarshalString(v)
21645 res := FallbackToStringEncoding(tmp)
21646 return res, graphql.ErrorOnPath(ctx, err)
21647 }
21648
21649 func (ec *executionContext) marshalNFallbackToStringEncoding2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐFallbackToStringEncoding(ctx context.Context, sel ast.SelectionSet, v FallbackToStringEncoding) graphql.Marshaler {
21650 res := graphql.MarshalString(string(v))
21651 if res == graphql.Null {
21652 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21653 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21654 }
21655 }
21656 return res
21657 }
21658
21659 func (ec *executionContext) unmarshalNFieldsOrderInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐFieldsOrderInput(ctx context.Context, v interface{}) (FieldsOrderInput, error) {
21660 res, err := ec.unmarshalInputFieldsOrderInput(ctx, v)
21661 return res, graphql.ErrorOnPath(ctx, err)
21662 }
21663
21664 func (ec *executionContext) marshalNFieldsOrderPayload2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐFieldsOrderPayload(ctx context.Context, sel ast.SelectionSet, v FieldsOrderPayload) graphql.Marshaler {
21665 return ec._FieldsOrderPayload(ctx, sel, &v)
21666 }
21667
21668 func (ec *executionContext) marshalNFieldsOrderPayload2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐFieldsOrderPayload(ctx context.Context, sel ast.SelectionSet, v *FieldsOrderPayload) graphql.Marshaler {
21669 if v == nil {
21670 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21671 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21672 }
21673 return graphql.Null
21674 }
21675 return ec._FieldsOrderPayload(ctx, sel, v)
21676 }
21677
21678 func (ec *executionContext) unmarshalNFloat2float64(ctx context.Context, v interface{}) (float64, error) {
21679 res, err := graphql.UnmarshalFloatContext(ctx, v)
21680 return res, graphql.ErrorOnPath(ctx, err)
21681 }
21682
21683 func (ec *executionContext) marshalNFloat2float64(ctx context.Context, sel ast.SelectionSet, v float64) graphql.Marshaler {
21684 res := graphql.MarshalFloatContext(v)
21685 if res == graphql.Null {
21686 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21687 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21688 }
21689 }
21690 return graphql.WrapContextMarshaler(ctx, res)
21691 }
21692
21693 func (ec *executionContext) unmarshalNID2int(ctx context.Context, v interface{}) (int, error) {
21694 res, err := graphql.UnmarshalIntID(v)
21695 return res, graphql.ErrorOnPath(ctx, err)
21696 }
21697
21698 func (ec *executionContext) marshalNID2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
21699 res := graphql.MarshalIntID(v)
21700 if res == graphql.Null {
21701 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21702 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21703 }
21704 }
21705 return res
21706 }
21707
21708 func (ec *executionContext) unmarshalNID2string(ctx context.Context, v interface{}) (string, error) {
21709 res, err := graphql.UnmarshalID(v)
21710 return res, graphql.ErrorOnPath(ctx, err)
21711 }
21712
21713 func (ec *executionContext) marshalNID2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
21714 res := graphql.MarshalID(v)
21715 if res == graphql.Null {
21716 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21717 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21718 }
21719 }
21720 return res
21721 }
21722
21723 func (ec *executionContext) unmarshalNInnerDirectives2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInnerDirectives(ctx context.Context, v interface{}) (*InnerDirectives, error) {
21724 res, err := ec.unmarshalInputInnerDirectives(ctx, v)
21725 return &res, graphql.ErrorOnPath(ctx, err)
21726 }
21727
21728 func (ec *executionContext) unmarshalNInnerInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInnerInput(ctx context.Context, v interface{}) (InnerInput, error) {
21729 res, err := ec.unmarshalInputInnerInput(ctx, v)
21730 return res, graphql.ErrorOnPath(ctx, err)
21731 }
21732
21733 func (ec *executionContext) unmarshalNInnerInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInnerInput(ctx context.Context, v interface{}) (*InnerInput, error) {
21734 res, err := ec.unmarshalInputInnerInput(ctx, v)
21735 return &res, graphql.ErrorOnPath(ctx, err)
21736 }
21737
21738 func (ec *executionContext) marshalNInnerObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInnerObject(ctx context.Context, sel ast.SelectionSet, v *InnerObject) graphql.Marshaler {
21739 if v == nil {
21740 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21741 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21742 }
21743 return graphql.Null
21744 }
21745 return ec._InnerObject(ctx, sel, v)
21746 }
21747
21748 func (ec *executionContext) unmarshalNInputDirectives2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInputDirectives(ctx context.Context, v interface{}) (InputDirectives, error) {
21749 res, err := ec.unmarshalInputInputDirectives(ctx, v)
21750 return res, graphql.ErrorOnPath(ctx, err)
21751 }
21752
21753 func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
21754 res, err := graphql.UnmarshalInt(v)
21755 return res, graphql.ErrorOnPath(ctx, err)
21756 }
21757
21758 func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
21759 res := graphql.MarshalInt(v)
21760 if res == graphql.Null {
21761 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21762 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21763 }
21764 }
21765 return res
21766 }
21767
21768 func (ec *executionContext) unmarshalNInt2int32(ctx context.Context, v interface{}) (int32, error) {
21769 res, err := graphql.UnmarshalInt32(v)
21770 return res, graphql.ErrorOnPath(ctx, err)
21771 }
21772
21773 func (ec *executionContext) marshalNInt2int32(ctx context.Context, sel ast.SelectionSet, v int32) graphql.Marshaler {
21774 res := graphql.MarshalInt32(v)
21775 if res == graphql.Null {
21776 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21777 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21778 }
21779 }
21780 return res
21781 }
21782
21783 func (ec *executionContext) unmarshalNInt2int64(ctx context.Context, v interface{}) (int64, error) {
21784 res, err := graphql.UnmarshalInt64(v)
21785 return res, graphql.ErrorOnPath(ctx, err)
21786 }
21787
21788 func (ec *executionContext) marshalNInt2int64(ctx context.Context, sel ast.SelectionSet, v int64) graphql.Marshaler {
21789 res := graphql.MarshalInt64(v)
21790 if res == graphql.Null {
21791 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21792 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21793 }
21794 }
21795 return res
21796 }
21797
21798 func (ec *executionContext) marshalNLoopA2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐLoopA(ctx context.Context, sel ast.SelectionSet, v *LoopA) graphql.Marshaler {
21799 if v == nil {
21800 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21801 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21802 }
21803 return graphql.Null
21804 }
21805 return ec._LoopA(ctx, sel, v)
21806 }
21807
21808 func (ec *executionContext) marshalNLoopB2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐLoopB(ctx context.Context, sel ast.SelectionSet, v *LoopB) graphql.Marshaler {
21809 if v == nil {
21810 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21811 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21812 }
21813 return graphql.Null
21814 }
21815 return ec._LoopB(ctx, sel, v)
21816 }
21817
21818 func (ec *executionContext) unmarshalNMarshalPanic2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐMarshalPanic(ctx context.Context, v interface{}) (MarshalPanic, error) {
21819 var res MarshalPanic
21820 err := res.UnmarshalGQL(v)
21821 return res, graphql.ErrorOnPath(ctx, err)
21822 }
21823
21824 func (ec *executionContext) marshalNMarshalPanic2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐMarshalPanic(ctx context.Context, sel ast.SelectionSet, v MarshalPanic) graphql.Marshaler {
21825 return v
21826 }
21827
21828 func (ec *executionContext) unmarshalNMarshalPanic2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐMarshalPanicᚄ(ctx context.Context, v interface{}) ([]MarshalPanic, error) {
21829 var vSlice []interface{}
21830 if v != nil {
21831 vSlice = graphql.CoerceList(v)
21832 }
21833 var err error
21834 res := make([]MarshalPanic, len(vSlice))
21835 for i := range vSlice {
21836 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
21837 res[i], err = ec.unmarshalNMarshalPanic2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐMarshalPanic(ctx, vSlice[i])
21838 if err != nil {
21839 return nil, err
21840 }
21841 }
21842 return res, nil
21843 }
21844
21845 func (ec *executionContext) marshalNMarshalPanic2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐMarshalPanicᚄ(ctx context.Context, sel ast.SelectionSet, v []MarshalPanic) graphql.Marshaler {
21846 ret := make(graphql.Array, len(v))
21847 for i := range v {
21848 ret[i] = ec.marshalNMarshalPanic2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐMarshalPanic(ctx, sel, v[i])
21849 }
21850
21851 for _, e := range ret {
21852 if e == graphql.Null {
21853 return graphql.Null
21854 }
21855 }
21856
21857 return ret
21858 }
21859
21860 func (ec *executionContext) unmarshalNNestedInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐNestedInput(ctx context.Context, v interface{}) (*NestedInput, error) {
21861 res, err := ec.unmarshalInputNestedInput(ctx, v)
21862 return &res, graphql.ErrorOnPath(ctx, err)
21863 }
21864
21865 func (ec *executionContext) marshalNNode2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐNode(ctx context.Context, sel ast.SelectionSet, v Node) graphql.Marshaler {
21866 if v == nil {
21867 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21868 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21869 }
21870 return graphql.Null
21871 }
21872 return ec._Node(ctx, sel, v)
21873 }
21874
21875 func (ec *executionContext) unmarshalNOmittableInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOmittableInput(ctx context.Context, v interface{}) (OmittableInput, error) {
21876 res, err := ec.unmarshalInputOmittableInput(ctx, v)
21877 return res, graphql.ErrorOnPath(ctx, err)
21878 }
21879
21880 func (ec *executionContext) marshalNPet2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPet(ctx context.Context, sel ast.SelectionSet, v *Pet) graphql.Marshaler {
21881 if v == nil {
21882 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21883 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21884 }
21885 return graphql.Null
21886 }
21887 return ec._Pet(ctx, sel, v)
21888 }
21889
21890 func (ec *executionContext) marshalNPrimitive2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPrimitive(ctx context.Context, sel ast.SelectionSet, v Primitive) graphql.Marshaler {
21891 return ec._Primitive(ctx, sel, &v)
21892 }
21893
21894 func (ec *executionContext) marshalNPrimitive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPrimitiveᚄ(ctx context.Context, sel ast.SelectionSet, v []Primitive) graphql.Marshaler {
21895 ret := make(graphql.Array, len(v))
21896 var wg sync.WaitGroup
21897 isLen1 := len(v) == 1
21898 if !isLen1 {
21899 wg.Add(len(v))
21900 }
21901 for i := range v {
21902 i := i
21903 fc := &graphql.FieldContext{
21904 Index: &i,
21905 Result: &v[i],
21906 }
21907 ctx := graphql.WithFieldContext(ctx, fc)
21908 f := func(i int) {
21909 defer func() {
21910 if r := recover(); r != nil {
21911 ec.Error(ctx, ec.Recover(ctx, r))
21912 ret = nil
21913 }
21914 }()
21915 if !isLen1 {
21916 defer wg.Done()
21917 }
21918 ret[i] = ec.marshalNPrimitive2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPrimitive(ctx, sel, v[i])
21919 }
21920 if isLen1 {
21921 f(i)
21922 } else {
21923 go f(i)
21924 }
21925
21926 }
21927 wg.Wait()
21928
21929 for _, e := range ret {
21930 if e == graphql.Null {
21931 return graphql.Null
21932 }
21933 }
21934
21935 return ret
21936 }
21937
21938 func (ec *executionContext) marshalNPrimitiveString2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPrimitiveString(ctx context.Context, sel ast.SelectionSet, v PrimitiveString) graphql.Marshaler {
21939 return ec._PrimitiveString(ctx, sel, &v)
21940 }
21941
21942 func (ec *executionContext) marshalNPrimitiveString2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPrimitiveStringᚄ(ctx context.Context, sel ast.SelectionSet, v []PrimitiveString) graphql.Marshaler {
21943 ret := make(graphql.Array, len(v))
21944 var wg sync.WaitGroup
21945 isLen1 := len(v) == 1
21946 if !isLen1 {
21947 wg.Add(len(v))
21948 }
21949 for i := range v {
21950 i := i
21951 fc := &graphql.FieldContext{
21952 Index: &i,
21953 Result: &v[i],
21954 }
21955 ctx := graphql.WithFieldContext(ctx, fc)
21956 f := func(i int) {
21957 defer func() {
21958 if r := recover(); r != nil {
21959 ec.Error(ctx, ec.Recover(ctx, r))
21960 ret = nil
21961 }
21962 }()
21963 if !isLen1 {
21964 defer wg.Done()
21965 }
21966 ret[i] = ec.marshalNPrimitiveString2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPrimitiveString(ctx, sel, v[i])
21967 }
21968 if isLen1 {
21969 f(i)
21970 } else {
21971 go f(i)
21972 }
21973
21974 }
21975 wg.Wait()
21976
21977 for _, e := range ret {
21978 if e == graphql.Null {
21979 return graphql.Null
21980 }
21981 }
21982
21983 return ret
21984 }
21985
21986 func (ec *executionContext) marshalNPtrToAnyContainer2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToAnyContainer(ctx context.Context, sel ast.SelectionSet, v PtrToAnyContainer) graphql.Marshaler {
21987 return ec._PtrToAnyContainer(ctx, sel, &v)
21988 }
21989
21990 func (ec *executionContext) marshalNPtrToAnyContainer2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToAnyContainer(ctx context.Context, sel ast.SelectionSet, v *PtrToAnyContainer) graphql.Marshaler {
21991 if v == nil {
21992 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
21993 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
21994 }
21995 return graphql.Null
21996 }
21997 return ec._PtrToAnyContainer(ctx, sel, v)
21998 }
21999
22000 func (ec *executionContext) marshalNPtrToPtrOuter2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrOuter(ctx context.Context, sel ast.SelectionSet, v PtrToPtrOuter) graphql.Marshaler {
22001 return ec._PtrToPtrOuter(ctx, sel, &v)
22002 }
22003
22004 func (ec *executionContext) marshalNPtrToPtrOuter2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrOuter(ctx context.Context, sel ast.SelectionSet, v *PtrToPtrOuter) graphql.Marshaler {
22005 if v == nil {
22006 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22007 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22008 }
22009 return graphql.Null
22010 }
22011 return ec._PtrToPtrOuter(ctx, sel, v)
22012 }
22013
22014 func (ec *executionContext) marshalNPtrToSliceContainer2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToSliceContainer(ctx context.Context, sel ast.SelectionSet, v PtrToSliceContainer) graphql.Marshaler {
22015 return ec._PtrToSliceContainer(ctx, sel, &v)
22016 }
22017
22018 func (ec *executionContext) marshalNPtrToSliceContainer2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToSliceContainer(ctx context.Context, sel ast.SelectionSet, v *PtrToSliceContainer) graphql.Marshaler {
22019 if v == nil {
22020 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22021 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22022 }
22023 return graphql.Null
22024 }
22025 return ec._PtrToSliceContainer(ctx, sel, v)
22026 }
22027
22028 func (ec *executionContext) unmarshalNRecursiveInputSlice2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐRecursiveInputSlice(ctx context.Context, v interface{}) (RecursiveInputSlice, error) {
22029 res, err := ec.unmarshalInputRecursiveInputSlice(ctx, v)
22030 return res, graphql.ErrorOnPath(ctx, err)
22031 }
22032
22033 func (ec *executionContext) marshalNShapeUnion2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐShapeUnion(ctx context.Context, sel ast.SelectionSet, v ShapeUnion) graphql.Marshaler {
22034 if v == nil {
22035 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22036 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22037 }
22038 return graphql.Null
22039 }
22040 return ec._ShapeUnion(ctx, sel, v)
22041 }
22042
22043 func (ec *executionContext) marshalNSize2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐSize(ctx context.Context, sel ast.SelectionSet, v *Size) graphql.Marshaler {
22044 if v == nil {
22045 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22046 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22047 }
22048 return graphql.Null
22049 }
22050 return ec._Size(ctx, sel, v)
22051 }
22052
22053 func (ec *executionContext) unmarshalNSpecialInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐSpecialInput(ctx context.Context, v interface{}) (SpecialInput, error) {
22054 res, err := ec.unmarshalInputSpecialInput(ctx, v)
22055 return res, graphql.ErrorOnPath(ctx, err)
22056 }
22057
22058 func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
22059 res, err := graphql.UnmarshalString(v)
22060 return res, graphql.ErrorOnPath(ctx, err)
22061 }
22062
22063 func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
22064 res := graphql.MarshalString(v)
22065 if res == graphql.Null {
22066 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22067 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22068 }
22069 }
22070 return res
22071 }
22072
22073 func (ec *executionContext) unmarshalNString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
22074 var vSlice []interface{}
22075 if v != nil {
22076 vSlice = graphql.CoerceList(v)
22077 }
22078 var err error
22079 res := make([]string, len(vSlice))
22080 for i := range vSlice {
22081 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
22082 res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
22083 if err != nil {
22084 return nil, err
22085 }
22086 }
22087 return res, nil
22088 }
22089
22090 func (ec *executionContext) marshalNString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
22091 ret := make(graphql.Array, len(v))
22092 for i := range v {
22093 ret[i] = ec.marshalNString2string(ctx, sel, v[i])
22094 }
22095
22096 for _, e := range ret {
22097 if e == graphql.Null {
22098 return graphql.Null
22099 }
22100 }
22101
22102 return ret
22103 }
22104
22105 func (ec *executionContext) unmarshalNString2ᚕᚖstring(ctx context.Context, v interface{}) ([]*string, error) {
22106 var vSlice []interface{}
22107 if v != nil {
22108 vSlice = graphql.CoerceList(v)
22109 }
22110 var err error
22111 res := make([]*string, len(vSlice))
22112 for i := range vSlice {
22113 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
22114 res[i], err = ec.unmarshalOString2ᚖstring(ctx, vSlice[i])
22115 if err != nil {
22116 return nil, err
22117 }
22118 }
22119 return res, nil
22120 }
22121
22122 func (ec *executionContext) marshalNString2ᚕᚖstring(ctx context.Context, sel ast.SelectionSet, v []*string) graphql.Marshaler {
22123 ret := make(graphql.Array, len(v))
22124 for i := range v {
22125 ret[i] = ec.marshalOString2ᚖstring(ctx, sel, v[i])
22126 }
22127
22128 return ret
22129 }
22130
22131 func (ec *executionContext) unmarshalNString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
22132 res, err := graphql.UnmarshalString(v)
22133 return &res, graphql.ErrorOnPath(ctx, err)
22134 }
22135
22136 func (ec *executionContext) marshalNString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
22137 if v == nil {
22138 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22139 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22140 }
22141 return graphql.Null
22142 }
22143 res := graphql.MarshalString(*v)
22144 if res == graphql.Null {
22145 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22146 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22147 }
22148 }
22149 return res
22150 }
22151
22152 func (ec *executionContext) unmarshalNStringFromContextFunction2string(ctx context.Context, v interface{}) (string, error) {
22153 res, err := UnmarshalStringFromContextFunction(ctx, v)
22154 return res, graphql.ErrorOnPath(ctx, err)
22155 }
22156
22157 func (ec *executionContext) marshalNStringFromContextFunction2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
22158 res := MarshalStringFromContextFunction(v)
22159 if res == graphql.Null {
22160 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22161 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22162 }
22163 }
22164 return graphql.WrapContextMarshaler(ctx, res)
22165 }
22166
22167 func (ec *executionContext) unmarshalNStringFromContextInterface2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐStringFromContextInterface(ctx context.Context, v interface{}) (StringFromContextInterface, error) {
22168 var res StringFromContextInterface
22169 err := res.UnmarshalGQLContext(ctx, v)
22170 return res, graphql.ErrorOnPath(ctx, err)
22171 }
22172
22173 func (ec *executionContext) marshalNStringFromContextInterface2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐStringFromContextInterface(ctx context.Context, sel ast.SelectionSet, v StringFromContextInterface) graphql.Marshaler {
22174 return graphql.WrapContextMarshaler(ctx, v)
22175 }
22176
22177 func (ec *executionContext) unmarshalNStringFromContextInterface2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐStringFromContextInterface(ctx context.Context, v interface{}) (*StringFromContextInterface, error) {
22178 var res = new(StringFromContextInterface)
22179 err := res.UnmarshalGQLContext(ctx, v)
22180 return res, graphql.ErrorOnPath(ctx, err)
22181 }
22182
22183 func (ec *executionContext) marshalNStringFromContextInterface2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐStringFromContextInterface(ctx context.Context, sel ast.SelectionSet, v *StringFromContextInterface) graphql.Marshaler {
22184 if v == nil {
22185 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22186 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22187 }
22188 return graphql.Null
22189 }
22190 return graphql.WrapContextMarshaler(ctx, v)
22191 }
22192
22193 func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
22194 res, err := graphql.UnmarshalTime(v)
22195 return res, graphql.ErrorOnPath(ctx, err)
22196 }
22197
22198 func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
22199 res := graphql.MarshalTime(v)
22200 if res == graphql.Null {
22201 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22202 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22203 }
22204 }
22205 return res
22206 }
22207
22208 func (ec *executionContext) unmarshalNUUID2string(ctx context.Context, v interface{}) (string, error) {
22209 res, err := graphql.UnmarshalString(v)
22210 return res, graphql.ErrorOnPath(ctx, err)
22211 }
22212
22213 func (ec *executionContext) marshalNUUID2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
22214 res := graphql.MarshalString(v)
22215 if res == graphql.Null {
22216 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22217 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22218 }
22219 }
22220 return res
22221 }
22222
22223 func (ec *executionContext) unmarshalNUpdatePtrToPtrOuter2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrOuter(ctx context.Context, v interface{}) (UpdatePtrToPtrOuter, error) {
22224 res, err := ec.unmarshalInputUpdatePtrToPtrOuter(ctx, v)
22225 return res, graphql.ErrorOnPath(ctx, err)
22226 }
22227
22228 func (ec *executionContext) marshalNUser2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUser(ctx context.Context, sel ast.SelectionSet, v User) graphql.Marshaler {
22229 return ec._User(ctx, sel, &v)
22230 }
22231
22232 func (ec *executionContext) marshalNUser2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUserᚄ(ctx context.Context, sel ast.SelectionSet, v []*User) graphql.Marshaler {
22233 ret := make(graphql.Array, len(v))
22234 var wg sync.WaitGroup
22235 isLen1 := len(v) == 1
22236 if !isLen1 {
22237 wg.Add(len(v))
22238 }
22239 for i := range v {
22240 i := i
22241 fc := &graphql.FieldContext{
22242 Index: &i,
22243 Result: &v[i],
22244 }
22245 ctx := graphql.WithFieldContext(ctx, fc)
22246 f := func(i int) {
22247 defer func() {
22248 if r := recover(); r != nil {
22249 ec.Error(ctx, ec.Recover(ctx, r))
22250 ret = nil
22251 }
22252 }()
22253 if !isLen1 {
22254 defer wg.Done()
22255 }
22256 ret[i] = ec.marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUser(ctx, sel, v[i])
22257 }
22258 if isLen1 {
22259 f(i)
22260 } else {
22261 go f(i)
22262 }
22263
22264 }
22265 wg.Wait()
22266
22267 for _, e := range ret {
22268 if e == graphql.Null {
22269 return graphql.Null
22270 }
22271 }
22272
22273 return ret
22274 }
22275
22276 func (ec *executionContext) marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUser(ctx context.Context, sel ast.SelectionSet, v *User) graphql.Marshaler {
22277 if v == nil {
22278 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22279 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22280 }
22281 return graphql.Null
22282 }
22283 return ec._User(ctx, sel, v)
22284 }
22285
22286 func (ec *executionContext) marshalNWrappedMap2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐWrappedMap(ctx context.Context, sel ast.SelectionSet, v WrappedMap) graphql.Marshaler {
22287 if v == nil {
22288 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22289 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22290 }
22291 return graphql.Null
22292 }
22293 return ec._WrappedMap(ctx, sel, v)
22294 }
22295
22296 func (ec *executionContext) unmarshalNWrappedScalar2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚋotherpkgᚐScalar(ctx context.Context, v interface{}) (otherpkg.Scalar, error) {
22297 tmp, err := graphql.UnmarshalString(v)
22298 res := otherpkg.Scalar(tmp)
22299 return res, graphql.ErrorOnPath(ctx, err)
22300 }
22301
22302 func (ec *executionContext) marshalNWrappedScalar2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚋotherpkgᚐScalar(ctx context.Context, sel ast.SelectionSet, v otherpkg.Scalar) graphql.Marshaler {
22303 res := graphql.MarshalString(string(v))
22304 if res == graphql.Null {
22305 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22306 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22307 }
22308 }
22309 return res
22310 }
22311
22312 func (ec *executionContext) marshalNWrappedSlice2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐWrappedSlice(ctx context.Context, sel ast.SelectionSet, v WrappedSlice) graphql.Marshaler {
22313 if v == nil {
22314 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22315 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22316 }
22317 return graphql.Null
22318 }
22319 return ec._WrappedSlice(ctx, sel, v)
22320 }
22321
22322 func (ec *executionContext) marshalNWrappedStruct2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐWrappedStruct(ctx context.Context, sel ast.SelectionSet, v WrappedStruct) graphql.Marshaler {
22323 return ec._WrappedStruct(ctx, sel, &v)
22324 }
22325
22326 func (ec *executionContext) marshalNWrappedStruct2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐWrappedStruct(ctx context.Context, sel ast.SelectionSet, v *WrappedStruct) graphql.Marshaler {
22327 if v == nil {
22328 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22329 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22330 }
22331 return graphql.Null
22332 }
22333 return ec._WrappedStruct(ctx, sel, v)
22334 }
22335
22336 func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
22337 return ec.___Directive(ctx, sel, &v)
22338 }
22339
22340 func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
22341 ret := make(graphql.Array, len(v))
22342 var wg sync.WaitGroup
22343 isLen1 := len(v) == 1
22344 if !isLen1 {
22345 wg.Add(len(v))
22346 }
22347 for i := range v {
22348 i := i
22349 fc := &graphql.FieldContext{
22350 Index: &i,
22351 Result: &v[i],
22352 }
22353 ctx := graphql.WithFieldContext(ctx, fc)
22354 f := func(i int) {
22355 defer func() {
22356 if r := recover(); r != nil {
22357 ec.Error(ctx, ec.Recover(ctx, r))
22358 ret = nil
22359 }
22360 }()
22361 if !isLen1 {
22362 defer wg.Done()
22363 }
22364 ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
22365 }
22366 if isLen1 {
22367 f(i)
22368 } else {
22369 go f(i)
22370 }
22371
22372 }
22373 wg.Wait()
22374
22375 for _, e := range ret {
22376 if e == graphql.Null {
22377 return graphql.Null
22378 }
22379 }
22380
22381 return ret
22382 }
22383
22384 func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
22385 res, err := graphql.UnmarshalString(v)
22386 return res, graphql.ErrorOnPath(ctx, err)
22387 }
22388
22389 func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
22390 res := graphql.MarshalString(v)
22391 if res == graphql.Null {
22392 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22393 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22394 }
22395 }
22396 return res
22397 }
22398
22399 func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
22400 var vSlice []interface{}
22401 if v != nil {
22402 vSlice = graphql.CoerceList(v)
22403 }
22404 var err error
22405 res := make([]string, len(vSlice))
22406 for i := range vSlice {
22407 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
22408 res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
22409 if err != nil {
22410 return nil, err
22411 }
22412 }
22413 return res, nil
22414 }
22415
22416 func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
22417 ret := make(graphql.Array, len(v))
22418 var wg sync.WaitGroup
22419 isLen1 := len(v) == 1
22420 if !isLen1 {
22421 wg.Add(len(v))
22422 }
22423 for i := range v {
22424 i := i
22425 fc := &graphql.FieldContext{
22426 Index: &i,
22427 Result: &v[i],
22428 }
22429 ctx := graphql.WithFieldContext(ctx, fc)
22430 f := func(i int) {
22431 defer func() {
22432 if r := recover(); r != nil {
22433 ec.Error(ctx, ec.Recover(ctx, r))
22434 ret = nil
22435 }
22436 }()
22437 if !isLen1 {
22438 defer wg.Done()
22439 }
22440 ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
22441 }
22442 if isLen1 {
22443 f(i)
22444 } else {
22445 go f(i)
22446 }
22447
22448 }
22449 wg.Wait()
22450
22451 for _, e := range ret {
22452 if e == graphql.Null {
22453 return graphql.Null
22454 }
22455 }
22456
22457 return ret
22458 }
22459
22460 func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
22461 return ec.___EnumValue(ctx, sel, &v)
22462 }
22463
22464 func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
22465 return ec.___Field(ctx, sel, &v)
22466 }
22467
22468 func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
22469 return ec.___InputValue(ctx, sel, &v)
22470 }
22471
22472 func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
22473 ret := make(graphql.Array, len(v))
22474 var wg sync.WaitGroup
22475 isLen1 := len(v) == 1
22476 if !isLen1 {
22477 wg.Add(len(v))
22478 }
22479 for i := range v {
22480 i := i
22481 fc := &graphql.FieldContext{
22482 Index: &i,
22483 Result: &v[i],
22484 }
22485 ctx := graphql.WithFieldContext(ctx, fc)
22486 f := func(i int) {
22487 defer func() {
22488 if r := recover(); r != nil {
22489 ec.Error(ctx, ec.Recover(ctx, r))
22490 ret = nil
22491 }
22492 }()
22493 if !isLen1 {
22494 defer wg.Done()
22495 }
22496 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
22497 }
22498 if isLen1 {
22499 f(i)
22500 } else {
22501 go f(i)
22502 }
22503
22504 }
22505 wg.Wait()
22506
22507 for _, e := range ret {
22508 if e == graphql.Null {
22509 return graphql.Null
22510 }
22511 }
22512
22513 return ret
22514 }
22515
22516 func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
22517 return ec.___Type(ctx, sel, &v)
22518 }
22519
22520 func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
22521 ret := make(graphql.Array, len(v))
22522 var wg sync.WaitGroup
22523 isLen1 := len(v) == 1
22524 if !isLen1 {
22525 wg.Add(len(v))
22526 }
22527 for i := range v {
22528 i := i
22529 fc := &graphql.FieldContext{
22530 Index: &i,
22531 Result: &v[i],
22532 }
22533 ctx := graphql.WithFieldContext(ctx, fc)
22534 f := func(i int) {
22535 defer func() {
22536 if r := recover(); r != nil {
22537 ec.Error(ctx, ec.Recover(ctx, r))
22538 ret = nil
22539 }
22540 }()
22541 if !isLen1 {
22542 defer wg.Done()
22543 }
22544 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
22545 }
22546 if isLen1 {
22547 f(i)
22548 } else {
22549 go f(i)
22550 }
22551
22552 }
22553 wg.Wait()
22554
22555 for _, e := range ret {
22556 if e == graphql.Null {
22557 return graphql.Null
22558 }
22559 }
22560
22561 return ret
22562 }
22563
22564 func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
22565 if v == nil {
22566 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22567 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22568 }
22569 return graphql.Null
22570 }
22571 return ec.___Type(ctx, sel, v)
22572 }
22573
22574 func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
22575 res, err := graphql.UnmarshalString(v)
22576 return res, graphql.ErrorOnPath(ctx, err)
22577 }
22578
22579 func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
22580 res := graphql.MarshalString(v)
22581 if res == graphql.Null {
22582 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
22583 ec.Errorf(ctx, "the requested element is null which the schema does not allow")
22584 }
22585 }
22586 return res
22587 }
22588
22589 func (ec *executionContext) marshalOAnimal2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐAnimal(ctx context.Context, sel ast.SelectionSet, v Animal) graphql.Marshaler {
22590 if v == nil {
22591 return graphql.Null
22592 }
22593 return ec._Animal(ctx, sel, v)
22594 }
22595
22596 func (ec *executionContext) unmarshalOAny2interface(ctx context.Context, v interface{}) (any, error) {
22597 if v == nil {
22598 return nil, nil
22599 }
22600 res, err := graphql.UnmarshalAny(v)
22601 return res, graphql.ErrorOnPath(ctx, err)
22602 }
22603
22604 func (ec *executionContext) marshalOAny2interface(ctx context.Context, sel ast.SelectionSet, v any) graphql.Marshaler {
22605 if v == nil {
22606 return graphql.Null
22607 }
22608 res := graphql.MarshalAny(v)
22609 return res
22610 }
22611
22612 func (ec *executionContext) unmarshalOAny2ᚖinterface(ctx context.Context, v interface{}) (*any, error) {
22613 if v == nil {
22614 return nil, nil
22615 }
22616 res, err := ec.unmarshalOAny2interface(ctx, v)
22617 return &res, graphql.ErrorOnPath(ctx, err)
22618 }
22619
22620 func (ec *executionContext) marshalOAny2ᚖinterface(ctx context.Context, sel ast.SelectionSet, v *any) graphql.Marshaler {
22621 return ec.marshalOAny2interface(ctx, sel, *v)
22622 }
22623
22624 func (ec *executionContext) marshalOAutobind2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐAutobind(ctx context.Context, sel ast.SelectionSet, v *Autobind) graphql.Marshaler {
22625 if v == nil {
22626 return graphql.Null
22627 }
22628 return ec._Autobind(ctx, sel, v)
22629 }
22630
22631 func (ec *executionContext) marshalOBackedByInterface2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐBackedByInterface(ctx context.Context, sel ast.SelectionSet, v BackedByInterface) graphql.Marshaler {
22632 if v == nil {
22633 return graphql.Null
22634 }
22635 return ec._BackedByInterface(ctx, sel, v)
22636 }
22637
22638 func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
22639 res, err := graphql.UnmarshalBoolean(v)
22640 return res, graphql.ErrorOnPath(ctx, err)
22641 }
22642
22643 func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
22644 res := graphql.MarshalBoolean(v)
22645 return res
22646 }
22647
22648 func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
22649 if v == nil {
22650 return nil, nil
22651 }
22652 res, err := graphql.UnmarshalBoolean(v)
22653 return &res, graphql.ErrorOnPath(ctx, err)
22654 }
22655
22656 func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
22657 if v == nil {
22658 return graphql.Null
22659 }
22660 res := graphql.MarshalBoolean(*v)
22661 return res
22662 }
22663
22664 func (ec *executionContext) unmarshalOChanges2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
22665 if v == nil {
22666 return nil, nil
22667 }
22668 res, err := ec.unmarshalInputChanges(ctx, v)
22669 return res, graphql.ErrorOnPath(ctx, err)
22670 }
22671
22672 func (ec *executionContext) marshalOCheckIssue8962ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCheckIssue896(ctx context.Context, sel ast.SelectionSet, v []*CheckIssue896) graphql.Marshaler {
22673 if v == nil {
22674 return graphql.Null
22675 }
22676 ret := make(graphql.Array, len(v))
22677 var wg sync.WaitGroup
22678 isLen1 := len(v) == 1
22679 if !isLen1 {
22680 wg.Add(len(v))
22681 }
22682 for i := range v {
22683 i := i
22684 fc := &graphql.FieldContext{
22685 Index: &i,
22686 Result: &v[i],
22687 }
22688 ctx := graphql.WithFieldContext(ctx, fc)
22689 f := func(i int) {
22690 defer func() {
22691 if r := recover(); r != nil {
22692 ec.Error(ctx, ec.Recover(ctx, r))
22693 ret = nil
22694 }
22695 }()
22696 if !isLen1 {
22697 defer wg.Done()
22698 }
22699 ret[i] = ec.marshalOCheckIssue8962ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCheckIssue896(ctx, sel, v[i])
22700 }
22701 if isLen1 {
22702 f(i)
22703 } else {
22704 go f(i)
22705 }
22706
22707 }
22708 wg.Wait()
22709
22710 return ret
22711 }
22712
22713 func (ec *executionContext) marshalOCheckIssue8962ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCheckIssue896ᚄ(ctx context.Context, sel ast.SelectionSet, v []*CheckIssue896) graphql.Marshaler {
22714 if v == nil {
22715 return graphql.Null
22716 }
22717 ret := make(graphql.Array, len(v))
22718 var wg sync.WaitGroup
22719 isLen1 := len(v) == 1
22720 if !isLen1 {
22721 wg.Add(len(v))
22722 }
22723 for i := range v {
22724 i := i
22725 fc := &graphql.FieldContext{
22726 Index: &i,
22727 Result: &v[i],
22728 }
22729 ctx := graphql.WithFieldContext(ctx, fc)
22730 f := func(i int) {
22731 defer func() {
22732 if r := recover(); r != nil {
22733 ec.Error(ctx, ec.Recover(ctx, r))
22734 ret = nil
22735 }
22736 }()
22737 if !isLen1 {
22738 defer wg.Done()
22739 }
22740 ret[i] = ec.marshalNCheckIssue8962ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCheckIssue896(ctx, sel, v[i])
22741 }
22742 if isLen1 {
22743 f(i)
22744 } else {
22745 go f(i)
22746 }
22747
22748 }
22749 wg.Wait()
22750
22751 for _, e := range ret {
22752 if e == graphql.Null {
22753 return graphql.Null
22754 }
22755 }
22756
22757 return ret
22758 }
22759
22760 func (ec *executionContext) marshalOCheckIssue8962ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCheckIssue896(ctx context.Context, sel ast.SelectionSet, v *CheckIssue896) graphql.Marshaler {
22761 if v == nil {
22762 return graphql.Null
22763 }
22764 return ec._CheckIssue896(ctx, sel, v)
22765 }
22766
22767 func (ec *executionContext) marshalOCircle2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCircle(ctx context.Context, sel ast.SelectionSet, v *Circle) graphql.Marshaler {
22768 if v == nil {
22769 return graphql.Null
22770 }
22771 return ec._Circle(ctx, sel, v)
22772 }
22773
22774 func (ec *executionContext) marshalOCoordinates2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCoordinates(ctx context.Context, sel ast.SelectionSet, v Coordinates) graphql.Marshaler {
22775 return ec._Coordinates(ctx, sel, &v)
22776 }
22777
22778 func (ec *executionContext) unmarshalOCustomScalar2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCustomScalar(ctx context.Context, v interface{}) (*CustomScalar, error) {
22779 if v == nil {
22780 return nil, nil
22781 }
22782 var res = new(CustomScalar)
22783 err := res.UnmarshalGQL(v)
22784 return res, graphql.ErrorOnPath(ctx, err)
22785 }
22786
22787 func (ec *executionContext) marshalOCustomScalar2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐCustomScalar(ctx context.Context, sel ast.SelectionSet, v *CustomScalar) graphql.Marshaler {
22788 if v == nil {
22789 return graphql.Null
22790 }
22791 return v
22792 }
22793
22794 func (ec *executionContext) unmarshalODefaultScalarImplementation2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
22795 if v == nil {
22796 return nil, nil
22797 }
22798 res, err := graphql.UnmarshalString(v)
22799 return &res, graphql.ErrorOnPath(ctx, err)
22800 }
22801
22802 func (ec *executionContext) marshalODefaultScalarImplementation2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
22803 if v == nil {
22804 return graphql.Null
22805 }
22806 res := graphql.MarshalString(*v)
22807 return res
22808 }
22809
22810 func (ec *executionContext) marshalODeferModel2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐDeferModelᚄ(ctx context.Context, sel ast.SelectionSet, v []*DeferModel) graphql.Marshaler {
22811 if v == nil {
22812 return graphql.Null
22813 }
22814 ret := make(graphql.Array, len(v))
22815 var wg sync.WaitGroup
22816 isLen1 := len(v) == 1
22817 if !isLen1 {
22818 wg.Add(len(v))
22819 }
22820 for i := range v {
22821 i := i
22822 fc := &graphql.FieldContext{
22823 Index: &i,
22824 Result: &v[i],
22825 }
22826 ctx := graphql.WithFieldContext(ctx, fc)
22827 f := func(i int) {
22828 defer func() {
22829 if r := recover(); r != nil {
22830 ec.Error(ctx, ec.Recover(ctx, r))
22831 ret = nil
22832 }
22833 }()
22834 if !isLen1 {
22835 defer wg.Done()
22836 }
22837 ret[i] = ec.marshalNDeferModel2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐDeferModel(ctx, sel, v[i])
22838 }
22839 if isLen1 {
22840 f(i)
22841 } else {
22842 go f(i)
22843 }
22844
22845 }
22846 wg.Wait()
22847
22848 for _, e := range ret {
22849 if e == graphql.Null {
22850 return graphql.Null
22851 }
22852 }
22853
22854 return ret
22855 }
22856
22857 func (ec *executionContext) marshalODeferModel2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐDeferModel(ctx context.Context, sel ast.SelectionSet, v *DeferModel) graphql.Marshaler {
22858 if v == nil {
22859 return graphql.Null
22860 }
22861 return ec._DeferModel(ctx, sel, v)
22862 }
22863
22864 func (ec *executionContext) marshalODog2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐDog(ctx context.Context, sel ast.SelectionSet, v *Dog) graphql.Marshaler {
22865 if v == nil {
22866 return graphql.Null
22867 }
22868 return ec._Dog(ctx, sel, v)
22869 }
22870
22871 func (ec *executionContext) marshalOEmbeddedCase12ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐEmbeddedCase1(ctx context.Context, sel ast.SelectionSet, v *EmbeddedCase1) graphql.Marshaler {
22872 if v == nil {
22873 return graphql.Null
22874 }
22875 return ec._EmbeddedCase1(ctx, sel, v)
22876 }
22877
22878 func (ec *executionContext) marshalOEmbeddedCase22ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐEmbeddedCase2(ctx context.Context, sel ast.SelectionSet, v *EmbeddedCase2) graphql.Marshaler {
22879 if v == nil {
22880 return graphql.Null
22881 }
22882 return ec._EmbeddedCase2(ctx, sel, v)
22883 }
22884
22885 func (ec *executionContext) marshalOEmbeddedCase32ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐEmbeddedCase3(ctx context.Context, sel ast.SelectionSet, v *EmbeddedCase3) graphql.Marshaler {
22886 if v == nil {
22887 return graphql.Null
22888 }
22889 return ec._EmbeddedCase3(ctx, sel, v)
22890 }
22891
22892 func (ec *executionContext) marshalOError2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐError(ctx context.Context, sel ast.SelectionSet, v []*Error) graphql.Marshaler {
22893 if v == nil {
22894 return graphql.Null
22895 }
22896 ret := make(graphql.Array, len(v))
22897 var wg sync.WaitGroup
22898 isLen1 := len(v) == 1
22899 if !isLen1 {
22900 wg.Add(len(v))
22901 }
22902 for i := range v {
22903 i := i
22904 fc := &graphql.FieldContext{
22905 Index: &i,
22906 Result: &v[i],
22907 }
22908 ctx := graphql.WithFieldContext(ctx, fc)
22909 f := func(i int) {
22910 defer func() {
22911 if r := recover(); r != nil {
22912 ec.Error(ctx, ec.Recover(ctx, r))
22913 ret = nil
22914 }
22915 }()
22916 if !isLen1 {
22917 defer wg.Done()
22918 }
22919 ret[i] = ec.marshalOError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐError(ctx, sel, v[i])
22920 }
22921 if isLen1 {
22922 f(i)
22923 } else {
22924 go f(i)
22925 }
22926
22927 }
22928 wg.Wait()
22929
22930 return ret
22931 }
22932
22933 func (ec *executionContext) marshalOError2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐErrorᚄ(ctx context.Context, sel ast.SelectionSet, v []*Error) graphql.Marshaler {
22934 if v == nil {
22935 return graphql.Null
22936 }
22937 ret := make(graphql.Array, len(v))
22938 var wg sync.WaitGroup
22939 isLen1 := len(v) == 1
22940 if !isLen1 {
22941 wg.Add(len(v))
22942 }
22943 for i := range v {
22944 i := i
22945 fc := &graphql.FieldContext{
22946 Index: &i,
22947 Result: &v[i],
22948 }
22949 ctx := graphql.WithFieldContext(ctx, fc)
22950 f := func(i int) {
22951 defer func() {
22952 if r := recover(); r != nil {
22953 ec.Error(ctx, ec.Recover(ctx, r))
22954 ret = nil
22955 }
22956 }()
22957 if !isLen1 {
22958 defer wg.Done()
22959 }
22960 ret[i] = ec.marshalNError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐError(ctx, sel, v[i])
22961 }
22962 if isLen1 {
22963 f(i)
22964 } else {
22965 go f(i)
22966 }
22967
22968 }
22969 wg.Wait()
22970
22971 for _, e := range ret {
22972 if e == graphql.Null {
22973 return graphql.Null
22974 }
22975 }
22976
22977 return ret
22978 }
22979
22980 func (ec *executionContext) marshalOError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐError(ctx context.Context, sel ast.SelectionSet, v *Error) graphql.Marshaler {
22981 if v == nil {
22982 return graphql.Null
22983 }
22984 return ec._Error(ctx, sel, v)
22985 }
22986
22987 func (ec *executionContext) marshalOErrors2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐErrors(ctx context.Context, sel ast.SelectionSet, v *Errors) graphql.Marshaler {
22988 if v == nil {
22989 return graphql.Null
22990 }
22991 return ec._Errors(ctx, sel, v)
22992 }
22993
22994 func (ec *executionContext) unmarshalOFloat2float64(ctx context.Context, v interface{}) (float64, error) {
22995 res, err := graphql.UnmarshalFloatContext(ctx, v)
22996 return res, graphql.ErrorOnPath(ctx, err)
22997 }
22998
22999 func (ec *executionContext) marshalOFloat2float64(ctx context.Context, sel ast.SelectionSet, v float64) graphql.Marshaler {
23000 res := graphql.MarshalFloatContext(v)
23001 return graphql.WrapContextMarshaler(ctx, res)
23002 }
23003
23004 func (ec *executionContext) unmarshalOID2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
23005 if v == nil {
23006 return nil, nil
23007 }
23008 res, err := graphql.UnmarshalID(v)
23009 return &res, graphql.ErrorOnPath(ctx, err)
23010 }
23011
23012 func (ec *executionContext) marshalOID2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
23013 if v == nil {
23014 return graphql.Null
23015 }
23016 res := graphql.MarshalID(*v)
23017 return res
23018 }
23019
23020 func (ec *executionContext) unmarshalOInnerDirectives2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInnerDirectives(ctx context.Context, v interface{}) (*InnerDirectives, error) {
23021 if v == nil {
23022 return nil, nil
23023 }
23024 res, err := ec.unmarshalInputInnerDirectives(ctx, v)
23025 return &res, graphql.ErrorOnPath(ctx, err)
23026 }
23027
23028 func (ec *executionContext) unmarshalOInputDirectives2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInputDirectives(ctx context.Context, v interface{}) (*InputDirectives, error) {
23029 if v == nil {
23030 return nil, nil
23031 }
23032 res, err := ec.unmarshalInputInputDirectives(ctx, v)
23033 return &res, graphql.ErrorOnPath(ctx, err)
23034 }
23035
23036 func (ec *executionContext) unmarshalOInputWithEnumValue2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐInputWithEnumValue(ctx context.Context, v interface{}) (*InputWithEnumValue, error) {
23037 if v == nil {
23038 return nil, nil
23039 }
23040 res, err := ec.unmarshalInputInputWithEnumValue(ctx, v)
23041 return &res, graphql.ErrorOnPath(ctx, err)
23042 }
23043
23044 func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
23045 if v == nil {
23046 return nil, nil
23047 }
23048 res, err := graphql.UnmarshalInt(v)
23049 return &res, graphql.ErrorOnPath(ctx, err)
23050 }
23051
23052 func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
23053 if v == nil {
23054 return graphql.Null
23055 }
23056 res := graphql.MarshalInt(*v)
23057 return res
23058 }
23059
23060 func (ec *executionContext) marshalOInvalidIdentifier2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚋinvalidᚑpackagenameᚐInvalidIdentifier(ctx context.Context, sel ast.SelectionSet, v *invalid_packagename.InvalidIdentifier) graphql.Marshaler {
23061 if v == nil {
23062 return graphql.Null
23063 }
23064 return ec._InvalidIdentifier(ctx, sel, v)
23065 }
23066
23067 func (ec *executionContext) marshalOIt2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚋintrospectionᚐIt(ctx context.Context, sel ast.SelectionSet, v *introspection1.It) graphql.Marshaler {
23068 if v == nil {
23069 return graphql.Null
23070 }
23071 return ec._It(ctx, sel, v)
23072 }
23073
23074 func (ec *executionContext) marshalOMapNested2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐMapNested(ctx context.Context, sel ast.SelectionSet, v *MapNested) graphql.Marshaler {
23075 if v == nil {
23076 return graphql.Null
23077 }
23078 return ec._MapNested(ctx, sel, v)
23079 }
23080
23081 func (ec *executionContext) unmarshalOMapNestedInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐMapNested(ctx context.Context, v interface{}) (*MapNested, error) {
23082 if v == nil {
23083 return nil, nil
23084 }
23085 res, err := ec.unmarshalInputMapNestedInput(ctx, v)
23086 return &res, graphql.ErrorOnPath(ctx, err)
23087 }
23088
23089 func (ec *executionContext) unmarshalOMapStringInterfaceInput2map(ctx context.Context, v interface{}) (map[string]interface{}, error) {
23090 if v == nil {
23091 return nil, nil
23092 }
23093 res, err := ec.unmarshalInputMapStringInterfaceInput(ctx, v)
23094 return res, graphql.ErrorOnPath(ctx, err)
23095 }
23096
23097 func (ec *executionContext) marshalOMapStringInterfaceType2map(ctx context.Context, sel ast.SelectionSet, v map[string]interface{}) graphql.Marshaler {
23098 if v == nil {
23099 return graphql.Null
23100 }
23101 return ec._MapStringInterfaceType(ctx, sel, v)
23102 }
23103
23104 func (ec *executionContext) marshalOModelMethods2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐModelMethods(ctx context.Context, sel ast.SelectionSet, v *ModelMethods) graphql.Marshaler {
23105 if v == nil {
23106 return graphql.Null
23107 }
23108 return ec._ModelMethods(ctx, sel, v)
23109 }
23110
23111 func (ec *executionContext) unmarshalONestedMapInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐNestedMapInput(ctx context.Context, v interface{}) (*NestedMapInput, error) {
23112 if v == nil {
23113 return nil, nil
23114 }
23115 res, err := ec.unmarshalInputNestedMapInput(ctx, v)
23116 return &res, graphql.ErrorOnPath(ctx, err)
23117 }
23118
23119 func (ec *executionContext) marshalOObjectDirectives2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐObjectDirectives(ctx context.Context, sel ast.SelectionSet, v *ObjectDirectives) graphql.Marshaler {
23120 if v == nil {
23121 return graphql.Null
23122 }
23123 return ec._ObjectDirectives(ctx, sel, v)
23124 }
23125
23126 func (ec *executionContext) marshalOObjectDirectivesWithCustomGoModel2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐObjectDirectivesWithCustomGoModel(ctx context.Context, sel ast.SelectionSet, v *ObjectDirectivesWithCustomGoModel) graphql.Marshaler {
23127 if v == nil {
23128 return graphql.Null
23129 }
23130 return ec._ObjectDirectivesWithCustomGoModel(ctx, sel, v)
23131 }
23132
23133 func (ec *executionContext) unmarshalOOuterInput2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOuterInput(ctx context.Context, v interface{}) ([][]*OuterInput, error) {
23134 if v == nil {
23135 return nil, nil
23136 }
23137 var vSlice []interface{}
23138 if v != nil {
23139 vSlice = graphql.CoerceList(v)
23140 }
23141 var err error
23142 res := make([][]*OuterInput, len(vSlice))
23143 for i := range vSlice {
23144 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
23145 res[i], err = ec.unmarshalOOuterInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOuterInput(ctx, vSlice[i])
23146 if err != nil {
23147 return nil, err
23148 }
23149 }
23150 return res, nil
23151 }
23152
23153 func (ec *executionContext) unmarshalOOuterInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOuterInput(ctx context.Context, v interface{}) ([]*OuterInput, error) {
23154 if v == nil {
23155 return nil, nil
23156 }
23157 var vSlice []interface{}
23158 if v != nil {
23159 vSlice = graphql.CoerceList(v)
23160 }
23161 var err error
23162 res := make([]*OuterInput, len(vSlice))
23163 for i := range vSlice {
23164 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
23165 res[i], err = ec.unmarshalOOuterInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOuterInput(ctx, vSlice[i])
23166 if err != nil {
23167 return nil, err
23168 }
23169 }
23170 return res, nil
23171 }
23172
23173 func (ec *executionContext) unmarshalOOuterInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOuterInput(ctx context.Context, v interface{}) (*OuterInput, error) {
23174 if v == nil {
23175 return nil, nil
23176 }
23177 res, err := ec.unmarshalInputOuterInput(ctx, v)
23178 return &res, graphql.ErrorOnPath(ctx, err)
23179 }
23180
23181 func (ec *executionContext) marshalOOuterObject2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOuterObject(ctx context.Context, sel ast.SelectionSet, v [][]*OuterObject) graphql.Marshaler {
23182 if v == nil {
23183 return graphql.Null
23184 }
23185 ret := make(graphql.Array, len(v))
23186 var wg sync.WaitGroup
23187 isLen1 := len(v) == 1
23188 if !isLen1 {
23189 wg.Add(len(v))
23190 }
23191 for i := range v {
23192 i := i
23193 fc := &graphql.FieldContext{
23194 Index: &i,
23195 Result: &v[i],
23196 }
23197 ctx := graphql.WithFieldContext(ctx, fc)
23198 f := func(i int) {
23199 defer func() {
23200 if r := recover(); r != nil {
23201 ec.Error(ctx, ec.Recover(ctx, r))
23202 ret = nil
23203 }
23204 }()
23205 if !isLen1 {
23206 defer wg.Done()
23207 }
23208 ret[i] = ec.marshalOOuterObject2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOuterObject(ctx, sel, v[i])
23209 }
23210 if isLen1 {
23211 f(i)
23212 } else {
23213 go f(i)
23214 }
23215
23216 }
23217 wg.Wait()
23218
23219 return ret
23220 }
23221
23222 func (ec *executionContext) marshalOOuterObject2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOuterObject(ctx context.Context, sel ast.SelectionSet, v []*OuterObject) graphql.Marshaler {
23223 if v == nil {
23224 return graphql.Null
23225 }
23226 ret := make(graphql.Array, len(v))
23227 var wg sync.WaitGroup
23228 isLen1 := len(v) == 1
23229 if !isLen1 {
23230 wg.Add(len(v))
23231 }
23232 for i := range v {
23233 i := i
23234 fc := &graphql.FieldContext{
23235 Index: &i,
23236 Result: &v[i],
23237 }
23238 ctx := graphql.WithFieldContext(ctx, fc)
23239 f := func(i int) {
23240 defer func() {
23241 if r := recover(); r != nil {
23242 ec.Error(ctx, ec.Recover(ctx, r))
23243 ret = nil
23244 }
23245 }()
23246 if !isLen1 {
23247 defer wg.Done()
23248 }
23249 ret[i] = ec.marshalOOuterObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOuterObject(ctx, sel, v[i])
23250 }
23251 if isLen1 {
23252 f(i)
23253 } else {
23254 go f(i)
23255 }
23256
23257 }
23258 wg.Wait()
23259
23260 return ret
23261 }
23262
23263 func (ec *executionContext) marshalOOuterObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOuterObject(ctx context.Context, sel ast.SelectionSet, v *OuterObject) graphql.Marshaler {
23264 if v == nil {
23265 return graphql.Null
23266 }
23267 return ec._OuterObject(ctx, sel, v)
23268 }
23269
23270 func (ec *executionContext) marshalOOverlappingFields2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐOverlappingFields(ctx context.Context, sel ast.SelectionSet, v *OverlappingFields) graphql.Marshaler {
23271 if v == nil {
23272 return graphql.Null
23273 }
23274 return ec._OverlappingFields(ctx, sel, v)
23275 }
23276
23277 func (ec *executionContext) marshalOPanics2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPanics(ctx context.Context, sel ast.SelectionSet, v *Panics) graphql.Marshaler {
23278 if v == nil {
23279 return graphql.Null
23280 }
23281 return ec._Panics(ctx, sel, v)
23282 }
23283
23284 func (ec *executionContext) marshalOPet2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPetᚄ(ctx context.Context, sel ast.SelectionSet, v []*Pet) graphql.Marshaler {
23285 if v == nil {
23286 return graphql.Null
23287 }
23288 ret := make(graphql.Array, len(v))
23289 var wg sync.WaitGroup
23290 isLen1 := len(v) == 1
23291 if !isLen1 {
23292 wg.Add(len(v))
23293 }
23294 for i := range v {
23295 i := i
23296 fc := &graphql.FieldContext{
23297 Index: &i,
23298 Result: &v[i],
23299 }
23300 ctx := graphql.WithFieldContext(ctx, fc)
23301 f := func(i int) {
23302 defer func() {
23303 if r := recover(); r != nil {
23304 ec.Error(ctx, ec.Recover(ctx, r))
23305 ret = nil
23306 }
23307 }()
23308 if !isLen1 {
23309 defer wg.Done()
23310 }
23311 ret[i] = ec.marshalNPet2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPet(ctx, sel, v[i])
23312 }
23313 if isLen1 {
23314 f(i)
23315 } else {
23316 go f(i)
23317 }
23318
23319 }
23320 wg.Wait()
23321
23322 for _, e := range ret {
23323 if e == graphql.Null {
23324 return graphql.Null
23325 }
23326 }
23327
23328 return ret
23329 }
23330
23331 func (ec *executionContext) marshalOPtrToPtrInner2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrInner(ctx context.Context, sel ast.SelectionSet, v *PtrToPtrInner) graphql.Marshaler {
23332 if v == nil {
23333 return graphql.Null
23334 }
23335 return ec._PtrToPtrInner(ctx, sel, v)
23336 }
23337
23338 func (ec *executionContext) marshalOPtrToPtrInner2ᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrInner(ctx context.Context, sel ast.SelectionSet, v **PtrToPtrInner) graphql.Marshaler {
23339 if v == nil {
23340 return graphql.Null
23341 }
23342 return ec.marshalOPtrToPtrInner2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrInner(ctx, sel, *v)
23343 }
23344
23345 func (ec *executionContext) marshalOPtrToPtrInner2ᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrInner(ctx context.Context, sel ast.SelectionSet, v ***PtrToPtrInner) graphql.Marshaler {
23346 if v == nil {
23347 return graphql.Null
23348 }
23349 return ec.marshalOPtrToPtrInner2ᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrInner(ctx, sel, *v)
23350 }
23351
23352 func (ec *executionContext) marshalOPtrToPtrInner2ᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrInner(ctx context.Context, sel ast.SelectionSet, v ****PtrToPtrInner) graphql.Marshaler {
23353 if v == nil {
23354 return graphql.Null
23355 }
23356 return ec.marshalOPtrToPtrInner2ᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrInner(ctx, sel, *v)
23357 }
23358
23359 func (ec *executionContext) marshalOPtrToPtrInner2ᚖᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrInner(ctx context.Context, sel ast.SelectionSet, v *****PtrToPtrInner) graphql.Marshaler {
23360 if v == nil {
23361 return graphql.Null
23362 }
23363 return ec.marshalOPtrToPtrInner2ᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrInner(ctx, sel, *v)
23364 }
23365
23366 func (ec *executionContext) marshalOPtrToPtrInner2ᚖᚖᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrInner(ctx context.Context, sel ast.SelectionSet, v ******PtrToPtrInner) graphql.Marshaler {
23367 if v == nil {
23368 return graphql.Null
23369 }
23370 return ec.marshalOPtrToPtrInner2ᚖᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrInner(ctx, sel, *v)
23371 }
23372
23373 func (ec *executionContext) marshalOPtrToPtrInner2ᚖᚖᚖᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrInner(ctx context.Context, sel ast.SelectionSet, v *******PtrToPtrInner) graphql.Marshaler {
23374 if v == nil {
23375 return graphql.Null
23376 }
23377 return ec.marshalOPtrToPtrInner2ᚖᚖᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐPtrToPtrInner(ctx, sel, *v)
23378 }
23379
23380 func (ec *executionContext) unmarshalORecursiveInputSlice2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐRecursiveInputSliceᚄ(ctx context.Context, v interface{}) ([]RecursiveInputSlice, error) {
23381 if v == nil {
23382 return nil, nil
23383 }
23384 var vSlice []interface{}
23385 if v != nil {
23386 vSlice = graphql.CoerceList(v)
23387 }
23388 var err error
23389 res := make([]RecursiveInputSlice, len(vSlice))
23390 for i := range vSlice {
23391 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
23392 res[i], err = ec.unmarshalNRecursiveInputSlice2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐRecursiveInputSlice(ctx, vSlice[i])
23393 if err != nil {
23394 return nil, err
23395 }
23396 }
23397 return res, nil
23398 }
23399
23400 func (ec *executionContext) unmarshalORecursiveInputSlice2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐRecursiveInputSlice(ctx context.Context, v interface{}) (*RecursiveInputSlice, error) {
23401 if v == nil {
23402 return nil, nil
23403 }
23404 res, err := ec.unmarshalInputRecursiveInputSlice(ctx, v)
23405 return &res, graphql.ErrorOnPath(ctx, err)
23406 }
23407
23408 func (ec *executionContext) marshalOShape2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐShape(ctx context.Context, sel ast.SelectionSet, v Shape) graphql.Marshaler {
23409 if v == nil {
23410 return graphql.Null
23411 }
23412 return ec._Shape(ctx, sel, v)
23413 }
23414
23415 func (ec *executionContext) marshalOShape2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐShape(ctx context.Context, sel ast.SelectionSet, v []Shape) graphql.Marshaler {
23416 if v == nil {
23417 return graphql.Null
23418 }
23419 ret := make(graphql.Array, len(v))
23420 var wg sync.WaitGroup
23421 isLen1 := len(v) == 1
23422 if !isLen1 {
23423 wg.Add(len(v))
23424 }
23425 for i := range v {
23426 i := i
23427 fc := &graphql.FieldContext{
23428 Index: &i,
23429 Result: &v[i],
23430 }
23431 ctx := graphql.WithFieldContext(ctx, fc)
23432 f := func(i int) {
23433 defer func() {
23434 if r := recover(); r != nil {
23435 ec.Error(ctx, ec.Recover(ctx, r))
23436 ret = nil
23437 }
23438 }()
23439 if !isLen1 {
23440 defer wg.Done()
23441 }
23442 ret[i] = ec.marshalOShape2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐShape(ctx, sel, v[i])
23443 }
23444 if isLen1 {
23445 f(i)
23446 } else {
23447 go f(i)
23448 }
23449
23450 }
23451 wg.Wait()
23452
23453 return ret
23454 }
23455
23456 func (ec *executionContext) marshalOSlices2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐSlices(ctx context.Context, sel ast.SelectionSet, v *Slices) graphql.Marshaler {
23457 if v == nil {
23458 return graphql.Null
23459 }
23460 return ec._Slices(ctx, sel, v)
23461 }
23462
23463 func (ec *executionContext) unmarshalOStatus2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐStatus(ctx context.Context, v interface{}) (*Status, error) {
23464 if v == nil {
23465 return nil, nil
23466 }
23467 var res = new(Status)
23468 err := res.UnmarshalGQL(v)
23469 return res, graphql.ErrorOnPath(ctx, err)
23470 }
23471
23472 func (ec *executionContext) marshalOStatus2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐStatus(ctx context.Context, sel ast.SelectionSet, v *Status) graphql.Marshaler {
23473 if v == nil {
23474 return graphql.Null
23475 }
23476 return v
23477 }
23478
23479 func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
23480 res, err := graphql.UnmarshalString(v)
23481 return res, graphql.ErrorOnPath(ctx, err)
23482 }
23483
23484 func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
23485 res := graphql.MarshalString(v)
23486 return res
23487 }
23488
23489 func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
23490 if v == nil {
23491 return nil, nil
23492 }
23493 var vSlice []interface{}
23494 if v != nil {
23495 vSlice = graphql.CoerceList(v)
23496 }
23497 var err error
23498 res := make([]string, len(vSlice))
23499 for i := range vSlice {
23500 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
23501 res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
23502 if err != nil {
23503 return nil, err
23504 }
23505 }
23506 return res, nil
23507 }
23508
23509 func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
23510 if v == nil {
23511 return graphql.Null
23512 }
23513 ret := make(graphql.Array, len(v))
23514 for i := range v {
23515 ret[i] = ec.marshalNString2string(ctx, sel, v[i])
23516 }
23517
23518 for _, e := range ret {
23519 if e == graphql.Null {
23520 return graphql.Null
23521 }
23522 }
23523
23524 return ret
23525 }
23526
23527 func (ec *executionContext) unmarshalOString2ᚕᚖstring(ctx context.Context, v interface{}) ([]*string, error) {
23528 if v == nil {
23529 return nil, nil
23530 }
23531 var vSlice []interface{}
23532 if v != nil {
23533 vSlice = graphql.CoerceList(v)
23534 }
23535 var err error
23536 res := make([]*string, len(vSlice))
23537 for i := range vSlice {
23538 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
23539 res[i], err = ec.unmarshalOString2ᚖstring(ctx, vSlice[i])
23540 if err != nil {
23541 return nil, err
23542 }
23543 }
23544 return res, nil
23545 }
23546
23547 func (ec *executionContext) marshalOString2ᚕᚖstring(ctx context.Context, sel ast.SelectionSet, v []*string) graphql.Marshaler {
23548 if v == nil {
23549 return graphql.Null
23550 }
23551 ret := make(graphql.Array, len(v))
23552 for i := range v {
23553 ret[i] = ec.marshalOString2ᚖstring(ctx, sel, v[i])
23554 }
23555
23556 return ret
23557 }
23558
23559 func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
23560 if v == nil {
23561 return nil, nil
23562 }
23563 res, err := graphql.UnmarshalString(v)
23564 return &res, graphql.ErrorOnPath(ctx, err)
23565 }
23566
23567 func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
23568 if v == nil {
23569 return graphql.Null
23570 }
23571 res := graphql.MarshalString(*v)
23572 return res
23573 }
23574
23575 func (ec *executionContext) unmarshalOString2ᚖᚕstringᚄ(ctx context.Context, v interface{}) (*[]string, error) {
23576 if v == nil {
23577 return nil, nil
23578 }
23579 res, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v)
23580 return &res, graphql.ErrorOnPath(ctx, err)
23581 }
23582
23583 func (ec *executionContext) marshalOString2ᚖᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v *[]string) graphql.Marshaler {
23584 return ec.marshalOString2ᚕstringᚄ(ctx, sel, *v)
23585 }
23586
23587 func (ec *executionContext) marshalOTestUnion2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐTestUnion(ctx context.Context, sel ast.SelectionSet, v TestUnion) graphql.Marshaler {
23588 if v == nil {
23589 return graphql.Null
23590 }
23591 return ec._TestUnion(ctx, sel, v)
23592 }
23593
23594 func (ec *executionContext) unmarshalOThirdParty2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐThirdParty(ctx context.Context, v interface{}) (*ThirdParty, error) {
23595 if v == nil {
23596 return nil, nil
23597 }
23598 res, err := UnmarshalThirdParty(v)
23599 return &res, graphql.ErrorOnPath(ctx, err)
23600 }
23601
23602 func (ec *executionContext) marshalOThirdParty2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐThirdParty(ctx context.Context, sel ast.SelectionSet, v *ThirdParty) graphql.Marshaler {
23603 if v == nil {
23604 return graphql.Null
23605 }
23606 res := MarshalThirdParty(*v)
23607 return res
23608 }
23609
23610 func (ec *executionContext) unmarshalOTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
23611 if v == nil {
23612 return nil, nil
23613 }
23614 res, err := graphql.UnmarshalTime(v)
23615 return &res, graphql.ErrorOnPath(ctx, err)
23616 }
23617
23618 func (ec *executionContext) marshalOTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
23619 if v == nil {
23620 return graphql.Null
23621 }
23622 res := graphql.MarshalTime(*v)
23623 return res
23624 }
23625
23626 func (ec *executionContext) unmarshalOUpdatePtrToPtrInner2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx context.Context, v interface{}) (*UpdatePtrToPtrInner, error) {
23627 if v == nil {
23628 return nil, nil
23629 }
23630 res, err := ec.unmarshalInputUpdatePtrToPtrInner(ctx, v)
23631 return &res, graphql.ErrorOnPath(ctx, err)
23632 }
23633
23634 func (ec *executionContext) unmarshalOUpdatePtrToPtrInner2ᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx context.Context, v interface{}) (**UpdatePtrToPtrInner, error) {
23635 var pres *UpdatePtrToPtrInner
23636 if v != nil {
23637 res, err := ec.unmarshalOUpdatePtrToPtrInner2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx, v)
23638 if err != nil {
23639 return nil, graphql.ErrorOnPath(ctx, err)
23640 }
23641 pres = res
23642 }
23643 return &pres, nil
23644 }
23645
23646 func (ec *executionContext) unmarshalOUpdatePtrToPtrInner2ᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx context.Context, v interface{}) (***UpdatePtrToPtrInner, error) {
23647 var pres **UpdatePtrToPtrInner
23648 if v != nil {
23649 res, err := ec.unmarshalOUpdatePtrToPtrInner2ᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx, v)
23650 if err != nil {
23651 return nil, graphql.ErrorOnPath(ctx, err)
23652 }
23653 pres = res
23654 }
23655 return &pres, nil
23656 }
23657
23658 func (ec *executionContext) unmarshalOUpdatePtrToPtrInner2ᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx context.Context, v interface{}) (****UpdatePtrToPtrInner, error) {
23659 var pres ***UpdatePtrToPtrInner
23660 if v != nil {
23661 res, err := ec.unmarshalOUpdatePtrToPtrInner2ᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx, v)
23662 if err != nil {
23663 return nil, graphql.ErrorOnPath(ctx, err)
23664 }
23665 pres = res
23666 }
23667 return &pres, nil
23668 }
23669
23670 func (ec *executionContext) unmarshalOUpdatePtrToPtrInner2ᚖᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx context.Context, v interface{}) (*****UpdatePtrToPtrInner, error) {
23671 var pres ****UpdatePtrToPtrInner
23672 if v != nil {
23673 res, err := ec.unmarshalOUpdatePtrToPtrInner2ᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx, v)
23674 if err != nil {
23675 return nil, graphql.ErrorOnPath(ctx, err)
23676 }
23677 pres = res
23678 }
23679 return &pres, nil
23680 }
23681
23682 func (ec *executionContext) unmarshalOUpdatePtrToPtrInner2ᚖᚖᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx context.Context, v interface{}) (******UpdatePtrToPtrInner, error) {
23683 var pres *****UpdatePtrToPtrInner
23684 if v != nil {
23685 res, err := ec.unmarshalOUpdatePtrToPtrInner2ᚖᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx, v)
23686 if err != nil {
23687 return nil, graphql.ErrorOnPath(ctx, err)
23688 }
23689 pres = res
23690 }
23691 return &pres, nil
23692 }
23693
23694 func (ec *executionContext) unmarshalOUpdatePtrToPtrInner2ᚖᚖᚖᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx context.Context, v interface{}) (*******UpdatePtrToPtrInner, error) {
23695 var pres ******UpdatePtrToPtrInner
23696 if v != nil {
23697 res, err := ec.unmarshalOUpdatePtrToPtrInner2ᚖᚖᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx, v)
23698 if err != nil {
23699 return nil, graphql.ErrorOnPath(ctx, err)
23700 }
23701 pres = res
23702 }
23703 return &pres, nil
23704 }
23705
23706 func (ec *executionContext) unmarshalOUpdatePtrToPtrInner2ᚖᚖᚖᚖᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx context.Context, v interface{}) (********UpdatePtrToPtrInner, error) {
23707 var pres *******UpdatePtrToPtrInner
23708 if v != nil {
23709 res, err := ec.unmarshalOUpdatePtrToPtrInner2ᚖᚖᚖᚖᚖᚖᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐUpdatePtrToPtrInner(ctx, v)
23710 if err != nil {
23711 return nil, graphql.ErrorOnPath(ctx, err)
23712 }
23713 pres = res
23714 }
23715 return &pres, nil
23716 }
23717
23718 func (ec *executionContext) marshalOVOkCaseNil2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐVOkCaseNil(ctx context.Context, sel ast.SelectionSet, v *VOkCaseNil) graphql.Marshaler {
23719 if v == nil {
23720 return graphql.Null
23721 }
23722 return ec._VOkCaseNil(ctx, sel, v)
23723 }
23724
23725 func (ec *executionContext) marshalOVOkCaseValue2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐVOkCaseValue(ctx context.Context, sel ast.SelectionSet, v *VOkCaseValue) graphql.Marshaler {
23726 if v == nil {
23727 return graphql.Null
23728 }
23729 return ec._VOkCaseValue(ctx, sel, v)
23730 }
23731
23732 func (ec *executionContext) unmarshalOValidInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐValidInput(ctx context.Context, v interface{}) (*ValidInput, error) {
23733 if v == nil {
23734 return nil, nil
23735 }
23736 res, err := ec.unmarshalInputValidInput(ctx, v)
23737 return &res, graphql.ErrorOnPath(ctx, err)
23738 }
23739
23740 func (ec *executionContext) marshalOValidType2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐValidType(ctx context.Context, sel ast.SelectionSet, v *ValidType) graphql.Marshaler {
23741 if v == nil {
23742 return graphql.Null
23743 }
23744 return ec._ValidType(ctx, sel, v)
23745 }
23746
23747 func (ec *executionContext) marshalOVariadicModel2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚐVariadicModel(ctx context.Context, sel ast.SelectionSet, v *VariadicModel) graphql.Marshaler {
23748 if v == nil {
23749 return graphql.Null
23750 }
23751 return ec._VariadicModel(ctx, sel, v)
23752 }
23753
23754 func (ec *executionContext) unmarshalOWrappedScalar2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚋotherpkgᚐScalar(ctx context.Context, v interface{}) (*otherpkg.Scalar, error) {
23755 if v == nil {
23756 return nil, nil
23757 }
23758 tmp, err := graphql.UnmarshalString(v)
23759 res := otherpkg.Scalar(tmp)
23760 return &res, graphql.ErrorOnPath(ctx, err)
23761 }
23762
23763 func (ec *executionContext) marshalOWrappedScalar2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋsinglefileᚋotherpkgᚐScalar(ctx context.Context, sel ast.SelectionSet, v *otherpkg.Scalar) graphql.Marshaler {
23764 if v == nil {
23765 return graphql.Null
23766 }
23767 res := graphql.MarshalString(string(*v))
23768 return res
23769 }
23770
23771 func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
23772 if v == nil {
23773 return graphql.Null
23774 }
23775 ret := make(graphql.Array, len(v))
23776 var wg sync.WaitGroup
23777 isLen1 := len(v) == 1
23778 if !isLen1 {
23779 wg.Add(len(v))
23780 }
23781 for i := range v {
23782 i := i
23783 fc := &graphql.FieldContext{
23784 Index: &i,
23785 Result: &v[i],
23786 }
23787 ctx := graphql.WithFieldContext(ctx, fc)
23788 f := func(i int) {
23789 defer func() {
23790 if r := recover(); r != nil {
23791 ec.Error(ctx, ec.Recover(ctx, r))
23792 ret = nil
23793 }
23794 }()
23795 if !isLen1 {
23796 defer wg.Done()
23797 }
23798 ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
23799 }
23800 if isLen1 {
23801 f(i)
23802 } else {
23803 go f(i)
23804 }
23805
23806 }
23807 wg.Wait()
23808
23809 for _, e := range ret {
23810 if e == graphql.Null {
23811 return graphql.Null
23812 }
23813 }
23814
23815 return ret
23816 }
23817
23818 func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
23819 if v == nil {
23820 return graphql.Null
23821 }
23822 ret := make(graphql.Array, len(v))
23823 var wg sync.WaitGroup
23824 isLen1 := len(v) == 1
23825 if !isLen1 {
23826 wg.Add(len(v))
23827 }
23828 for i := range v {
23829 i := i
23830 fc := &graphql.FieldContext{
23831 Index: &i,
23832 Result: &v[i],
23833 }
23834 ctx := graphql.WithFieldContext(ctx, fc)
23835 f := func(i int) {
23836 defer func() {
23837 if r := recover(); r != nil {
23838 ec.Error(ctx, ec.Recover(ctx, r))
23839 ret = nil
23840 }
23841 }()
23842 if !isLen1 {
23843 defer wg.Done()
23844 }
23845 ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
23846 }
23847 if isLen1 {
23848 f(i)
23849 } else {
23850 go f(i)
23851 }
23852
23853 }
23854 wg.Wait()
23855
23856 for _, e := range ret {
23857 if e == graphql.Null {
23858 return graphql.Null
23859 }
23860 }
23861
23862 return ret
23863 }
23864
23865 func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
23866 if v == nil {
23867 return graphql.Null
23868 }
23869 ret := make(graphql.Array, len(v))
23870 var wg sync.WaitGroup
23871 isLen1 := len(v) == 1
23872 if !isLen1 {
23873 wg.Add(len(v))
23874 }
23875 for i := range v {
23876 i := i
23877 fc := &graphql.FieldContext{
23878 Index: &i,
23879 Result: &v[i],
23880 }
23881 ctx := graphql.WithFieldContext(ctx, fc)
23882 f := func(i int) {
23883 defer func() {
23884 if r := recover(); r != nil {
23885 ec.Error(ctx, ec.Recover(ctx, r))
23886 ret = nil
23887 }
23888 }()
23889 if !isLen1 {
23890 defer wg.Done()
23891 }
23892 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
23893 }
23894 if isLen1 {
23895 f(i)
23896 } else {
23897 go f(i)
23898 }
23899
23900 }
23901 wg.Wait()
23902
23903 for _, e := range ret {
23904 if e == graphql.Null {
23905 return graphql.Null
23906 }
23907 }
23908
23909 return ret
23910 }
23911
23912 func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
23913 if v == nil {
23914 return graphql.Null
23915 }
23916 return ec.___Schema(ctx, sel, v)
23917 }
23918
23919 func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
23920 if v == nil {
23921 return graphql.Null
23922 }
23923 ret := make(graphql.Array, len(v))
23924 var wg sync.WaitGroup
23925 isLen1 := len(v) == 1
23926 if !isLen1 {
23927 wg.Add(len(v))
23928 }
23929 for i := range v {
23930 i := i
23931 fc := &graphql.FieldContext{
23932 Index: &i,
23933 Result: &v[i],
23934 }
23935 ctx := graphql.WithFieldContext(ctx, fc)
23936 f := func(i int) {
23937 defer func() {
23938 if r := recover(); r != nil {
23939 ec.Error(ctx, ec.Recover(ctx, r))
23940 ret = nil
23941 }
23942 }()
23943 if !isLen1 {
23944 defer wg.Done()
23945 }
23946 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
23947 }
23948 if isLen1 {
23949 f(i)
23950 } else {
23951 go f(i)
23952 }
23953
23954 }
23955 wg.Wait()
23956
23957 for _, e := range ret {
23958 if e == graphql.Null {
23959 return graphql.Null
23960 }
23961 }
23962
23963 return ret
23964 }
23965
23966 func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
23967 if v == nil {
23968 return graphql.Null
23969 }
23970 return ec.___Type(ctx, sel, v)
23971 }
23972
23973
23974
View as plain text