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