github.com/luciferinlove/gqlgen@v0.17.16-bzc.1/codegen/testserver/followschema/schema.generated.go (about) 1 // Code generated by github.com/luciferinlove/gqlgen, DO NOT EDIT. 2 3 package followschema 4 5 import ( 6 "context" 7 "errors" 8 "fmt" 9 "io" 10 "strconv" 11 "sync" 12 "sync/atomic" 13 "time" 14 15 introspection1 "github.com/luciferinlove/gqlgen/codegen/testserver/followschema/introspection" 16 invalid_packagename "github.com/luciferinlove/gqlgen/codegen/testserver/followschema/invalid-packagename" 17 "github.com/luciferinlove/gqlgen/codegen/testserver/followschema/otherpkg" 18 "github.com/luciferinlove/gqlgen/graphql" 19 "github.com/luciferinlove/gqlgen/graphql/introspection" 20 "github.com/vektah/gqlparser/v2/ast" 21 ) 22 23 // region ************************** generated!.gotpl ************************** 24 25 type ForcedResolverResolver interface { 26 Field(ctx context.Context, obj *ForcedResolver) (*Circle, error) 27 } 28 type ModelMethodsResolver interface { 29 ResolverField(ctx context.Context, obj *ModelMethods) (bool, error) 30 } 31 type PetResolver interface { 32 Friends(ctx context.Context, obj *Pet, limit *int) ([]*Pet, error) 33 } 34 type QueryResolver interface { 35 InvalidIdentifier(ctx context.Context) (*invalid_packagename.InvalidIdentifier, error) 36 Collision(ctx context.Context) (*introspection1.It, error) 37 MapInput(ctx context.Context, input map[string]interface{}) (*bool, error) 38 Recursive(ctx context.Context, input *RecursiveInputSlice) (*bool, error) 39 NestedInputs(ctx context.Context, input [][]*OuterInput) (*bool, error) 40 NestedOutputs(ctx context.Context) ([][]*OuterObject, error) 41 ModelMethods(ctx context.Context) (*ModelMethods, error) 42 User(ctx context.Context, id int) (*User, error) 43 NullableArg(ctx context.Context, arg *int) (*string, error) 44 InputSlice(ctx context.Context, arg []string) (bool, error) 45 InputNullableSlice(ctx context.Context, arg []string) (bool, error) 46 ShapeUnion(ctx context.Context) (ShapeUnion, error) 47 Autobind(ctx context.Context) (*Autobind, error) 48 DeprecatedField(ctx context.Context) (string, error) 49 Overlapping(ctx context.Context) (*OverlappingFields, error) 50 DefaultParameters(ctx context.Context, falsyBoolean *bool, truthyBoolean *bool) (*DefaultParametersMirror, error) 51 DirectiveArg(ctx context.Context, arg string) (*string, error) 52 DirectiveNullableArg(ctx context.Context, arg *int, arg2 *int, arg3 *string) (*string, error) 53 DirectiveInputNullable(ctx context.Context, arg *InputDirectives) (*string, error) 54 DirectiveInput(ctx context.Context, arg InputDirectives) (*string, error) 55 DirectiveInputType(ctx context.Context, arg InnerInput) (*string, error) 56 DirectiveObject(ctx context.Context) (*ObjectDirectives, error) 57 DirectiveObjectWithCustomGoModel(ctx context.Context) (*ObjectDirectivesWithCustomGoModel, error) 58 DirectiveFieldDef(ctx context.Context, ret string) (string, error) 59 DirectiveField(ctx context.Context) (*string, error) 60 DirectiveDouble(ctx context.Context) (*string, error) 61 DirectiveUnimplemented(ctx context.Context) (*string, error) 62 EmbeddedCase1(ctx context.Context) (*EmbeddedCase1, error) 63 EmbeddedCase2(ctx context.Context) (*EmbeddedCase2, error) 64 EmbeddedCase3(ctx context.Context) (*EmbeddedCase3, error) 65 EnumInInput(ctx context.Context, input *InputWithEnumValue) (EnumTest, error) 66 Shapes(ctx context.Context) ([]Shape, error) 67 NoShape(ctx context.Context) (Shape, error) 68 Node(ctx context.Context) (Node, error) 69 NoShapeTypedNil(ctx context.Context) (Shape, error) 70 Animal(ctx context.Context) (Animal, error) 71 NotAnInterface(ctx context.Context) (BackedByInterface, error) 72 Issue896a(ctx context.Context) ([]*CheckIssue896, error) 73 MapStringInterface(ctx context.Context, in map[string]interface{}) (map[string]interface{}, error) 74 MapNestedStringInterface(ctx context.Context, in *NestedMapInput) (map[string]interface{}, error) 75 ErrorBubble(ctx context.Context) (*Error, error) 76 ErrorBubbleList(ctx context.Context) ([]*Error, error) 77 ErrorList(ctx context.Context) ([]*Error, error) 78 Errors(ctx context.Context) (*Errors, error) 79 Valid(ctx context.Context) (string, error) 80 Panics(ctx context.Context) (*Panics, error) 81 PrimitiveObject(ctx context.Context) ([]Primitive, error) 82 PrimitiveStringObject(ctx context.Context) ([]PrimitiveString, error) 83 PtrToSliceContainer(ctx context.Context) (*PtrToSliceContainer, error) 84 Infinity(ctx context.Context) (float64, error) 85 StringFromContextInterface(ctx context.Context) (*StringFromContextInterface, error) 86 StringFromContextFunction(ctx context.Context) (string, error) 87 DefaultScalar(ctx context.Context, arg string) (string, error) 88 Slices(ctx context.Context) (*Slices, error) 89 ScalarSlice(ctx context.Context) ([]byte, error) 90 Fallback(ctx context.Context, arg FallbackToStringEncoding) (FallbackToStringEncoding, error) 91 OptionalUnion(ctx context.Context) (TestUnion, error) 92 VOkCaseValue(ctx context.Context) (*VOkCaseValue, error) 93 VOkCaseNil(ctx context.Context) (*VOkCaseNil, error) 94 ValidType(ctx context.Context) (*ValidType, error) 95 VariadicModel(ctx context.Context) (*VariadicModel, error) 96 WrappedStruct(ctx context.Context) (*WrappedStruct, error) 97 WrappedScalar(ctx context.Context) (otherpkg.Scalar, error) 98 WrappedMap(ctx context.Context) (WrappedMap, error) 99 WrappedSlice(ctx context.Context) (WrappedSlice, error) 100 } 101 type SubscriptionResolver interface { 102 Updated(ctx context.Context) (<-chan string, error) 103 InitPayload(ctx context.Context) (<-chan string, error) 104 DirectiveArg(ctx context.Context, arg string) (<-chan *string, error) 105 DirectiveNullableArg(ctx context.Context, arg *int, arg2 *int, arg3 *string) (<-chan *string, error) 106 DirectiveDouble(ctx context.Context) (<-chan *string, error) 107 DirectiveUnimplemented(ctx context.Context) (<-chan *string, error) 108 Issue896b(ctx context.Context) (<-chan []*CheckIssue896, error) 109 ErrorRequired(ctx context.Context) (<-chan *Error, error) 110 } 111 type UserResolver interface { 112 Friends(ctx context.Context, obj *User) ([]*User, error) 113 114 Pets(ctx context.Context, obj *User, limit *int) ([]*Pet, error) 115 } 116 117 // endregion ************************** generated!.gotpl ************************** 118 119 // region ***************************** args.gotpl ***************************** 120 121 func (ec *executionContext) field_Pet_friends_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 122 var err error 123 args := map[string]interface{}{} 124 var arg0 *int 125 if tmp, ok := rawArgs["limit"]; ok { 126 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit")) 127 arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp) 128 if err != nil { 129 return nil, err 130 } 131 } 132 args["limit"] = arg0 133 return args, nil 134 } 135 136 func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 137 var err error 138 args := map[string]interface{}{} 139 var arg0 string 140 if tmp, ok := rawArgs["name"]; ok { 141 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) 142 arg0, err = ec.unmarshalNString2string(ctx, tmp) 143 if err != nil { 144 return nil, err 145 } 146 } 147 args["name"] = arg0 148 return args, nil 149 } 150 151 func (ec *executionContext) field_Query_defaultParameters_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 152 var err error 153 args := map[string]interface{}{} 154 var arg0 *bool 155 if tmp, ok := rawArgs["falsyBoolean"]; ok { 156 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("falsyBoolean")) 157 arg0, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp) 158 if err != nil { 159 return nil, err 160 } 161 } 162 args["falsyBoolean"] = arg0 163 var arg1 *bool 164 if tmp, ok := rawArgs["truthyBoolean"]; ok { 165 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("truthyBoolean")) 166 arg1, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp) 167 if err != nil { 168 return nil, err 169 } 170 } 171 args["truthyBoolean"] = arg1 172 return args, nil 173 } 174 175 func (ec *executionContext) field_Query_defaultScalar_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 176 var err error 177 args := map[string]interface{}{} 178 var arg0 string 179 if tmp, ok := rawArgs["arg"]; ok { 180 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg")) 181 arg0, err = ec.unmarshalNDefaultScalarImplementation2string(ctx, tmp) 182 if err != nil { 183 return nil, err 184 } 185 } 186 args["arg"] = arg0 187 return args, nil 188 } 189 190 func (ec *executionContext) field_Query_directiveArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 191 var err error 192 args := map[string]interface{}{} 193 var arg0 string 194 if tmp, ok := rawArgs["arg"]; ok { 195 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg")) 196 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalNString2string(ctx, tmp) } 197 directive1 := func(ctx context.Context) (interface{}, error) { 198 min, err := ec.unmarshalNInt2int(ctx, 1) 199 if err != nil { 200 return nil, err 201 } 202 max, err := ec.unmarshalOInt2ᚖint(ctx, 255) 203 if err != nil { 204 return nil, err 205 } 206 message, err := ec.unmarshalOString2ᚖstring(ctx, "invalid length") 207 if err != nil { 208 return nil, err 209 } 210 if ec.directives.Length == nil { 211 return nil, errors.New("directive length is not implemented") 212 } 213 return ec.directives.Length(ctx, rawArgs, directive0, min, max, message) 214 } 215 216 tmp, err = directive1(ctx) 217 if err != nil { 218 return nil, graphql.ErrorOnPath(ctx, err) 219 } 220 if data, ok := tmp.(string); ok { 221 arg0 = data 222 } else { 223 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp)) 224 } 225 } 226 args["arg"] = arg0 227 return args, nil 228 } 229 230 func (ec *executionContext) field_Query_directiveFieldDef_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 231 var err error 232 args := map[string]interface{}{} 233 var arg0 string 234 if tmp, ok := rawArgs["ret"]; ok { 235 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ret")) 236 arg0, err = ec.unmarshalNString2string(ctx, tmp) 237 if err != nil { 238 return nil, err 239 } 240 } 241 args["ret"] = arg0 242 return args, nil 243 } 244 245 func (ec *executionContext) field_Query_directiveInputNullable_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 246 var err error 247 args := map[string]interface{}{} 248 var arg0 *InputDirectives 249 if tmp, ok := rawArgs["arg"]; ok { 250 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg")) 251 arg0, err = ec.unmarshalOInputDirectives2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInputDirectives(ctx, tmp) 252 if err != nil { 253 return nil, err 254 } 255 } 256 args["arg"] = arg0 257 return args, nil 258 } 259 260 func (ec *executionContext) field_Query_directiveInputType_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 261 var err error 262 args := map[string]interface{}{} 263 var arg0 InnerInput 264 if tmp, ok := rawArgs["arg"]; ok { 265 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg")) 266 directive0 := func(ctx context.Context) (interface{}, error) { 267 return ec.unmarshalNInnerInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerInput(ctx, tmp) 268 } 269 directive1 := func(ctx context.Context) (interface{}, error) { 270 if ec.directives.Custom == nil { 271 return nil, errors.New("directive custom is not implemented") 272 } 273 return ec.directives.Custom(ctx, rawArgs, directive0) 274 } 275 276 tmp, err = directive1(ctx) 277 if err != nil { 278 return nil, graphql.ErrorOnPath(ctx, err) 279 } 280 if data, ok := tmp.(InnerInput); ok { 281 arg0 = data 282 } else { 283 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be github.com/luciferinlove/gqlgen/codegen/testserver/followschema.InnerInput`, tmp)) 284 } 285 } 286 args["arg"] = arg0 287 return args, nil 288 } 289 290 func (ec *executionContext) field_Query_directiveInput_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 291 var err error 292 args := map[string]interface{}{} 293 var arg0 InputDirectives 294 if tmp, ok := rawArgs["arg"]; ok { 295 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg")) 296 arg0, err = ec.unmarshalNInputDirectives2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInputDirectives(ctx, tmp) 297 if err != nil { 298 return nil, err 299 } 300 } 301 args["arg"] = arg0 302 return args, nil 303 } 304 305 func (ec *executionContext) field_Query_directiveNullableArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 306 var err error 307 args := map[string]interface{}{} 308 var arg0 *int 309 if tmp, ok := rawArgs["arg"]; ok { 310 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg")) 311 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) } 312 directive1 := func(ctx context.Context) (interface{}, error) { 313 min, err := ec.unmarshalOInt2ᚖint(ctx, 0) 314 if err != nil { 315 return nil, err 316 } 317 if ec.directives.Range == nil { 318 return nil, errors.New("directive range is not implemented") 319 } 320 return ec.directives.Range(ctx, rawArgs, directive0, min, nil) 321 } 322 323 tmp, err = directive1(ctx) 324 if err != nil { 325 return nil, graphql.ErrorOnPath(ctx, err) 326 } 327 if data, ok := tmp.(*int); ok { 328 arg0 = data 329 } else if tmp == nil { 330 arg0 = nil 331 } else { 332 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp)) 333 } 334 } 335 args["arg"] = arg0 336 var arg1 *int 337 if tmp, ok := rawArgs["arg2"]; ok { 338 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg2")) 339 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) } 340 directive1 := func(ctx context.Context) (interface{}, error) { 341 min, err := ec.unmarshalOInt2ᚖint(ctx, 0) 342 if err != nil { 343 return nil, err 344 } 345 if ec.directives.Range == nil { 346 return nil, errors.New("directive range is not implemented") 347 } 348 return ec.directives.Range(ctx, rawArgs, directive0, min, nil) 349 } 350 351 tmp, err = directive1(ctx) 352 if err != nil { 353 return nil, graphql.ErrorOnPath(ctx, err) 354 } 355 if data, ok := tmp.(*int); ok { 356 arg1 = data 357 } else if tmp == nil { 358 arg1 = nil 359 } else { 360 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp)) 361 } 362 } 363 args["arg2"] = arg1 364 var arg2 *string 365 if tmp, ok := rawArgs["arg3"]; ok { 366 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg3")) 367 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOString2ᚖstring(ctx, tmp) } 368 directive1 := func(ctx context.Context) (interface{}, error) { 369 if ec.directives.ToNull == nil { 370 return nil, errors.New("directive toNull is not implemented") 371 } 372 return ec.directives.ToNull(ctx, rawArgs, directive0) 373 } 374 375 tmp, err = directive1(ctx) 376 if err != nil { 377 return nil, graphql.ErrorOnPath(ctx, err) 378 } 379 if data, ok := tmp.(*string); ok { 380 arg2 = data 381 } else if tmp == nil { 382 arg2 = nil 383 } else { 384 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp)) 385 } 386 } 387 args["arg3"] = arg2 388 return args, nil 389 } 390 391 func (ec *executionContext) field_Query_enumInInput_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 392 var err error 393 args := map[string]interface{}{} 394 var arg0 *InputWithEnumValue 395 if tmp, ok := rawArgs["input"]; ok { 396 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input")) 397 arg0, err = ec.unmarshalOInputWithEnumValue2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInputWithEnumValue(ctx, tmp) 398 if err != nil { 399 return nil, err 400 } 401 } 402 args["input"] = arg0 403 return args, nil 404 } 405 406 func (ec *executionContext) field_Query_fallback_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 407 var err error 408 args := map[string]interface{}{} 409 var arg0 FallbackToStringEncoding 410 if tmp, ok := rawArgs["arg"]; ok { 411 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg")) 412 arg0, err = ec.unmarshalNFallbackToStringEncoding2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐFallbackToStringEncoding(ctx, tmp) 413 if err != nil { 414 return nil, err 415 } 416 } 417 args["arg"] = arg0 418 return args, nil 419 } 420 421 func (ec *executionContext) field_Query_inputNullableSlice_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 422 var err error 423 args := map[string]interface{}{} 424 var arg0 []string 425 if tmp, ok := rawArgs["arg"]; ok { 426 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg")) 427 arg0, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp) 428 if err != nil { 429 return nil, err 430 } 431 } 432 args["arg"] = arg0 433 return args, nil 434 } 435 436 func (ec *executionContext) field_Query_inputSlice_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 437 var err error 438 args := map[string]interface{}{} 439 var arg0 []string 440 if tmp, ok := rawArgs["arg"]; ok { 441 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg")) 442 arg0, err = ec.unmarshalNString2ᚕstringᚄ(ctx, tmp) 443 if err != nil { 444 return nil, err 445 } 446 } 447 args["arg"] = arg0 448 return args, nil 449 } 450 451 func (ec *executionContext) field_Query_mapInput_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 452 var err error 453 args := map[string]interface{}{} 454 var arg0 map[string]interface{} 455 if tmp, ok := rawArgs["input"]; ok { 456 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input")) 457 arg0, err = ec.unmarshalOChanges2map(ctx, tmp) 458 if err != nil { 459 return nil, err 460 } 461 } 462 args["input"] = arg0 463 return args, nil 464 } 465 466 func (ec *executionContext) field_Query_mapNestedStringInterface_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 467 var err error 468 args := map[string]interface{}{} 469 var arg0 *NestedMapInput 470 if tmp, ok := rawArgs["in"]; ok { 471 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("in")) 472 arg0, err = ec.unmarshalONestedMapInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐNestedMapInput(ctx, tmp) 473 if err != nil { 474 return nil, err 475 } 476 } 477 args["in"] = arg0 478 return args, nil 479 } 480 481 func (ec *executionContext) field_Query_mapStringInterface_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 482 var err error 483 args := map[string]interface{}{} 484 var arg0 map[string]interface{} 485 if tmp, ok := rawArgs["in"]; ok { 486 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("in")) 487 arg0, err = ec.unmarshalOMapStringInterfaceInput2map(ctx, tmp) 488 if err != nil { 489 return nil, err 490 } 491 } 492 args["in"] = arg0 493 return args, nil 494 } 495 496 func (ec *executionContext) field_Query_nestedInputs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 497 var err error 498 args := map[string]interface{}{} 499 var arg0 [][]*OuterInput 500 if tmp, ok := rawArgs["input"]; ok { 501 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input")) 502 arg0, err = ec.unmarshalOOuterInput2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx, tmp) 503 if err != nil { 504 return nil, err 505 } 506 } 507 args["input"] = arg0 508 return args, nil 509 } 510 511 func (ec *executionContext) field_Query_nullableArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 512 var err error 513 args := map[string]interface{}{} 514 var arg0 *int 515 if tmp, ok := rawArgs["arg"]; ok { 516 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg")) 517 arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp) 518 if err != nil { 519 return nil, err 520 } 521 } 522 args["arg"] = arg0 523 return args, nil 524 } 525 526 func (ec *executionContext) field_Query_recursive_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 527 var err error 528 args := map[string]interface{}{} 529 var arg0 *RecursiveInputSlice 530 if tmp, ok := rawArgs["input"]; ok { 531 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input")) 532 arg0, err = ec.unmarshalORecursiveInputSlice2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSlice(ctx, tmp) 533 if err != nil { 534 return nil, err 535 } 536 } 537 args["input"] = arg0 538 return args, nil 539 } 540 541 func (ec *executionContext) field_Query_user_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 542 var err error 543 args := map[string]interface{}{} 544 var arg0 int 545 if tmp, ok := rawArgs["id"]; ok { 546 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) 547 arg0, err = ec.unmarshalNInt2int(ctx, tmp) 548 if err != nil { 549 return nil, err 550 } 551 } 552 args["id"] = arg0 553 return args, nil 554 } 555 556 func (ec *executionContext) field_Subscription_directiveArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 557 var err error 558 args := map[string]interface{}{} 559 var arg0 string 560 if tmp, ok := rawArgs["arg"]; ok { 561 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg")) 562 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalNString2string(ctx, tmp) } 563 directive1 := func(ctx context.Context) (interface{}, error) { 564 min, err := ec.unmarshalNInt2int(ctx, 1) 565 if err != nil { 566 return nil, err 567 } 568 max, err := ec.unmarshalOInt2ᚖint(ctx, 255) 569 if err != nil { 570 return nil, err 571 } 572 message, err := ec.unmarshalOString2ᚖstring(ctx, "invalid length") 573 if err != nil { 574 return nil, err 575 } 576 if ec.directives.Length == nil { 577 return nil, errors.New("directive length is not implemented") 578 } 579 return ec.directives.Length(ctx, rawArgs, directive0, min, max, message) 580 } 581 582 tmp, err = directive1(ctx) 583 if err != nil { 584 return nil, graphql.ErrorOnPath(ctx, err) 585 } 586 if data, ok := tmp.(string); ok { 587 arg0 = data 588 } else { 589 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp)) 590 } 591 } 592 args["arg"] = arg0 593 return args, nil 594 } 595 596 func (ec *executionContext) field_Subscription_directiveNullableArg_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 597 var err error 598 args := map[string]interface{}{} 599 var arg0 *int 600 if tmp, ok := rawArgs["arg"]; ok { 601 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg")) 602 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) } 603 directive1 := func(ctx context.Context) (interface{}, error) { 604 min, err := ec.unmarshalOInt2ᚖint(ctx, 0) 605 if err != nil { 606 return nil, err 607 } 608 if ec.directives.Range == nil { 609 return nil, errors.New("directive range is not implemented") 610 } 611 return ec.directives.Range(ctx, rawArgs, directive0, min, nil) 612 } 613 614 tmp, err = directive1(ctx) 615 if err != nil { 616 return nil, graphql.ErrorOnPath(ctx, err) 617 } 618 if data, ok := tmp.(*int); ok { 619 arg0 = data 620 } else if tmp == nil { 621 arg0 = nil 622 } else { 623 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp)) 624 } 625 } 626 args["arg"] = arg0 627 var arg1 *int 628 if tmp, ok := rawArgs["arg2"]; ok { 629 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg2")) 630 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOInt2ᚖint(ctx, tmp) } 631 directive1 := func(ctx context.Context) (interface{}, error) { 632 min, err := ec.unmarshalOInt2ᚖint(ctx, 0) 633 if err != nil { 634 return nil, err 635 } 636 if ec.directives.Range == nil { 637 return nil, errors.New("directive range is not implemented") 638 } 639 return ec.directives.Range(ctx, rawArgs, directive0, min, nil) 640 } 641 642 tmp, err = directive1(ctx) 643 if err != nil { 644 return nil, graphql.ErrorOnPath(ctx, err) 645 } 646 if data, ok := tmp.(*int); ok { 647 arg1 = data 648 } else if tmp == nil { 649 arg1 = nil 650 } else { 651 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *int`, tmp)) 652 } 653 } 654 args["arg2"] = arg1 655 var arg2 *string 656 if tmp, ok := rawArgs["arg3"]; ok { 657 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("arg3")) 658 directive0 := func(ctx context.Context) (interface{}, error) { return ec.unmarshalOString2ᚖstring(ctx, tmp) } 659 directive1 := func(ctx context.Context) (interface{}, error) { 660 if ec.directives.ToNull == nil { 661 return nil, errors.New("directive toNull is not implemented") 662 } 663 return ec.directives.ToNull(ctx, rawArgs, directive0) 664 } 665 666 tmp, err = directive1(ctx) 667 if err != nil { 668 return nil, graphql.ErrorOnPath(ctx, err) 669 } 670 if data, ok := tmp.(*string); ok { 671 arg2 = data 672 } else if tmp == nil { 673 arg2 = nil 674 } else { 675 return nil, graphql.ErrorOnPath(ctx, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp)) 676 } 677 } 678 args["arg3"] = arg2 679 return args, nil 680 } 681 682 func (ec *executionContext) field_User_pets_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 683 var err error 684 args := map[string]interface{}{} 685 var arg0 *int 686 if tmp, ok := rawArgs["limit"]; ok { 687 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit")) 688 arg0, err = ec.unmarshalOInt2ᚖint(ctx, tmp) 689 if err != nil { 690 return nil, err 691 } 692 } 693 args["limit"] = arg0 694 return args, nil 695 } 696 697 // endregion ***************************** args.gotpl ***************************** 698 699 // region ************************** directives.gotpl ************************** 700 701 // endregion ************************** directives.gotpl ************************** 702 703 // region **************************** field.gotpl ***************************** 704 705 func (ec *executionContext) _Autobind_int(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) { 706 fc, err := ec.fieldContext_Autobind_int(ctx, field) 707 if err != nil { 708 return graphql.Null 709 } 710 ctx = graphql.WithFieldContext(ctx, fc) 711 defer func() { 712 if r := recover(); r != nil { 713 ec.Error(ctx, ec.Recover(ctx, r)) 714 ret = graphql.Null 715 } 716 }() 717 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 718 ctx = rctx // use context from middleware stack in children 719 return obj.Int, nil 720 }) 721 722 if resTmp == nil { 723 if !graphql.HasFieldError(ctx, fc) { 724 ec.Errorf(ctx, "must not be null") 725 } 726 return graphql.Null 727 } 728 res := resTmp.(int) 729 fc.Result = res 730 return ec.marshalNInt2int(ctx, field.Selections, res) 731 } 732 733 func (ec *executionContext) fieldContext_Autobind_int(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 734 fc = &graphql.FieldContext{ 735 Object: "Autobind", 736 Field: field, 737 IsMethod: false, 738 IsResolver: false, 739 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 740 return nil, errors.New("field of type Int does not have child fields") 741 }, 742 } 743 return fc, nil 744 } 745 746 func (ec *executionContext) _Autobind_int32(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) { 747 fc, err := ec.fieldContext_Autobind_int32(ctx, field) 748 if err != nil { 749 return graphql.Null 750 } 751 ctx = graphql.WithFieldContext(ctx, fc) 752 defer func() { 753 if r := recover(); r != nil { 754 ec.Error(ctx, ec.Recover(ctx, r)) 755 ret = graphql.Null 756 } 757 }() 758 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 759 ctx = rctx // use context from middleware stack in children 760 return obj.Int32, nil 761 }) 762 763 if resTmp == nil { 764 if !graphql.HasFieldError(ctx, fc) { 765 ec.Errorf(ctx, "must not be null") 766 } 767 return graphql.Null 768 } 769 res := resTmp.(int32) 770 fc.Result = res 771 return ec.marshalNInt2int32(ctx, field.Selections, res) 772 } 773 774 func (ec *executionContext) fieldContext_Autobind_int32(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 775 fc = &graphql.FieldContext{ 776 Object: "Autobind", 777 Field: field, 778 IsMethod: false, 779 IsResolver: false, 780 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 781 return nil, errors.New("field of type Int does not have child fields") 782 }, 783 } 784 return fc, nil 785 } 786 787 func (ec *executionContext) _Autobind_int64(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) { 788 fc, err := ec.fieldContext_Autobind_int64(ctx, field) 789 if err != nil { 790 return graphql.Null 791 } 792 ctx = graphql.WithFieldContext(ctx, fc) 793 defer func() { 794 if r := recover(); r != nil { 795 ec.Error(ctx, ec.Recover(ctx, r)) 796 ret = graphql.Null 797 } 798 }() 799 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 800 ctx = rctx // use context from middleware stack in children 801 return obj.Int64, nil 802 }) 803 804 if resTmp == nil { 805 if !graphql.HasFieldError(ctx, fc) { 806 ec.Errorf(ctx, "must not be null") 807 } 808 return graphql.Null 809 } 810 res := resTmp.(int64) 811 fc.Result = res 812 return ec.marshalNInt2int64(ctx, field.Selections, res) 813 } 814 815 func (ec *executionContext) fieldContext_Autobind_int64(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 816 fc = &graphql.FieldContext{ 817 Object: "Autobind", 818 Field: field, 819 IsMethod: false, 820 IsResolver: false, 821 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 822 return nil, errors.New("field of type Int does not have child fields") 823 }, 824 } 825 return fc, nil 826 } 827 828 func (ec *executionContext) _Autobind_idStr(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) { 829 fc, err := ec.fieldContext_Autobind_idStr(ctx, field) 830 if err != nil { 831 return graphql.Null 832 } 833 ctx = graphql.WithFieldContext(ctx, fc) 834 defer func() { 835 if r := recover(); r != nil { 836 ec.Error(ctx, ec.Recover(ctx, r)) 837 ret = graphql.Null 838 } 839 }() 840 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 841 ctx = rctx // use context from middleware stack in children 842 return obj.IdStr, nil 843 }) 844 845 if resTmp == nil { 846 if !graphql.HasFieldError(ctx, fc) { 847 ec.Errorf(ctx, "must not be null") 848 } 849 return graphql.Null 850 } 851 res := resTmp.(string) 852 fc.Result = res 853 return ec.marshalNID2string(ctx, field.Selections, res) 854 } 855 856 func (ec *executionContext) fieldContext_Autobind_idStr(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 857 fc = &graphql.FieldContext{ 858 Object: "Autobind", 859 Field: field, 860 IsMethod: false, 861 IsResolver: false, 862 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 863 return nil, errors.New("field of type ID does not have child fields") 864 }, 865 } 866 return fc, nil 867 } 868 869 func (ec *executionContext) _Autobind_idInt(ctx context.Context, field graphql.CollectedField, obj *Autobind) (ret graphql.Marshaler) { 870 fc, err := ec.fieldContext_Autobind_idInt(ctx, field) 871 if err != nil { 872 return graphql.Null 873 } 874 ctx = graphql.WithFieldContext(ctx, fc) 875 defer func() { 876 if r := recover(); r != nil { 877 ec.Error(ctx, ec.Recover(ctx, r)) 878 ret = graphql.Null 879 } 880 }() 881 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 882 ctx = rctx // use context from middleware stack in children 883 return obj.IdInt, nil 884 }) 885 886 if resTmp == nil { 887 if !graphql.HasFieldError(ctx, fc) { 888 ec.Errorf(ctx, "must not be null") 889 } 890 return graphql.Null 891 } 892 res := resTmp.(int) 893 fc.Result = res 894 return ec.marshalNID2int(ctx, field.Selections, res) 895 } 896 897 func (ec *executionContext) fieldContext_Autobind_idInt(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 898 fc = &graphql.FieldContext{ 899 Object: "Autobind", 900 Field: field, 901 IsMethod: false, 902 IsResolver: false, 903 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 904 return nil, errors.New("field of type ID does not have child fields") 905 }, 906 } 907 return fc, nil 908 } 909 910 func (ec *executionContext) _EmbeddedPointer_ID(ctx context.Context, field graphql.CollectedField, obj *EmbeddedPointerModel) (ret graphql.Marshaler) { 911 fc, err := ec.fieldContext_EmbeddedPointer_ID(ctx, field) 912 if err != nil { 913 return graphql.Null 914 } 915 ctx = graphql.WithFieldContext(ctx, fc) 916 defer func() { 917 if r := recover(); r != nil { 918 ec.Error(ctx, ec.Recover(ctx, r)) 919 ret = graphql.Null 920 } 921 }() 922 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 923 ctx = rctx // use context from middleware stack in children 924 return obj.ID, nil 925 }) 926 927 if resTmp == nil { 928 return graphql.Null 929 } 930 res := resTmp.(string) 931 fc.Result = res 932 return ec.marshalOString2string(ctx, field.Selections, res) 933 } 934 935 func (ec *executionContext) fieldContext_EmbeddedPointer_ID(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 936 fc = &graphql.FieldContext{ 937 Object: "EmbeddedPointer", 938 Field: field, 939 IsMethod: false, 940 IsResolver: false, 941 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 942 return nil, errors.New("field of type String does not have child fields") 943 }, 944 } 945 return fc, nil 946 } 947 948 func (ec *executionContext) _EmbeddedPointer_Title(ctx context.Context, field graphql.CollectedField, obj *EmbeddedPointerModel) (ret graphql.Marshaler) { 949 fc, err := ec.fieldContext_EmbeddedPointer_Title(ctx, field) 950 if err != nil { 951 return graphql.Null 952 } 953 ctx = graphql.WithFieldContext(ctx, fc) 954 defer func() { 955 if r := recover(); r != nil { 956 ec.Error(ctx, ec.Recover(ctx, r)) 957 ret = graphql.Null 958 } 959 }() 960 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 961 ctx = rctx // use context from middleware stack in children 962 return obj.Title, nil 963 }) 964 965 if resTmp == nil { 966 return graphql.Null 967 } 968 res := resTmp.(string) 969 fc.Result = res 970 return ec.marshalOString2string(ctx, field.Selections, res) 971 } 972 973 func (ec *executionContext) fieldContext_EmbeddedPointer_Title(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 974 fc = &graphql.FieldContext{ 975 Object: "EmbeddedPointer", 976 Field: field, 977 IsMethod: false, 978 IsResolver: false, 979 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 980 return nil, errors.New("field of type String does not have child fields") 981 }, 982 } 983 return fc, nil 984 } 985 986 func (ec *executionContext) _ForcedResolver_field(ctx context.Context, field graphql.CollectedField, obj *ForcedResolver) (ret graphql.Marshaler) { 987 fc, err := ec.fieldContext_ForcedResolver_field(ctx, field) 988 if err != nil { 989 return graphql.Null 990 } 991 ctx = graphql.WithFieldContext(ctx, fc) 992 defer func() { 993 if r := recover(); r != nil { 994 ec.Error(ctx, ec.Recover(ctx, r)) 995 ret = graphql.Null 996 } 997 }() 998 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 999 ctx = rctx // use context from middleware stack in children 1000 return ec.resolvers.ForcedResolver().Field(rctx, obj) 1001 }) 1002 1003 if resTmp == nil { 1004 return graphql.Null 1005 } 1006 res := resTmp.(*Circle) 1007 fc.Result = res 1008 return ec.marshalOCircle2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐCircle(ctx, field.Selections, res) 1009 } 1010 1011 func (ec *executionContext) fieldContext_ForcedResolver_field(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1012 fc = &graphql.FieldContext{ 1013 Object: "ForcedResolver", 1014 Field: field, 1015 IsMethod: true, 1016 IsResolver: true, 1017 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1018 switch field.Name { 1019 case "radius": 1020 return ec.fieldContext_Circle_radius(ctx, field) 1021 case "area": 1022 return ec.fieldContext_Circle_area(ctx, field) 1023 case "coordinates": 1024 return ec.fieldContext_Circle_coordinates(ctx, field) 1025 } 1026 return nil, fmt.Errorf("no field named %q was found under type Circle", field.Name) 1027 }, 1028 } 1029 return fc, nil 1030 } 1031 1032 func (ec *executionContext) _InnerObject_id(ctx context.Context, field graphql.CollectedField, obj *InnerObject) (ret graphql.Marshaler) { 1033 fc, err := ec.fieldContext_InnerObject_id(ctx, field) 1034 if err != nil { 1035 return graphql.Null 1036 } 1037 ctx = graphql.WithFieldContext(ctx, fc) 1038 defer func() { 1039 if r := recover(); r != nil { 1040 ec.Error(ctx, ec.Recover(ctx, r)) 1041 ret = graphql.Null 1042 } 1043 }() 1044 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1045 ctx = rctx // use context from middleware stack in children 1046 return obj.ID, nil 1047 }) 1048 1049 if resTmp == nil { 1050 if !graphql.HasFieldError(ctx, fc) { 1051 ec.Errorf(ctx, "must not be null") 1052 } 1053 return graphql.Null 1054 } 1055 res := resTmp.(int) 1056 fc.Result = res 1057 return ec.marshalNInt2int(ctx, field.Selections, res) 1058 } 1059 1060 func (ec *executionContext) fieldContext_InnerObject_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1061 fc = &graphql.FieldContext{ 1062 Object: "InnerObject", 1063 Field: field, 1064 IsMethod: false, 1065 IsResolver: false, 1066 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1067 return nil, errors.New("field of type Int does not have child fields") 1068 }, 1069 } 1070 return fc, nil 1071 } 1072 1073 func (ec *executionContext) _InvalidIdentifier_id(ctx context.Context, field graphql.CollectedField, obj *invalid_packagename.InvalidIdentifier) (ret graphql.Marshaler) { 1074 fc, err := ec.fieldContext_InvalidIdentifier_id(ctx, field) 1075 if err != nil { 1076 return graphql.Null 1077 } 1078 ctx = graphql.WithFieldContext(ctx, fc) 1079 defer func() { 1080 if r := recover(); r != nil { 1081 ec.Error(ctx, ec.Recover(ctx, r)) 1082 ret = graphql.Null 1083 } 1084 }() 1085 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1086 ctx = rctx // use context from middleware stack in children 1087 return obj.ID, nil 1088 }) 1089 1090 if resTmp == nil { 1091 if !graphql.HasFieldError(ctx, fc) { 1092 ec.Errorf(ctx, "must not be null") 1093 } 1094 return graphql.Null 1095 } 1096 res := resTmp.(int) 1097 fc.Result = res 1098 return ec.marshalNInt2int(ctx, field.Selections, res) 1099 } 1100 1101 func (ec *executionContext) fieldContext_InvalidIdentifier_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1102 fc = &graphql.FieldContext{ 1103 Object: "InvalidIdentifier", 1104 Field: field, 1105 IsMethod: false, 1106 IsResolver: false, 1107 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1108 return nil, errors.New("field of type Int does not have child fields") 1109 }, 1110 } 1111 return fc, nil 1112 } 1113 1114 func (ec *executionContext) _It_id(ctx context.Context, field graphql.CollectedField, obj *introspection1.It) (ret graphql.Marshaler) { 1115 fc, err := ec.fieldContext_It_id(ctx, field) 1116 if err != nil { 1117 return graphql.Null 1118 } 1119 ctx = graphql.WithFieldContext(ctx, fc) 1120 defer func() { 1121 if r := recover(); r != nil { 1122 ec.Error(ctx, ec.Recover(ctx, r)) 1123 ret = graphql.Null 1124 } 1125 }() 1126 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1127 ctx = rctx // use context from middleware stack in children 1128 return obj.ID, nil 1129 }) 1130 1131 if resTmp == nil { 1132 if !graphql.HasFieldError(ctx, fc) { 1133 ec.Errorf(ctx, "must not be null") 1134 } 1135 return graphql.Null 1136 } 1137 res := resTmp.(string) 1138 fc.Result = res 1139 return ec.marshalNID2string(ctx, field.Selections, res) 1140 } 1141 1142 func (ec *executionContext) fieldContext_It_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1143 fc = &graphql.FieldContext{ 1144 Object: "It", 1145 Field: field, 1146 IsMethod: false, 1147 IsResolver: false, 1148 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1149 return nil, errors.New("field of type ID does not have child fields") 1150 }, 1151 } 1152 return fc, nil 1153 } 1154 1155 func (ec *executionContext) _ModelMethods_resolverField(ctx context.Context, field graphql.CollectedField, obj *ModelMethods) (ret graphql.Marshaler) { 1156 fc, err := ec.fieldContext_ModelMethods_resolverField(ctx, field) 1157 if err != nil { 1158 return graphql.Null 1159 } 1160 ctx = graphql.WithFieldContext(ctx, fc) 1161 defer func() { 1162 if r := recover(); r != nil { 1163 ec.Error(ctx, ec.Recover(ctx, r)) 1164 ret = graphql.Null 1165 } 1166 }() 1167 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1168 ctx = rctx // use context from middleware stack in children 1169 return ec.resolvers.ModelMethods().ResolverField(rctx, obj) 1170 }) 1171 1172 if resTmp == nil { 1173 if !graphql.HasFieldError(ctx, fc) { 1174 ec.Errorf(ctx, "must not be null") 1175 } 1176 return graphql.Null 1177 } 1178 res := resTmp.(bool) 1179 fc.Result = res 1180 return ec.marshalNBoolean2bool(ctx, field.Selections, res) 1181 } 1182 1183 func (ec *executionContext) fieldContext_ModelMethods_resolverField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1184 fc = &graphql.FieldContext{ 1185 Object: "ModelMethods", 1186 Field: field, 1187 IsMethod: true, 1188 IsResolver: true, 1189 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1190 return nil, errors.New("field of type Boolean does not have child fields") 1191 }, 1192 } 1193 return fc, nil 1194 } 1195 1196 func (ec *executionContext) _ModelMethods_noContext(ctx context.Context, field graphql.CollectedField, obj *ModelMethods) (ret graphql.Marshaler) { 1197 fc, err := ec.fieldContext_ModelMethods_noContext(ctx, field) 1198 if err != nil { 1199 return graphql.Null 1200 } 1201 ctx = graphql.WithFieldContext(ctx, fc) 1202 defer func() { 1203 if r := recover(); r != nil { 1204 ec.Error(ctx, ec.Recover(ctx, r)) 1205 ret = graphql.Null 1206 } 1207 }() 1208 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1209 ctx = rctx // use context from middleware stack in children 1210 return obj.NoContext(), nil 1211 }) 1212 1213 if resTmp == nil { 1214 if !graphql.HasFieldError(ctx, fc) { 1215 ec.Errorf(ctx, "must not be null") 1216 } 1217 return graphql.Null 1218 } 1219 res := resTmp.(bool) 1220 fc.Result = res 1221 return ec.marshalNBoolean2bool(ctx, field.Selections, res) 1222 } 1223 1224 func (ec *executionContext) fieldContext_ModelMethods_noContext(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1225 fc = &graphql.FieldContext{ 1226 Object: "ModelMethods", 1227 Field: field, 1228 IsMethod: true, 1229 IsResolver: false, 1230 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1231 return nil, errors.New("field of type Boolean does not have child fields") 1232 }, 1233 } 1234 return fc, nil 1235 } 1236 1237 func (ec *executionContext) _ModelMethods_withContext(ctx context.Context, field graphql.CollectedField, obj *ModelMethods) (ret graphql.Marshaler) { 1238 fc, err := ec.fieldContext_ModelMethods_withContext(ctx, field) 1239 if err != nil { 1240 return graphql.Null 1241 } 1242 ctx = graphql.WithFieldContext(ctx, fc) 1243 defer func() { 1244 if r := recover(); r != nil { 1245 ec.Error(ctx, ec.Recover(ctx, r)) 1246 ret = graphql.Null 1247 } 1248 }() 1249 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1250 ctx = rctx // use context from middleware stack in children 1251 return obj.WithContext(ctx), nil 1252 }) 1253 1254 if resTmp == nil { 1255 if !graphql.HasFieldError(ctx, fc) { 1256 ec.Errorf(ctx, "must not be null") 1257 } 1258 return graphql.Null 1259 } 1260 res := resTmp.(bool) 1261 fc.Result = res 1262 return ec.marshalNBoolean2bool(ctx, field.Selections, res) 1263 } 1264 1265 func (ec *executionContext) fieldContext_ModelMethods_withContext(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1266 fc = &graphql.FieldContext{ 1267 Object: "ModelMethods", 1268 Field: field, 1269 IsMethod: true, 1270 IsResolver: false, 1271 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1272 return nil, errors.New("field of type Boolean does not have child fields") 1273 }, 1274 } 1275 return fc, nil 1276 } 1277 1278 func (ec *executionContext) _OuterObject_inner(ctx context.Context, field graphql.CollectedField, obj *OuterObject) (ret graphql.Marshaler) { 1279 fc, err := ec.fieldContext_OuterObject_inner(ctx, field) 1280 if err != nil { 1281 return graphql.Null 1282 } 1283 ctx = graphql.WithFieldContext(ctx, fc) 1284 defer func() { 1285 if r := recover(); r != nil { 1286 ec.Error(ctx, ec.Recover(ctx, r)) 1287 ret = graphql.Null 1288 } 1289 }() 1290 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1291 ctx = rctx // use context from middleware stack in children 1292 return obj.Inner, nil 1293 }) 1294 1295 if resTmp == nil { 1296 if !graphql.HasFieldError(ctx, fc) { 1297 ec.Errorf(ctx, "must not be null") 1298 } 1299 return graphql.Null 1300 } 1301 res := resTmp.(*InnerObject) 1302 fc.Result = res 1303 return ec.marshalNInnerObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerObject(ctx, field.Selections, res) 1304 } 1305 1306 func (ec *executionContext) fieldContext_OuterObject_inner(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1307 fc = &graphql.FieldContext{ 1308 Object: "OuterObject", 1309 Field: field, 1310 IsMethod: false, 1311 IsResolver: false, 1312 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1313 switch field.Name { 1314 case "id": 1315 return ec.fieldContext_InnerObject_id(ctx, field) 1316 } 1317 return nil, fmt.Errorf("no field named %q was found under type InnerObject", field.Name) 1318 }, 1319 } 1320 return fc, nil 1321 } 1322 1323 func (ec *executionContext) _Pet_id(ctx context.Context, field graphql.CollectedField, obj *Pet) (ret graphql.Marshaler) { 1324 fc, err := ec.fieldContext_Pet_id(ctx, field) 1325 if err != nil { 1326 return graphql.Null 1327 } 1328 ctx = graphql.WithFieldContext(ctx, fc) 1329 defer func() { 1330 if r := recover(); r != nil { 1331 ec.Error(ctx, ec.Recover(ctx, r)) 1332 ret = graphql.Null 1333 } 1334 }() 1335 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1336 ctx = rctx // use context from middleware stack in children 1337 return obj.ID, nil 1338 }) 1339 1340 if resTmp == nil { 1341 if !graphql.HasFieldError(ctx, fc) { 1342 ec.Errorf(ctx, "must not be null") 1343 } 1344 return graphql.Null 1345 } 1346 res := resTmp.(int) 1347 fc.Result = res 1348 return ec.marshalNInt2int(ctx, field.Selections, res) 1349 } 1350 1351 func (ec *executionContext) fieldContext_Pet_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1352 fc = &graphql.FieldContext{ 1353 Object: "Pet", 1354 Field: field, 1355 IsMethod: false, 1356 IsResolver: false, 1357 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1358 return nil, errors.New("field of type Int does not have child fields") 1359 }, 1360 } 1361 return fc, nil 1362 } 1363 1364 func (ec *executionContext) _Pet_friends(ctx context.Context, field graphql.CollectedField, obj *Pet) (ret graphql.Marshaler) { 1365 fc, err := ec.fieldContext_Pet_friends(ctx, field) 1366 if err != nil { 1367 return graphql.Null 1368 } 1369 ctx = graphql.WithFieldContext(ctx, fc) 1370 defer func() { 1371 if r := recover(); r != nil { 1372 ec.Error(ctx, ec.Recover(ctx, r)) 1373 ret = graphql.Null 1374 } 1375 }() 1376 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 1377 ctx = rctx // use context from middleware stack in children 1378 return ec.resolvers.Pet().Friends(rctx, obj, fc.Args["limit"].(*int)) 1379 }) 1380 1381 if resTmp == nil { 1382 return graphql.Null 1383 } 1384 res := resTmp.([]*Pet) 1385 fc.Result = res 1386 return ec.marshalOPet2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPetᚄ(ctx, field.Selections, res) 1387 } 1388 1389 func (ec *executionContext) fieldContext_Pet_friends(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1390 fc = &graphql.FieldContext{ 1391 Object: "Pet", 1392 Field: field, 1393 IsMethod: true, 1394 IsResolver: true, 1395 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1396 switch field.Name { 1397 case "id": 1398 return ec.fieldContext_Pet_id(ctx, field) 1399 case "friends": 1400 return ec.fieldContext_Pet_friends(ctx, field) 1401 } 1402 return nil, fmt.Errorf("no field named %q was found under type Pet", field.Name) 1403 }, 1404 } 1405 defer func() { 1406 if r := recover(); r != nil { 1407 err = ec.Recover(ctx, r) 1408 ec.Error(ctx, err) 1409 } 1410 }() 1411 ctx = graphql.WithFieldContext(ctx, fc) 1412 if fc.Args, err = ec.field_Pet_friends_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 1413 ec.Error(ctx, err) 1414 return 1415 } 1416 return fc, nil 1417 } 1418 1419 func (ec *executionContext) _Query_invalidIdentifier(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 1420 fc, err := ec.fieldContext_Query_invalidIdentifier(ctx, field) 1421 if err != nil { 1422 return graphql.Null 1423 } 1424 ctx = graphql.WithFieldContext(ctx, fc) 1425 defer func() { 1426 if r := recover(); r != nil { 1427 ec.Error(ctx, ec.Recover(ctx, r)) 1428 ret = graphql.Null 1429 } 1430 }() 1431 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 1432 ctx = rctx // use context from middleware stack in children 1433 return ec.resolvers.Query().InvalidIdentifier(rctx) 1434 }) 1435 1436 if resTmp == nil { 1437 return graphql.Null 1438 } 1439 res := resTmp.(*invalid_packagename.InvalidIdentifier) 1440 fc.Result = res 1441 return ec.marshalOInvalidIdentifier2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋinvalidᚑpackagenameᚐInvalidIdentifier(ctx, field.Selections, res) 1442 } 1443 1444 func (ec *executionContext) fieldContext_Query_invalidIdentifier(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1445 fc = &graphql.FieldContext{ 1446 Object: "Query", 1447 Field: field, 1448 IsMethod: true, 1449 IsResolver: true, 1450 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1451 switch field.Name { 1452 case "id": 1453 return ec.fieldContext_InvalidIdentifier_id(ctx, field) 1454 } 1455 return nil, fmt.Errorf("no field named %q was found under type InvalidIdentifier", field.Name) 1456 }, 1457 } 1458 return fc, nil 1459 } 1460 1461 func (ec *executionContext) _Query_collision(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 1462 fc, err := ec.fieldContext_Query_collision(ctx, field) 1463 if err != nil { 1464 return graphql.Null 1465 } 1466 ctx = graphql.WithFieldContext(ctx, fc) 1467 defer func() { 1468 if r := recover(); r != nil { 1469 ec.Error(ctx, ec.Recover(ctx, r)) 1470 ret = graphql.Null 1471 } 1472 }() 1473 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 1474 ctx = rctx // use context from middleware stack in children 1475 return ec.resolvers.Query().Collision(rctx) 1476 }) 1477 1478 if resTmp == nil { 1479 return graphql.Null 1480 } 1481 res := resTmp.(*introspection1.It) 1482 fc.Result = res 1483 return ec.marshalOIt2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋintrospectionᚐIt(ctx, field.Selections, res) 1484 } 1485 1486 func (ec *executionContext) fieldContext_Query_collision(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1487 fc = &graphql.FieldContext{ 1488 Object: "Query", 1489 Field: field, 1490 IsMethod: true, 1491 IsResolver: true, 1492 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1493 switch field.Name { 1494 case "id": 1495 return ec.fieldContext_It_id(ctx, field) 1496 } 1497 return nil, fmt.Errorf("no field named %q was found under type It", field.Name) 1498 }, 1499 } 1500 return fc, nil 1501 } 1502 1503 func (ec *executionContext) _Query_mapInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 1504 fc, err := ec.fieldContext_Query_mapInput(ctx, field) 1505 if err != nil { 1506 return graphql.Null 1507 } 1508 ctx = graphql.WithFieldContext(ctx, fc) 1509 defer func() { 1510 if r := recover(); r != nil { 1511 ec.Error(ctx, ec.Recover(ctx, r)) 1512 ret = graphql.Null 1513 } 1514 }() 1515 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 1516 ctx = rctx // use context from middleware stack in children 1517 return ec.resolvers.Query().MapInput(rctx, fc.Args["input"].(map[string]interface{})) 1518 }) 1519 1520 if resTmp == nil { 1521 return graphql.Null 1522 } 1523 res := resTmp.(*bool) 1524 fc.Result = res 1525 return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res) 1526 } 1527 1528 func (ec *executionContext) fieldContext_Query_mapInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1529 fc = &graphql.FieldContext{ 1530 Object: "Query", 1531 Field: field, 1532 IsMethod: true, 1533 IsResolver: true, 1534 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1535 return nil, errors.New("field of type Boolean does not have child fields") 1536 }, 1537 } 1538 defer func() { 1539 if r := recover(); r != nil { 1540 err = ec.Recover(ctx, r) 1541 ec.Error(ctx, err) 1542 } 1543 }() 1544 ctx = graphql.WithFieldContext(ctx, fc) 1545 if fc.Args, err = ec.field_Query_mapInput_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 1546 ec.Error(ctx, err) 1547 return 1548 } 1549 return fc, nil 1550 } 1551 1552 func (ec *executionContext) _Query_recursive(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 1553 fc, err := ec.fieldContext_Query_recursive(ctx, field) 1554 if err != nil { 1555 return graphql.Null 1556 } 1557 ctx = graphql.WithFieldContext(ctx, fc) 1558 defer func() { 1559 if r := recover(); r != nil { 1560 ec.Error(ctx, ec.Recover(ctx, r)) 1561 ret = graphql.Null 1562 } 1563 }() 1564 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 1565 ctx = rctx // use context from middleware stack in children 1566 return ec.resolvers.Query().Recursive(rctx, fc.Args["input"].(*RecursiveInputSlice)) 1567 }) 1568 1569 if resTmp == nil { 1570 return graphql.Null 1571 } 1572 res := resTmp.(*bool) 1573 fc.Result = res 1574 return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res) 1575 } 1576 1577 func (ec *executionContext) fieldContext_Query_recursive(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1578 fc = &graphql.FieldContext{ 1579 Object: "Query", 1580 Field: field, 1581 IsMethod: true, 1582 IsResolver: true, 1583 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1584 return nil, errors.New("field of type Boolean does not have child fields") 1585 }, 1586 } 1587 defer func() { 1588 if r := recover(); r != nil { 1589 err = ec.Recover(ctx, r) 1590 ec.Error(ctx, err) 1591 } 1592 }() 1593 ctx = graphql.WithFieldContext(ctx, fc) 1594 if fc.Args, err = ec.field_Query_recursive_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 1595 ec.Error(ctx, err) 1596 return 1597 } 1598 return fc, nil 1599 } 1600 1601 func (ec *executionContext) _Query_nestedInputs(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 1602 fc, err := ec.fieldContext_Query_nestedInputs(ctx, field) 1603 if err != nil { 1604 return graphql.Null 1605 } 1606 ctx = graphql.WithFieldContext(ctx, fc) 1607 defer func() { 1608 if r := recover(); r != nil { 1609 ec.Error(ctx, ec.Recover(ctx, r)) 1610 ret = graphql.Null 1611 } 1612 }() 1613 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 1614 ctx = rctx // use context from middleware stack in children 1615 return ec.resolvers.Query().NestedInputs(rctx, fc.Args["input"].([][]*OuterInput)) 1616 }) 1617 1618 if resTmp == nil { 1619 return graphql.Null 1620 } 1621 res := resTmp.(*bool) 1622 fc.Result = res 1623 return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res) 1624 } 1625 1626 func (ec *executionContext) fieldContext_Query_nestedInputs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1627 fc = &graphql.FieldContext{ 1628 Object: "Query", 1629 Field: field, 1630 IsMethod: true, 1631 IsResolver: true, 1632 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1633 return nil, errors.New("field of type Boolean does not have child fields") 1634 }, 1635 } 1636 defer func() { 1637 if r := recover(); r != nil { 1638 err = ec.Recover(ctx, r) 1639 ec.Error(ctx, err) 1640 } 1641 }() 1642 ctx = graphql.WithFieldContext(ctx, fc) 1643 if fc.Args, err = ec.field_Query_nestedInputs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 1644 ec.Error(ctx, err) 1645 return 1646 } 1647 return fc, nil 1648 } 1649 1650 func (ec *executionContext) _Query_nestedOutputs(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 1651 fc, err := ec.fieldContext_Query_nestedOutputs(ctx, field) 1652 if err != nil { 1653 return graphql.Null 1654 } 1655 ctx = graphql.WithFieldContext(ctx, fc) 1656 defer func() { 1657 if r := recover(); r != nil { 1658 ec.Error(ctx, ec.Recover(ctx, r)) 1659 ret = graphql.Null 1660 } 1661 }() 1662 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 1663 ctx = rctx // use context from middleware stack in children 1664 return ec.resolvers.Query().NestedOutputs(rctx) 1665 }) 1666 1667 if resTmp == nil { 1668 return graphql.Null 1669 } 1670 res := resTmp.([][]*OuterObject) 1671 fc.Result = res 1672 return ec.marshalOOuterObject2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx, field.Selections, res) 1673 } 1674 1675 func (ec *executionContext) fieldContext_Query_nestedOutputs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1676 fc = &graphql.FieldContext{ 1677 Object: "Query", 1678 Field: field, 1679 IsMethod: true, 1680 IsResolver: true, 1681 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1682 switch field.Name { 1683 case "inner": 1684 return ec.fieldContext_OuterObject_inner(ctx, field) 1685 } 1686 return nil, fmt.Errorf("no field named %q was found under type OuterObject", field.Name) 1687 }, 1688 } 1689 return fc, nil 1690 } 1691 1692 func (ec *executionContext) _Query_modelMethods(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 1693 fc, err := ec.fieldContext_Query_modelMethods(ctx, field) 1694 if err != nil { 1695 return graphql.Null 1696 } 1697 ctx = graphql.WithFieldContext(ctx, fc) 1698 defer func() { 1699 if r := recover(); r != nil { 1700 ec.Error(ctx, ec.Recover(ctx, r)) 1701 ret = graphql.Null 1702 } 1703 }() 1704 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 1705 ctx = rctx // use context from middleware stack in children 1706 return ec.resolvers.Query().ModelMethods(rctx) 1707 }) 1708 1709 if resTmp == nil { 1710 return graphql.Null 1711 } 1712 res := resTmp.(*ModelMethods) 1713 fc.Result = res 1714 return ec.marshalOModelMethods2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐModelMethods(ctx, field.Selections, res) 1715 } 1716 1717 func (ec *executionContext) fieldContext_Query_modelMethods(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1718 fc = &graphql.FieldContext{ 1719 Object: "Query", 1720 Field: field, 1721 IsMethod: true, 1722 IsResolver: true, 1723 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1724 switch field.Name { 1725 case "resolverField": 1726 return ec.fieldContext_ModelMethods_resolverField(ctx, field) 1727 case "noContext": 1728 return ec.fieldContext_ModelMethods_noContext(ctx, field) 1729 case "withContext": 1730 return ec.fieldContext_ModelMethods_withContext(ctx, field) 1731 } 1732 return nil, fmt.Errorf("no field named %q was found under type ModelMethods", field.Name) 1733 }, 1734 } 1735 return fc, nil 1736 } 1737 1738 func (ec *executionContext) _Query_user(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 1739 fc, err := ec.fieldContext_Query_user(ctx, field) 1740 if err != nil { 1741 return graphql.Null 1742 } 1743 ctx = graphql.WithFieldContext(ctx, fc) 1744 defer func() { 1745 if r := recover(); r != nil { 1746 ec.Error(ctx, ec.Recover(ctx, r)) 1747 ret = graphql.Null 1748 } 1749 }() 1750 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 1751 ctx = rctx // use context from middleware stack in children 1752 return ec.resolvers.Query().User(rctx, fc.Args["id"].(int)) 1753 }) 1754 1755 if resTmp == nil { 1756 if !graphql.HasFieldError(ctx, fc) { 1757 ec.Errorf(ctx, "must not be null") 1758 } 1759 return graphql.Null 1760 } 1761 res := resTmp.(*User) 1762 fc.Result = res 1763 return ec.marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUser(ctx, field.Selections, res) 1764 } 1765 1766 func (ec *executionContext) fieldContext_Query_user(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1767 fc = &graphql.FieldContext{ 1768 Object: "Query", 1769 Field: field, 1770 IsMethod: true, 1771 IsResolver: true, 1772 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1773 switch field.Name { 1774 case "id": 1775 return ec.fieldContext_User_id(ctx, field) 1776 case "friends": 1777 return ec.fieldContext_User_friends(ctx, field) 1778 case "created": 1779 return ec.fieldContext_User_created(ctx, field) 1780 case "updated": 1781 return ec.fieldContext_User_updated(ctx, field) 1782 case "pets": 1783 return ec.fieldContext_User_pets(ctx, field) 1784 } 1785 return nil, fmt.Errorf("no field named %q was found under type User", field.Name) 1786 }, 1787 } 1788 defer func() { 1789 if r := recover(); r != nil { 1790 err = ec.Recover(ctx, r) 1791 ec.Error(ctx, err) 1792 } 1793 }() 1794 ctx = graphql.WithFieldContext(ctx, fc) 1795 if fc.Args, err = ec.field_Query_user_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 1796 ec.Error(ctx, err) 1797 return 1798 } 1799 return fc, nil 1800 } 1801 1802 func (ec *executionContext) _Query_nullableArg(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 1803 fc, err := ec.fieldContext_Query_nullableArg(ctx, field) 1804 if err != nil { 1805 return graphql.Null 1806 } 1807 ctx = graphql.WithFieldContext(ctx, fc) 1808 defer func() { 1809 if r := recover(); r != nil { 1810 ec.Error(ctx, ec.Recover(ctx, r)) 1811 ret = graphql.Null 1812 } 1813 }() 1814 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 1815 ctx = rctx // use context from middleware stack in children 1816 return ec.resolvers.Query().NullableArg(rctx, fc.Args["arg"].(*int)) 1817 }) 1818 1819 if resTmp == nil { 1820 return graphql.Null 1821 } 1822 res := resTmp.(*string) 1823 fc.Result = res 1824 return ec.marshalOString2ᚖstring(ctx, field.Selections, res) 1825 } 1826 1827 func (ec *executionContext) fieldContext_Query_nullableArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1828 fc = &graphql.FieldContext{ 1829 Object: "Query", 1830 Field: field, 1831 IsMethod: true, 1832 IsResolver: true, 1833 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1834 return nil, errors.New("field of type String does not have child fields") 1835 }, 1836 } 1837 defer func() { 1838 if r := recover(); r != nil { 1839 err = ec.Recover(ctx, r) 1840 ec.Error(ctx, err) 1841 } 1842 }() 1843 ctx = graphql.WithFieldContext(ctx, fc) 1844 if fc.Args, err = ec.field_Query_nullableArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 1845 ec.Error(ctx, err) 1846 return 1847 } 1848 return fc, nil 1849 } 1850 1851 func (ec *executionContext) _Query_inputSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 1852 fc, err := ec.fieldContext_Query_inputSlice(ctx, field) 1853 if err != nil { 1854 return graphql.Null 1855 } 1856 ctx = graphql.WithFieldContext(ctx, fc) 1857 defer func() { 1858 if r := recover(); r != nil { 1859 ec.Error(ctx, ec.Recover(ctx, r)) 1860 ret = graphql.Null 1861 } 1862 }() 1863 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 1864 ctx = rctx // use context from middleware stack in children 1865 return ec.resolvers.Query().InputSlice(rctx, fc.Args["arg"].([]string)) 1866 }) 1867 1868 if resTmp == nil { 1869 if !graphql.HasFieldError(ctx, fc) { 1870 ec.Errorf(ctx, "must not be null") 1871 } 1872 return graphql.Null 1873 } 1874 res := resTmp.(bool) 1875 fc.Result = res 1876 return ec.marshalNBoolean2bool(ctx, field.Selections, res) 1877 } 1878 1879 func (ec *executionContext) fieldContext_Query_inputSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1880 fc = &graphql.FieldContext{ 1881 Object: "Query", 1882 Field: field, 1883 IsMethod: true, 1884 IsResolver: true, 1885 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1886 return nil, errors.New("field of type Boolean does not have child fields") 1887 }, 1888 } 1889 defer func() { 1890 if r := recover(); r != nil { 1891 err = ec.Recover(ctx, r) 1892 ec.Error(ctx, err) 1893 } 1894 }() 1895 ctx = graphql.WithFieldContext(ctx, fc) 1896 if fc.Args, err = ec.field_Query_inputSlice_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 1897 ec.Error(ctx, err) 1898 return 1899 } 1900 return fc, nil 1901 } 1902 1903 func (ec *executionContext) _Query_inputNullableSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 1904 fc, err := ec.fieldContext_Query_inputNullableSlice(ctx, field) 1905 if err != nil { 1906 return graphql.Null 1907 } 1908 ctx = graphql.WithFieldContext(ctx, fc) 1909 defer func() { 1910 if r := recover(); r != nil { 1911 ec.Error(ctx, ec.Recover(ctx, r)) 1912 ret = graphql.Null 1913 } 1914 }() 1915 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 1916 ctx = rctx // use context from middleware stack in children 1917 return ec.resolvers.Query().InputNullableSlice(rctx, fc.Args["arg"].([]string)) 1918 }) 1919 1920 if resTmp == nil { 1921 if !graphql.HasFieldError(ctx, fc) { 1922 ec.Errorf(ctx, "must not be null") 1923 } 1924 return graphql.Null 1925 } 1926 res := resTmp.(bool) 1927 fc.Result = res 1928 return ec.marshalNBoolean2bool(ctx, field.Selections, res) 1929 } 1930 1931 func (ec *executionContext) fieldContext_Query_inputNullableSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1932 fc = &graphql.FieldContext{ 1933 Object: "Query", 1934 Field: field, 1935 IsMethod: true, 1936 IsResolver: true, 1937 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1938 return nil, errors.New("field of type Boolean does not have child fields") 1939 }, 1940 } 1941 defer func() { 1942 if r := recover(); r != nil { 1943 err = ec.Recover(ctx, r) 1944 ec.Error(ctx, err) 1945 } 1946 }() 1947 ctx = graphql.WithFieldContext(ctx, fc) 1948 if fc.Args, err = ec.field_Query_inputNullableSlice_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 1949 ec.Error(ctx, err) 1950 return 1951 } 1952 return fc, nil 1953 } 1954 1955 func (ec *executionContext) _Query_shapeUnion(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 1956 fc, err := ec.fieldContext_Query_shapeUnion(ctx, field) 1957 if err != nil { 1958 return graphql.Null 1959 } 1960 ctx = graphql.WithFieldContext(ctx, fc) 1961 defer func() { 1962 if r := recover(); r != nil { 1963 ec.Error(ctx, ec.Recover(ctx, r)) 1964 ret = graphql.Null 1965 } 1966 }() 1967 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 1968 ctx = rctx // use context from middleware stack in children 1969 return ec.resolvers.Query().ShapeUnion(rctx) 1970 }) 1971 1972 if resTmp == nil { 1973 if !graphql.HasFieldError(ctx, fc) { 1974 ec.Errorf(ctx, "must not be null") 1975 } 1976 return graphql.Null 1977 } 1978 res := resTmp.(ShapeUnion) 1979 fc.Result = res 1980 return ec.marshalNShapeUnion2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐShapeUnion(ctx, field.Selections, res) 1981 } 1982 1983 func (ec *executionContext) fieldContext_Query_shapeUnion(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 1984 fc = &graphql.FieldContext{ 1985 Object: "Query", 1986 Field: field, 1987 IsMethod: true, 1988 IsResolver: true, 1989 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 1990 return nil, errors.New("field of type ShapeUnion does not have child fields") 1991 }, 1992 } 1993 return fc, nil 1994 } 1995 1996 func (ec *executionContext) _Query_autobind(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 1997 fc, err := ec.fieldContext_Query_autobind(ctx, field) 1998 if err != nil { 1999 return graphql.Null 2000 } 2001 ctx = graphql.WithFieldContext(ctx, fc) 2002 defer func() { 2003 if r := recover(); r != nil { 2004 ec.Error(ctx, ec.Recover(ctx, r)) 2005 ret = graphql.Null 2006 } 2007 }() 2008 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2009 ctx = rctx // use context from middleware stack in children 2010 return ec.resolvers.Query().Autobind(rctx) 2011 }) 2012 2013 if resTmp == nil { 2014 return graphql.Null 2015 } 2016 res := resTmp.(*Autobind) 2017 fc.Result = res 2018 return ec.marshalOAutobind2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐAutobind(ctx, field.Selections, res) 2019 } 2020 2021 func (ec *executionContext) fieldContext_Query_autobind(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2022 fc = &graphql.FieldContext{ 2023 Object: "Query", 2024 Field: field, 2025 IsMethod: true, 2026 IsResolver: true, 2027 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2028 switch field.Name { 2029 case "int": 2030 return ec.fieldContext_Autobind_int(ctx, field) 2031 case "int32": 2032 return ec.fieldContext_Autobind_int32(ctx, field) 2033 case "int64": 2034 return ec.fieldContext_Autobind_int64(ctx, field) 2035 case "idStr": 2036 return ec.fieldContext_Autobind_idStr(ctx, field) 2037 case "idInt": 2038 return ec.fieldContext_Autobind_idInt(ctx, field) 2039 } 2040 return nil, fmt.Errorf("no field named %q was found under type Autobind", field.Name) 2041 }, 2042 } 2043 return fc, nil 2044 } 2045 2046 func (ec *executionContext) _Query_deprecatedField(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2047 fc, err := ec.fieldContext_Query_deprecatedField(ctx, field) 2048 if err != nil { 2049 return graphql.Null 2050 } 2051 ctx = graphql.WithFieldContext(ctx, fc) 2052 defer func() { 2053 if r := recover(); r != nil { 2054 ec.Error(ctx, ec.Recover(ctx, r)) 2055 ret = graphql.Null 2056 } 2057 }() 2058 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2059 ctx = rctx // use context from middleware stack in children 2060 return ec.resolvers.Query().DeprecatedField(rctx) 2061 }) 2062 2063 if resTmp == nil { 2064 if !graphql.HasFieldError(ctx, fc) { 2065 ec.Errorf(ctx, "must not be null") 2066 } 2067 return graphql.Null 2068 } 2069 res := resTmp.(string) 2070 fc.Result = res 2071 return ec.marshalNString2string(ctx, field.Selections, res) 2072 } 2073 2074 func (ec *executionContext) fieldContext_Query_deprecatedField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2075 fc = &graphql.FieldContext{ 2076 Object: "Query", 2077 Field: field, 2078 IsMethod: true, 2079 IsResolver: true, 2080 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2081 return nil, errors.New("field of type String does not have child fields") 2082 }, 2083 } 2084 return fc, nil 2085 } 2086 2087 func (ec *executionContext) _Query_overlapping(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2088 fc, err := ec.fieldContext_Query_overlapping(ctx, field) 2089 if err != nil { 2090 return graphql.Null 2091 } 2092 ctx = graphql.WithFieldContext(ctx, fc) 2093 defer func() { 2094 if r := recover(); r != nil { 2095 ec.Error(ctx, ec.Recover(ctx, r)) 2096 ret = graphql.Null 2097 } 2098 }() 2099 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2100 ctx = rctx // use context from middleware stack in children 2101 return ec.resolvers.Query().Overlapping(rctx) 2102 }) 2103 2104 if resTmp == nil { 2105 return graphql.Null 2106 } 2107 res := resTmp.(*OverlappingFields) 2108 fc.Result = res 2109 return ec.marshalOOverlappingFields2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOverlappingFields(ctx, field.Selections, res) 2110 } 2111 2112 func (ec *executionContext) fieldContext_Query_overlapping(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2113 fc = &graphql.FieldContext{ 2114 Object: "Query", 2115 Field: field, 2116 IsMethod: true, 2117 IsResolver: true, 2118 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2119 switch field.Name { 2120 case "oneFoo": 2121 return ec.fieldContext_OverlappingFields_oneFoo(ctx, field) 2122 case "twoFoo": 2123 return ec.fieldContext_OverlappingFields_twoFoo(ctx, field) 2124 case "oldFoo": 2125 return ec.fieldContext_OverlappingFields_oldFoo(ctx, field) 2126 case "newFoo": 2127 return ec.fieldContext_OverlappingFields_newFoo(ctx, field) 2128 case "new_foo": 2129 return ec.fieldContext_OverlappingFields_new_foo(ctx, field) 2130 } 2131 return nil, fmt.Errorf("no field named %q was found under type OverlappingFields", field.Name) 2132 }, 2133 } 2134 return fc, nil 2135 } 2136 2137 func (ec *executionContext) _Query_defaultParameters(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2138 fc, err := ec.fieldContext_Query_defaultParameters(ctx, field) 2139 if err != nil { 2140 return graphql.Null 2141 } 2142 ctx = graphql.WithFieldContext(ctx, fc) 2143 defer func() { 2144 if r := recover(); r != nil { 2145 ec.Error(ctx, ec.Recover(ctx, r)) 2146 ret = graphql.Null 2147 } 2148 }() 2149 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2150 ctx = rctx // use context from middleware stack in children 2151 return ec.resolvers.Query().DefaultParameters(rctx, fc.Args["falsyBoolean"].(*bool), fc.Args["truthyBoolean"].(*bool)) 2152 }) 2153 2154 if resTmp == nil { 2155 if !graphql.HasFieldError(ctx, fc) { 2156 ec.Errorf(ctx, "must not be null") 2157 } 2158 return graphql.Null 2159 } 2160 res := resTmp.(*DefaultParametersMirror) 2161 fc.Result = res 2162 return ec.marshalNDefaultParametersMirror2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐDefaultParametersMirror(ctx, field.Selections, res) 2163 } 2164 2165 func (ec *executionContext) fieldContext_Query_defaultParameters(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2166 fc = &graphql.FieldContext{ 2167 Object: "Query", 2168 Field: field, 2169 IsMethod: true, 2170 IsResolver: true, 2171 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2172 switch field.Name { 2173 case "falsyBoolean": 2174 return ec.fieldContext_DefaultParametersMirror_falsyBoolean(ctx, field) 2175 case "truthyBoolean": 2176 return ec.fieldContext_DefaultParametersMirror_truthyBoolean(ctx, field) 2177 } 2178 return nil, fmt.Errorf("no field named %q was found under type DefaultParametersMirror", field.Name) 2179 }, 2180 } 2181 defer func() { 2182 if r := recover(); r != nil { 2183 err = ec.Recover(ctx, r) 2184 ec.Error(ctx, err) 2185 } 2186 }() 2187 ctx = graphql.WithFieldContext(ctx, fc) 2188 if fc.Args, err = ec.field_Query_defaultParameters_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 2189 ec.Error(ctx, err) 2190 return 2191 } 2192 return fc, nil 2193 } 2194 2195 func (ec *executionContext) _Query_directiveArg(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2196 fc, err := ec.fieldContext_Query_directiveArg(ctx, field) 2197 if err != nil { 2198 return graphql.Null 2199 } 2200 ctx = graphql.WithFieldContext(ctx, fc) 2201 defer func() { 2202 if r := recover(); r != nil { 2203 ec.Error(ctx, ec.Recover(ctx, r)) 2204 ret = graphql.Null 2205 } 2206 }() 2207 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2208 ctx = rctx // use context from middleware stack in children 2209 return ec.resolvers.Query().DirectiveArg(rctx, fc.Args["arg"].(string)) 2210 }) 2211 2212 if resTmp == nil { 2213 return graphql.Null 2214 } 2215 res := resTmp.(*string) 2216 fc.Result = res 2217 return ec.marshalOString2ᚖstring(ctx, field.Selections, res) 2218 } 2219 2220 func (ec *executionContext) fieldContext_Query_directiveArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2221 fc = &graphql.FieldContext{ 2222 Object: "Query", 2223 Field: field, 2224 IsMethod: true, 2225 IsResolver: true, 2226 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2227 return nil, errors.New("field of type String does not have child fields") 2228 }, 2229 } 2230 defer func() { 2231 if r := recover(); r != nil { 2232 err = ec.Recover(ctx, r) 2233 ec.Error(ctx, err) 2234 } 2235 }() 2236 ctx = graphql.WithFieldContext(ctx, fc) 2237 if fc.Args, err = ec.field_Query_directiveArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 2238 ec.Error(ctx, err) 2239 return 2240 } 2241 return fc, nil 2242 } 2243 2244 func (ec *executionContext) _Query_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2245 fc, err := ec.fieldContext_Query_directiveNullableArg(ctx, field) 2246 if err != nil { 2247 return graphql.Null 2248 } 2249 ctx = graphql.WithFieldContext(ctx, fc) 2250 defer func() { 2251 if r := recover(); r != nil { 2252 ec.Error(ctx, ec.Recover(ctx, r)) 2253 ret = graphql.Null 2254 } 2255 }() 2256 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2257 ctx = rctx // use context from middleware stack in children 2258 return ec.resolvers.Query().DirectiveNullableArg(rctx, fc.Args["arg"].(*int), fc.Args["arg2"].(*int), fc.Args["arg3"].(*string)) 2259 }) 2260 2261 if resTmp == nil { 2262 return graphql.Null 2263 } 2264 res := resTmp.(*string) 2265 fc.Result = res 2266 return ec.marshalOString2ᚖstring(ctx, field.Selections, res) 2267 } 2268 2269 func (ec *executionContext) fieldContext_Query_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2270 fc = &graphql.FieldContext{ 2271 Object: "Query", 2272 Field: field, 2273 IsMethod: true, 2274 IsResolver: true, 2275 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2276 return nil, errors.New("field of type String does not have child fields") 2277 }, 2278 } 2279 defer func() { 2280 if r := recover(); r != nil { 2281 err = ec.Recover(ctx, r) 2282 ec.Error(ctx, err) 2283 } 2284 }() 2285 ctx = graphql.WithFieldContext(ctx, fc) 2286 if fc.Args, err = ec.field_Query_directiveNullableArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 2287 ec.Error(ctx, err) 2288 return 2289 } 2290 return fc, nil 2291 } 2292 2293 func (ec *executionContext) _Query_directiveInputNullable(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2294 fc, err := ec.fieldContext_Query_directiveInputNullable(ctx, field) 2295 if err != nil { 2296 return graphql.Null 2297 } 2298 ctx = graphql.WithFieldContext(ctx, fc) 2299 defer func() { 2300 if r := recover(); r != nil { 2301 ec.Error(ctx, ec.Recover(ctx, r)) 2302 ret = graphql.Null 2303 } 2304 }() 2305 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2306 ctx = rctx // use context from middleware stack in children 2307 return ec.resolvers.Query().DirectiveInputNullable(rctx, fc.Args["arg"].(*InputDirectives)) 2308 }) 2309 2310 if resTmp == nil { 2311 return graphql.Null 2312 } 2313 res := resTmp.(*string) 2314 fc.Result = res 2315 return ec.marshalOString2ᚖstring(ctx, field.Selections, res) 2316 } 2317 2318 func (ec *executionContext) fieldContext_Query_directiveInputNullable(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2319 fc = &graphql.FieldContext{ 2320 Object: "Query", 2321 Field: field, 2322 IsMethod: true, 2323 IsResolver: true, 2324 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2325 return nil, errors.New("field of type String does not have child fields") 2326 }, 2327 } 2328 defer func() { 2329 if r := recover(); r != nil { 2330 err = ec.Recover(ctx, r) 2331 ec.Error(ctx, err) 2332 } 2333 }() 2334 ctx = graphql.WithFieldContext(ctx, fc) 2335 if fc.Args, err = ec.field_Query_directiveInputNullable_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 2336 ec.Error(ctx, err) 2337 return 2338 } 2339 return fc, nil 2340 } 2341 2342 func (ec *executionContext) _Query_directiveInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2343 fc, err := ec.fieldContext_Query_directiveInput(ctx, field) 2344 if err != nil { 2345 return graphql.Null 2346 } 2347 ctx = graphql.WithFieldContext(ctx, fc) 2348 defer func() { 2349 if r := recover(); r != nil { 2350 ec.Error(ctx, ec.Recover(ctx, r)) 2351 ret = graphql.Null 2352 } 2353 }() 2354 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2355 ctx = rctx // use context from middleware stack in children 2356 return ec.resolvers.Query().DirectiveInput(rctx, fc.Args["arg"].(InputDirectives)) 2357 }) 2358 2359 if resTmp == nil { 2360 return graphql.Null 2361 } 2362 res := resTmp.(*string) 2363 fc.Result = res 2364 return ec.marshalOString2ᚖstring(ctx, field.Selections, res) 2365 } 2366 2367 func (ec *executionContext) fieldContext_Query_directiveInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2368 fc = &graphql.FieldContext{ 2369 Object: "Query", 2370 Field: field, 2371 IsMethod: true, 2372 IsResolver: true, 2373 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2374 return nil, errors.New("field of type String does not have child fields") 2375 }, 2376 } 2377 defer func() { 2378 if r := recover(); r != nil { 2379 err = ec.Recover(ctx, r) 2380 ec.Error(ctx, err) 2381 } 2382 }() 2383 ctx = graphql.WithFieldContext(ctx, fc) 2384 if fc.Args, err = ec.field_Query_directiveInput_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 2385 ec.Error(ctx, err) 2386 return 2387 } 2388 return fc, nil 2389 } 2390 2391 func (ec *executionContext) _Query_directiveInputType(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2392 fc, err := ec.fieldContext_Query_directiveInputType(ctx, field) 2393 if err != nil { 2394 return graphql.Null 2395 } 2396 ctx = graphql.WithFieldContext(ctx, fc) 2397 defer func() { 2398 if r := recover(); r != nil { 2399 ec.Error(ctx, ec.Recover(ctx, r)) 2400 ret = graphql.Null 2401 } 2402 }() 2403 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2404 ctx = rctx // use context from middleware stack in children 2405 return ec.resolvers.Query().DirectiveInputType(rctx, fc.Args["arg"].(InnerInput)) 2406 }) 2407 2408 if resTmp == nil { 2409 return graphql.Null 2410 } 2411 res := resTmp.(*string) 2412 fc.Result = res 2413 return ec.marshalOString2ᚖstring(ctx, field.Selections, res) 2414 } 2415 2416 func (ec *executionContext) fieldContext_Query_directiveInputType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2417 fc = &graphql.FieldContext{ 2418 Object: "Query", 2419 Field: field, 2420 IsMethod: true, 2421 IsResolver: true, 2422 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2423 return nil, errors.New("field of type String does not have child fields") 2424 }, 2425 } 2426 defer func() { 2427 if r := recover(); r != nil { 2428 err = ec.Recover(ctx, r) 2429 ec.Error(ctx, err) 2430 } 2431 }() 2432 ctx = graphql.WithFieldContext(ctx, fc) 2433 if fc.Args, err = ec.field_Query_directiveInputType_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 2434 ec.Error(ctx, err) 2435 return 2436 } 2437 return fc, nil 2438 } 2439 2440 func (ec *executionContext) _Query_directiveObject(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2441 fc, err := ec.fieldContext_Query_directiveObject(ctx, field) 2442 if err != nil { 2443 return graphql.Null 2444 } 2445 ctx = graphql.WithFieldContext(ctx, fc) 2446 defer func() { 2447 if r := recover(); r != nil { 2448 ec.Error(ctx, ec.Recover(ctx, r)) 2449 ret = graphql.Null 2450 } 2451 }() 2452 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2453 directive0 := func(rctx context.Context) (interface{}, error) { 2454 ctx = rctx // use context from middleware stack in children 2455 return ec.resolvers.Query().DirectiveObject(rctx) 2456 } 2457 directive1 := func(ctx context.Context) (interface{}, error) { 2458 location, err := ec.unmarshalNString2string(ctx, "order1_1") 2459 if err != nil { 2460 return nil, err 2461 } 2462 if ec.directives.Order1 == nil { 2463 return nil, errors.New("directive order1 is not implemented") 2464 } 2465 return ec.directives.Order1(ctx, nil, directive0, location) 2466 } 2467 directive2 := func(ctx context.Context) (interface{}, error) { 2468 location, err := ec.unmarshalNString2string(ctx, "order1_2") 2469 if err != nil { 2470 return nil, err 2471 } 2472 if ec.directives.Order1 == nil { 2473 return nil, errors.New("directive order1 is not implemented") 2474 } 2475 return ec.directives.Order1(ctx, nil, directive1, location) 2476 } 2477 directive3 := func(ctx context.Context) (interface{}, error) { 2478 location, err := ec.unmarshalNString2string(ctx, "order2_1") 2479 if err != nil { 2480 return nil, err 2481 } 2482 if ec.directives.Order2 == nil { 2483 return nil, errors.New("directive order2 is not implemented") 2484 } 2485 return ec.directives.Order2(ctx, nil, directive2, location) 2486 } 2487 directive4 := func(ctx context.Context) (interface{}, error) { 2488 location, err := ec.unmarshalNString2string(ctx, "Query_field") 2489 if err != nil { 2490 return nil, err 2491 } 2492 if ec.directives.Order1 == nil { 2493 return nil, errors.New("directive order1 is not implemented") 2494 } 2495 return ec.directives.Order1(ctx, nil, directive3, location) 2496 } 2497 2498 tmp, err := directive4(rctx) 2499 if err != nil { 2500 return nil, graphql.ErrorOnPath(ctx, err) 2501 } 2502 if tmp == nil { 2503 return nil, nil 2504 } 2505 if data, ok := tmp.(*ObjectDirectives); ok { 2506 return data, nil 2507 } 2508 return nil, fmt.Errorf(`unexpected type %T from directive, should be *github.com/luciferinlove/gqlgen/codegen/testserver/followschema.ObjectDirectives`, tmp) 2509 }) 2510 2511 if resTmp == nil { 2512 return graphql.Null 2513 } 2514 res := resTmp.(*ObjectDirectives) 2515 fc.Result = res 2516 return ec.marshalOObjectDirectives2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐObjectDirectives(ctx, field.Selections, res) 2517 } 2518 2519 func (ec *executionContext) fieldContext_Query_directiveObject(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2520 fc = &graphql.FieldContext{ 2521 Object: "Query", 2522 Field: field, 2523 IsMethod: true, 2524 IsResolver: true, 2525 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2526 switch field.Name { 2527 case "text": 2528 return ec.fieldContext_ObjectDirectives_text(ctx, field) 2529 case "nullableText": 2530 return ec.fieldContext_ObjectDirectives_nullableText(ctx, field) 2531 case "order": 2532 return ec.fieldContext_ObjectDirectives_order(ctx, field) 2533 } 2534 return nil, fmt.Errorf("no field named %q was found under type ObjectDirectives", field.Name) 2535 }, 2536 } 2537 return fc, nil 2538 } 2539 2540 func (ec *executionContext) _Query_directiveObjectWithCustomGoModel(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2541 fc, err := ec.fieldContext_Query_directiveObjectWithCustomGoModel(ctx, field) 2542 if err != nil { 2543 return graphql.Null 2544 } 2545 ctx = graphql.WithFieldContext(ctx, fc) 2546 defer func() { 2547 if r := recover(); r != nil { 2548 ec.Error(ctx, ec.Recover(ctx, r)) 2549 ret = graphql.Null 2550 } 2551 }() 2552 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2553 ctx = rctx // use context from middleware stack in children 2554 return ec.resolvers.Query().DirectiveObjectWithCustomGoModel(rctx) 2555 }) 2556 2557 if resTmp == nil { 2558 return graphql.Null 2559 } 2560 res := resTmp.(*ObjectDirectivesWithCustomGoModel) 2561 fc.Result = res 2562 return ec.marshalOObjectDirectivesWithCustomGoModel2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐObjectDirectivesWithCustomGoModel(ctx, field.Selections, res) 2563 } 2564 2565 func (ec *executionContext) fieldContext_Query_directiveObjectWithCustomGoModel(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2566 fc = &graphql.FieldContext{ 2567 Object: "Query", 2568 Field: field, 2569 IsMethod: true, 2570 IsResolver: true, 2571 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2572 switch field.Name { 2573 case "nullableText": 2574 return ec.fieldContext_ObjectDirectivesWithCustomGoModel_nullableText(ctx, field) 2575 } 2576 return nil, fmt.Errorf("no field named %q was found under type ObjectDirectivesWithCustomGoModel", field.Name) 2577 }, 2578 } 2579 return fc, nil 2580 } 2581 2582 func (ec *executionContext) _Query_directiveFieldDef(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2583 fc, err := ec.fieldContext_Query_directiveFieldDef(ctx, field) 2584 if err != nil { 2585 return graphql.Null 2586 } 2587 ctx = graphql.WithFieldContext(ctx, fc) 2588 defer func() { 2589 if r := recover(); r != nil { 2590 ec.Error(ctx, ec.Recover(ctx, r)) 2591 ret = graphql.Null 2592 } 2593 }() 2594 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2595 directive0 := func(rctx context.Context) (interface{}, error) { 2596 ctx = rctx // use context from middleware stack in children 2597 return ec.resolvers.Query().DirectiveFieldDef(rctx, fc.Args["ret"].(string)) 2598 } 2599 directive1 := func(ctx context.Context) (interface{}, error) { 2600 min, err := ec.unmarshalNInt2int(ctx, 1) 2601 if err != nil { 2602 return nil, err 2603 } 2604 message, err := ec.unmarshalOString2ᚖstring(ctx, "not valid") 2605 if err != nil { 2606 return nil, err 2607 } 2608 if ec.directives.Length == nil { 2609 return nil, errors.New("directive length is not implemented") 2610 } 2611 return ec.directives.Length(ctx, nil, directive0, min, nil, message) 2612 } 2613 2614 tmp, err := directive1(rctx) 2615 if err != nil { 2616 return nil, graphql.ErrorOnPath(ctx, err) 2617 } 2618 if tmp == nil { 2619 return nil, nil 2620 } 2621 if data, ok := tmp.(string); ok { 2622 return data, nil 2623 } 2624 return nil, fmt.Errorf(`unexpected type %T from directive, should be string`, tmp) 2625 }) 2626 2627 if resTmp == nil { 2628 if !graphql.HasFieldError(ctx, fc) { 2629 ec.Errorf(ctx, "must not be null") 2630 } 2631 return graphql.Null 2632 } 2633 res := resTmp.(string) 2634 fc.Result = res 2635 return ec.marshalNString2string(ctx, field.Selections, res) 2636 } 2637 2638 func (ec *executionContext) fieldContext_Query_directiveFieldDef(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2639 fc = &graphql.FieldContext{ 2640 Object: "Query", 2641 Field: field, 2642 IsMethod: true, 2643 IsResolver: true, 2644 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2645 return nil, errors.New("field of type String does not have child fields") 2646 }, 2647 } 2648 defer func() { 2649 if r := recover(); r != nil { 2650 err = ec.Recover(ctx, r) 2651 ec.Error(ctx, err) 2652 } 2653 }() 2654 ctx = graphql.WithFieldContext(ctx, fc) 2655 if fc.Args, err = ec.field_Query_directiveFieldDef_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 2656 ec.Error(ctx, err) 2657 return 2658 } 2659 return fc, nil 2660 } 2661 2662 func (ec *executionContext) _Query_directiveField(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2663 fc, err := ec.fieldContext_Query_directiveField(ctx, field) 2664 if err != nil { 2665 return graphql.Null 2666 } 2667 ctx = graphql.WithFieldContext(ctx, fc) 2668 defer func() { 2669 if r := recover(); r != nil { 2670 ec.Error(ctx, ec.Recover(ctx, r)) 2671 ret = graphql.Null 2672 } 2673 }() 2674 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2675 ctx = rctx // use context from middleware stack in children 2676 return ec.resolvers.Query().DirectiveField(rctx) 2677 }) 2678 2679 if resTmp == nil { 2680 return graphql.Null 2681 } 2682 res := resTmp.(*string) 2683 fc.Result = res 2684 return ec.marshalOString2ᚖstring(ctx, field.Selections, res) 2685 } 2686 2687 func (ec *executionContext) fieldContext_Query_directiveField(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2688 fc = &graphql.FieldContext{ 2689 Object: "Query", 2690 Field: field, 2691 IsMethod: true, 2692 IsResolver: true, 2693 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2694 return nil, errors.New("field of type String does not have child fields") 2695 }, 2696 } 2697 return fc, nil 2698 } 2699 2700 func (ec *executionContext) _Query_directiveDouble(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2701 fc, err := ec.fieldContext_Query_directiveDouble(ctx, field) 2702 if err != nil { 2703 return graphql.Null 2704 } 2705 ctx = graphql.WithFieldContext(ctx, fc) 2706 defer func() { 2707 if r := recover(); r != nil { 2708 ec.Error(ctx, ec.Recover(ctx, r)) 2709 ret = graphql.Null 2710 } 2711 }() 2712 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2713 directive0 := func(rctx context.Context) (interface{}, error) { 2714 ctx = rctx // use context from middleware stack in children 2715 return ec.resolvers.Query().DirectiveDouble(rctx) 2716 } 2717 directive1 := func(ctx context.Context) (interface{}, error) { 2718 if ec.directives.Directive1 == nil { 2719 return nil, errors.New("directive directive1 is not implemented") 2720 } 2721 return ec.directives.Directive1(ctx, nil, directive0) 2722 } 2723 directive2 := func(ctx context.Context) (interface{}, error) { 2724 if ec.directives.Directive2 == nil { 2725 return nil, errors.New("directive directive2 is not implemented") 2726 } 2727 return ec.directives.Directive2(ctx, nil, directive1) 2728 } 2729 2730 tmp, err := directive2(rctx) 2731 if err != nil { 2732 return nil, graphql.ErrorOnPath(ctx, err) 2733 } 2734 if tmp == nil { 2735 return nil, nil 2736 } 2737 if data, ok := tmp.(*string); ok { 2738 return data, nil 2739 } 2740 return nil, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp) 2741 }) 2742 2743 if resTmp == nil { 2744 return graphql.Null 2745 } 2746 res := resTmp.(*string) 2747 fc.Result = res 2748 return ec.marshalOString2ᚖstring(ctx, field.Selections, res) 2749 } 2750 2751 func (ec *executionContext) fieldContext_Query_directiveDouble(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2752 fc = &graphql.FieldContext{ 2753 Object: "Query", 2754 Field: field, 2755 IsMethod: true, 2756 IsResolver: true, 2757 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2758 return nil, errors.New("field of type String does not have child fields") 2759 }, 2760 } 2761 return fc, nil 2762 } 2763 2764 func (ec *executionContext) _Query_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2765 fc, err := ec.fieldContext_Query_directiveUnimplemented(ctx, field) 2766 if err != nil { 2767 return graphql.Null 2768 } 2769 ctx = graphql.WithFieldContext(ctx, fc) 2770 defer func() { 2771 if r := recover(); r != nil { 2772 ec.Error(ctx, ec.Recover(ctx, r)) 2773 ret = graphql.Null 2774 } 2775 }() 2776 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2777 directive0 := func(rctx context.Context) (interface{}, error) { 2778 ctx = rctx // use context from middleware stack in children 2779 return ec.resolvers.Query().DirectiveUnimplemented(rctx) 2780 } 2781 directive1 := func(ctx context.Context) (interface{}, error) { 2782 if ec.directives.Unimplemented == nil { 2783 return nil, errors.New("directive unimplemented is not implemented") 2784 } 2785 return ec.directives.Unimplemented(ctx, nil, directive0) 2786 } 2787 2788 tmp, err := directive1(rctx) 2789 if err != nil { 2790 return nil, graphql.ErrorOnPath(ctx, err) 2791 } 2792 if tmp == nil { 2793 return nil, nil 2794 } 2795 if data, ok := tmp.(*string); ok { 2796 return data, nil 2797 } 2798 return nil, fmt.Errorf(`unexpected type %T from directive, should be *string`, tmp) 2799 }) 2800 2801 if resTmp == nil { 2802 return graphql.Null 2803 } 2804 res := resTmp.(*string) 2805 fc.Result = res 2806 return ec.marshalOString2ᚖstring(ctx, field.Selections, res) 2807 } 2808 2809 func (ec *executionContext) fieldContext_Query_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2810 fc = &graphql.FieldContext{ 2811 Object: "Query", 2812 Field: field, 2813 IsMethod: true, 2814 IsResolver: true, 2815 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2816 return nil, errors.New("field of type String does not have child fields") 2817 }, 2818 } 2819 return fc, nil 2820 } 2821 2822 func (ec *executionContext) _Query_embeddedCase1(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2823 fc, err := ec.fieldContext_Query_embeddedCase1(ctx, field) 2824 if err != nil { 2825 return graphql.Null 2826 } 2827 ctx = graphql.WithFieldContext(ctx, fc) 2828 defer func() { 2829 if r := recover(); r != nil { 2830 ec.Error(ctx, ec.Recover(ctx, r)) 2831 ret = graphql.Null 2832 } 2833 }() 2834 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2835 ctx = rctx // use context from middleware stack in children 2836 return ec.resolvers.Query().EmbeddedCase1(rctx) 2837 }) 2838 2839 if resTmp == nil { 2840 return graphql.Null 2841 } 2842 res := resTmp.(*EmbeddedCase1) 2843 fc.Result = res 2844 return ec.marshalOEmbeddedCase12ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐEmbeddedCase1(ctx, field.Selections, res) 2845 } 2846 2847 func (ec *executionContext) fieldContext_Query_embeddedCase1(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2848 fc = &graphql.FieldContext{ 2849 Object: "Query", 2850 Field: field, 2851 IsMethod: true, 2852 IsResolver: true, 2853 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2854 switch field.Name { 2855 case "exportedEmbeddedPointerExportedMethod": 2856 return ec.fieldContext_EmbeddedCase1_exportedEmbeddedPointerExportedMethod(ctx, field) 2857 } 2858 return nil, fmt.Errorf("no field named %q was found under type EmbeddedCase1", field.Name) 2859 }, 2860 } 2861 return fc, nil 2862 } 2863 2864 func (ec *executionContext) _Query_embeddedCase2(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2865 fc, err := ec.fieldContext_Query_embeddedCase2(ctx, field) 2866 if err != nil { 2867 return graphql.Null 2868 } 2869 ctx = graphql.WithFieldContext(ctx, fc) 2870 defer func() { 2871 if r := recover(); r != nil { 2872 ec.Error(ctx, ec.Recover(ctx, r)) 2873 ret = graphql.Null 2874 } 2875 }() 2876 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2877 ctx = rctx // use context from middleware stack in children 2878 return ec.resolvers.Query().EmbeddedCase2(rctx) 2879 }) 2880 2881 if resTmp == nil { 2882 return graphql.Null 2883 } 2884 res := resTmp.(*EmbeddedCase2) 2885 fc.Result = res 2886 return ec.marshalOEmbeddedCase22ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐEmbeddedCase2(ctx, field.Selections, res) 2887 } 2888 2889 func (ec *executionContext) fieldContext_Query_embeddedCase2(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2890 fc = &graphql.FieldContext{ 2891 Object: "Query", 2892 Field: field, 2893 IsMethod: true, 2894 IsResolver: true, 2895 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2896 switch field.Name { 2897 case "unexportedEmbeddedPointerExportedMethod": 2898 return ec.fieldContext_EmbeddedCase2_unexportedEmbeddedPointerExportedMethod(ctx, field) 2899 } 2900 return nil, fmt.Errorf("no field named %q was found under type EmbeddedCase2", field.Name) 2901 }, 2902 } 2903 return fc, nil 2904 } 2905 2906 func (ec *executionContext) _Query_embeddedCase3(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2907 fc, err := ec.fieldContext_Query_embeddedCase3(ctx, field) 2908 if err != nil { 2909 return graphql.Null 2910 } 2911 ctx = graphql.WithFieldContext(ctx, fc) 2912 defer func() { 2913 if r := recover(); r != nil { 2914 ec.Error(ctx, ec.Recover(ctx, r)) 2915 ret = graphql.Null 2916 } 2917 }() 2918 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2919 ctx = rctx // use context from middleware stack in children 2920 return ec.resolvers.Query().EmbeddedCase3(rctx) 2921 }) 2922 2923 if resTmp == nil { 2924 return graphql.Null 2925 } 2926 res := resTmp.(*EmbeddedCase3) 2927 fc.Result = res 2928 return ec.marshalOEmbeddedCase32ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐEmbeddedCase3(ctx, field.Selections, res) 2929 } 2930 2931 func (ec *executionContext) fieldContext_Query_embeddedCase3(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2932 fc = &graphql.FieldContext{ 2933 Object: "Query", 2934 Field: field, 2935 IsMethod: true, 2936 IsResolver: true, 2937 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2938 switch field.Name { 2939 case "unexportedEmbeddedInterfaceExportedMethod": 2940 return ec.fieldContext_EmbeddedCase3_unexportedEmbeddedInterfaceExportedMethod(ctx, field) 2941 } 2942 return nil, fmt.Errorf("no field named %q was found under type EmbeddedCase3", field.Name) 2943 }, 2944 } 2945 return fc, nil 2946 } 2947 2948 func (ec *executionContext) _Query_enumInInput(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 2949 fc, err := ec.fieldContext_Query_enumInInput(ctx, field) 2950 if err != nil { 2951 return graphql.Null 2952 } 2953 ctx = graphql.WithFieldContext(ctx, fc) 2954 defer func() { 2955 if r := recover(); r != nil { 2956 ec.Error(ctx, ec.Recover(ctx, r)) 2957 ret = graphql.Null 2958 } 2959 }() 2960 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 2961 ctx = rctx // use context from middleware stack in children 2962 return ec.resolvers.Query().EnumInInput(rctx, fc.Args["input"].(*InputWithEnumValue)) 2963 }) 2964 2965 if resTmp == nil { 2966 if !graphql.HasFieldError(ctx, fc) { 2967 ec.Errorf(ctx, "must not be null") 2968 } 2969 return graphql.Null 2970 } 2971 res := resTmp.(EnumTest) 2972 fc.Result = res 2973 return ec.marshalNEnumTest2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐEnumTest(ctx, field.Selections, res) 2974 } 2975 2976 func (ec *executionContext) fieldContext_Query_enumInInput(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 2977 fc = &graphql.FieldContext{ 2978 Object: "Query", 2979 Field: field, 2980 IsMethod: true, 2981 IsResolver: true, 2982 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 2983 return nil, errors.New("field of type EnumTest does not have child fields") 2984 }, 2985 } 2986 defer func() { 2987 if r := recover(); r != nil { 2988 err = ec.Recover(ctx, r) 2989 ec.Error(ctx, err) 2990 } 2991 }() 2992 ctx = graphql.WithFieldContext(ctx, fc) 2993 if fc.Args, err = ec.field_Query_enumInInput_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 2994 ec.Error(ctx, err) 2995 return 2996 } 2997 return fc, nil 2998 } 2999 3000 func (ec *executionContext) _Query_shapes(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3001 fc, err := ec.fieldContext_Query_shapes(ctx, field) 3002 if err != nil { 3003 return graphql.Null 3004 } 3005 ctx = graphql.WithFieldContext(ctx, fc) 3006 defer func() { 3007 if r := recover(); r != nil { 3008 ec.Error(ctx, ec.Recover(ctx, r)) 3009 ret = graphql.Null 3010 } 3011 }() 3012 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3013 ctx = rctx // use context from middleware stack in children 3014 return ec.resolvers.Query().Shapes(rctx) 3015 }) 3016 3017 if resTmp == nil { 3018 return graphql.Null 3019 } 3020 res := resTmp.([]Shape) 3021 fc.Result = res 3022 return ec.marshalOShape2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐShape(ctx, field.Selections, res) 3023 } 3024 3025 func (ec *executionContext) fieldContext_Query_shapes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3026 fc = &graphql.FieldContext{ 3027 Object: "Query", 3028 Field: field, 3029 IsMethod: true, 3030 IsResolver: true, 3031 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3032 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE") 3033 }, 3034 } 3035 return fc, nil 3036 } 3037 3038 func (ec *executionContext) _Query_noShape(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3039 fc, err := ec.fieldContext_Query_noShape(ctx, field) 3040 if err != nil { 3041 return graphql.Null 3042 } 3043 ctx = graphql.WithFieldContext(ctx, fc) 3044 defer func() { 3045 if r := recover(); r != nil { 3046 ec.Error(ctx, ec.Recover(ctx, r)) 3047 ret = graphql.Null 3048 } 3049 }() 3050 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3051 directive0 := func(rctx context.Context) (interface{}, error) { 3052 ctx = rctx // use context from middleware stack in children 3053 return ec.resolvers.Query().NoShape(rctx) 3054 } 3055 directive1 := func(ctx context.Context) (interface{}, error) { 3056 if ec.directives.MakeNil == nil { 3057 return nil, errors.New("directive makeNil is not implemented") 3058 } 3059 return ec.directives.MakeNil(ctx, nil, directive0) 3060 } 3061 3062 tmp, err := directive1(rctx) 3063 if err != nil { 3064 return nil, graphql.ErrorOnPath(ctx, err) 3065 } 3066 if tmp == nil { 3067 return nil, nil 3068 } 3069 if data, ok := tmp.(Shape); ok { 3070 return data, nil 3071 } 3072 return nil, fmt.Errorf(`unexpected type %T from directive, should be github.com/luciferinlove/gqlgen/codegen/testserver/followschema.Shape`, tmp) 3073 }) 3074 3075 if resTmp == nil { 3076 return graphql.Null 3077 } 3078 res := resTmp.(Shape) 3079 fc.Result = res 3080 return ec.marshalOShape2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐShape(ctx, field.Selections, res) 3081 } 3082 3083 func (ec *executionContext) fieldContext_Query_noShape(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3084 fc = &graphql.FieldContext{ 3085 Object: "Query", 3086 Field: field, 3087 IsMethod: true, 3088 IsResolver: true, 3089 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3090 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE") 3091 }, 3092 } 3093 return fc, nil 3094 } 3095 3096 func (ec *executionContext) _Query_node(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3097 fc, err := ec.fieldContext_Query_node(ctx, field) 3098 if err != nil { 3099 return graphql.Null 3100 } 3101 ctx = graphql.WithFieldContext(ctx, fc) 3102 defer func() { 3103 if r := recover(); r != nil { 3104 ec.Error(ctx, ec.Recover(ctx, r)) 3105 ret = graphql.Null 3106 } 3107 }() 3108 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3109 ctx = rctx // use context from middleware stack in children 3110 return ec.resolvers.Query().Node(rctx) 3111 }) 3112 3113 if resTmp == nil { 3114 if !graphql.HasFieldError(ctx, fc) { 3115 ec.Errorf(ctx, "must not be null") 3116 } 3117 return graphql.Null 3118 } 3119 res := resTmp.(Node) 3120 fc.Result = res 3121 return ec.marshalNNode2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐNode(ctx, field.Selections, res) 3122 } 3123 3124 func (ec *executionContext) fieldContext_Query_node(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3125 fc = &graphql.FieldContext{ 3126 Object: "Query", 3127 Field: field, 3128 IsMethod: true, 3129 IsResolver: true, 3130 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3131 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE") 3132 }, 3133 } 3134 return fc, nil 3135 } 3136 3137 func (ec *executionContext) _Query_noShapeTypedNil(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3138 fc, err := ec.fieldContext_Query_noShapeTypedNil(ctx, field) 3139 if err != nil { 3140 return graphql.Null 3141 } 3142 ctx = graphql.WithFieldContext(ctx, fc) 3143 defer func() { 3144 if r := recover(); r != nil { 3145 ec.Error(ctx, ec.Recover(ctx, r)) 3146 ret = graphql.Null 3147 } 3148 }() 3149 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3150 directive0 := func(rctx context.Context) (interface{}, error) { 3151 ctx = rctx // use context from middleware stack in children 3152 return ec.resolvers.Query().NoShapeTypedNil(rctx) 3153 } 3154 directive1 := func(ctx context.Context) (interface{}, error) { 3155 if ec.directives.MakeTypedNil == nil { 3156 return nil, errors.New("directive makeTypedNil is not implemented") 3157 } 3158 return ec.directives.MakeTypedNil(ctx, nil, directive0) 3159 } 3160 3161 tmp, err := directive1(rctx) 3162 if err != nil { 3163 return nil, graphql.ErrorOnPath(ctx, err) 3164 } 3165 if tmp == nil { 3166 return nil, nil 3167 } 3168 if data, ok := tmp.(Shape); ok { 3169 return data, nil 3170 } 3171 return nil, fmt.Errorf(`unexpected type %T from directive, should be github.com/luciferinlove/gqlgen/codegen/testserver/followschema.Shape`, tmp) 3172 }) 3173 3174 if resTmp == nil { 3175 return graphql.Null 3176 } 3177 res := resTmp.(Shape) 3178 fc.Result = res 3179 return ec.marshalOShape2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐShape(ctx, field.Selections, res) 3180 } 3181 3182 func (ec *executionContext) fieldContext_Query_noShapeTypedNil(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3183 fc = &graphql.FieldContext{ 3184 Object: "Query", 3185 Field: field, 3186 IsMethod: true, 3187 IsResolver: true, 3188 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3189 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE") 3190 }, 3191 } 3192 return fc, nil 3193 } 3194 3195 func (ec *executionContext) _Query_animal(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3196 fc, err := ec.fieldContext_Query_animal(ctx, field) 3197 if err != nil { 3198 return graphql.Null 3199 } 3200 ctx = graphql.WithFieldContext(ctx, fc) 3201 defer func() { 3202 if r := recover(); r != nil { 3203 ec.Error(ctx, ec.Recover(ctx, r)) 3204 ret = graphql.Null 3205 } 3206 }() 3207 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3208 directive0 := func(rctx context.Context) (interface{}, error) { 3209 ctx = rctx // use context from middleware stack in children 3210 return ec.resolvers.Query().Animal(rctx) 3211 } 3212 directive1 := func(ctx context.Context) (interface{}, error) { 3213 if ec.directives.MakeTypedNil == nil { 3214 return nil, errors.New("directive makeTypedNil is not implemented") 3215 } 3216 return ec.directives.MakeTypedNil(ctx, nil, directive0) 3217 } 3218 3219 tmp, err := directive1(rctx) 3220 if err != nil { 3221 return nil, graphql.ErrorOnPath(ctx, err) 3222 } 3223 if tmp == nil { 3224 return nil, nil 3225 } 3226 if data, ok := tmp.(Animal); ok { 3227 return data, nil 3228 } 3229 return nil, fmt.Errorf(`unexpected type %T from directive, should be github.com/luciferinlove/gqlgen/codegen/testserver/followschema.Animal`, tmp) 3230 }) 3231 3232 if resTmp == nil { 3233 return graphql.Null 3234 } 3235 res := resTmp.(Animal) 3236 fc.Result = res 3237 return ec.marshalOAnimal2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐAnimal(ctx, field.Selections, res) 3238 } 3239 3240 func (ec *executionContext) fieldContext_Query_animal(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3241 fc = &graphql.FieldContext{ 3242 Object: "Query", 3243 Field: field, 3244 IsMethod: true, 3245 IsResolver: true, 3246 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3247 return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE") 3248 }, 3249 } 3250 return fc, nil 3251 } 3252 3253 func (ec *executionContext) _Query_notAnInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3254 fc, err := ec.fieldContext_Query_notAnInterface(ctx, field) 3255 if err != nil { 3256 return graphql.Null 3257 } 3258 ctx = graphql.WithFieldContext(ctx, fc) 3259 defer func() { 3260 if r := recover(); r != nil { 3261 ec.Error(ctx, ec.Recover(ctx, r)) 3262 ret = graphql.Null 3263 } 3264 }() 3265 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3266 ctx = rctx // use context from middleware stack in children 3267 return ec.resolvers.Query().NotAnInterface(rctx) 3268 }) 3269 3270 if resTmp == nil { 3271 return graphql.Null 3272 } 3273 res := resTmp.(BackedByInterface) 3274 fc.Result = res 3275 return ec.marshalOBackedByInterface2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐBackedByInterface(ctx, field.Selections, res) 3276 } 3277 3278 func (ec *executionContext) fieldContext_Query_notAnInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3279 fc = &graphql.FieldContext{ 3280 Object: "Query", 3281 Field: field, 3282 IsMethod: true, 3283 IsResolver: true, 3284 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3285 switch field.Name { 3286 case "id": 3287 return ec.fieldContext_BackedByInterface_id(ctx, field) 3288 case "thisShouldBind": 3289 return ec.fieldContext_BackedByInterface_thisShouldBind(ctx, field) 3290 case "thisShouldBindWithError": 3291 return ec.fieldContext_BackedByInterface_thisShouldBindWithError(ctx, field) 3292 } 3293 return nil, fmt.Errorf("no field named %q was found under type BackedByInterface", field.Name) 3294 }, 3295 } 3296 return fc, nil 3297 } 3298 3299 func (ec *executionContext) _Query_issue896a(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3300 fc, err := ec.fieldContext_Query_issue896a(ctx, field) 3301 if err != nil { 3302 return graphql.Null 3303 } 3304 ctx = graphql.WithFieldContext(ctx, fc) 3305 defer func() { 3306 if r := recover(); r != nil { 3307 ec.Error(ctx, ec.Recover(ctx, r)) 3308 ret = graphql.Null 3309 } 3310 }() 3311 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3312 ctx = rctx // use context from middleware stack in children 3313 return ec.resolvers.Query().Issue896a(rctx) 3314 }) 3315 3316 if resTmp == nil { 3317 return graphql.Null 3318 } 3319 res := resTmp.([]*CheckIssue896) 3320 fc.Result = res 3321 return ec.marshalOCheckIssue8962ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐCheckIssue896ᚄ(ctx, field.Selections, res) 3322 } 3323 3324 func (ec *executionContext) fieldContext_Query_issue896a(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3325 fc = &graphql.FieldContext{ 3326 Object: "Query", 3327 Field: field, 3328 IsMethod: true, 3329 IsResolver: true, 3330 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3331 switch field.Name { 3332 case "id": 3333 return ec.fieldContext_CheckIssue896_id(ctx, field) 3334 } 3335 return nil, fmt.Errorf("no field named %q was found under type CheckIssue896", field.Name) 3336 }, 3337 } 3338 return fc, nil 3339 } 3340 3341 func (ec *executionContext) _Query_mapStringInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3342 fc, err := ec.fieldContext_Query_mapStringInterface(ctx, field) 3343 if err != nil { 3344 return graphql.Null 3345 } 3346 ctx = graphql.WithFieldContext(ctx, fc) 3347 defer func() { 3348 if r := recover(); r != nil { 3349 ec.Error(ctx, ec.Recover(ctx, r)) 3350 ret = graphql.Null 3351 } 3352 }() 3353 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3354 ctx = rctx // use context from middleware stack in children 3355 return ec.resolvers.Query().MapStringInterface(rctx, fc.Args["in"].(map[string]interface{})) 3356 }) 3357 3358 if resTmp == nil { 3359 return graphql.Null 3360 } 3361 res := resTmp.(map[string]interface{}) 3362 fc.Result = res 3363 return ec.marshalOMapStringInterfaceType2map(ctx, field.Selections, res) 3364 } 3365 3366 func (ec *executionContext) fieldContext_Query_mapStringInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3367 fc = &graphql.FieldContext{ 3368 Object: "Query", 3369 Field: field, 3370 IsMethod: true, 3371 IsResolver: true, 3372 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3373 switch field.Name { 3374 case "a": 3375 return ec.fieldContext_MapStringInterfaceType_a(ctx, field) 3376 case "b": 3377 return ec.fieldContext_MapStringInterfaceType_b(ctx, field) 3378 } 3379 return nil, fmt.Errorf("no field named %q was found under type MapStringInterfaceType", field.Name) 3380 }, 3381 } 3382 defer func() { 3383 if r := recover(); r != nil { 3384 err = ec.Recover(ctx, r) 3385 ec.Error(ctx, err) 3386 } 3387 }() 3388 ctx = graphql.WithFieldContext(ctx, fc) 3389 if fc.Args, err = ec.field_Query_mapStringInterface_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 3390 ec.Error(ctx, err) 3391 return 3392 } 3393 return fc, nil 3394 } 3395 3396 func (ec *executionContext) _Query_mapNestedStringInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3397 fc, err := ec.fieldContext_Query_mapNestedStringInterface(ctx, field) 3398 if err != nil { 3399 return graphql.Null 3400 } 3401 ctx = graphql.WithFieldContext(ctx, fc) 3402 defer func() { 3403 if r := recover(); r != nil { 3404 ec.Error(ctx, ec.Recover(ctx, r)) 3405 ret = graphql.Null 3406 } 3407 }() 3408 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3409 ctx = rctx // use context from middleware stack in children 3410 return ec.resolvers.Query().MapNestedStringInterface(rctx, fc.Args["in"].(*NestedMapInput)) 3411 }) 3412 3413 if resTmp == nil { 3414 return graphql.Null 3415 } 3416 res := resTmp.(map[string]interface{}) 3417 fc.Result = res 3418 return ec.marshalOMapStringInterfaceType2map(ctx, field.Selections, res) 3419 } 3420 3421 func (ec *executionContext) fieldContext_Query_mapNestedStringInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3422 fc = &graphql.FieldContext{ 3423 Object: "Query", 3424 Field: field, 3425 IsMethod: true, 3426 IsResolver: true, 3427 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3428 switch field.Name { 3429 case "a": 3430 return ec.fieldContext_MapStringInterfaceType_a(ctx, field) 3431 case "b": 3432 return ec.fieldContext_MapStringInterfaceType_b(ctx, field) 3433 } 3434 return nil, fmt.Errorf("no field named %q was found under type MapStringInterfaceType", field.Name) 3435 }, 3436 } 3437 defer func() { 3438 if r := recover(); r != nil { 3439 err = ec.Recover(ctx, r) 3440 ec.Error(ctx, err) 3441 } 3442 }() 3443 ctx = graphql.WithFieldContext(ctx, fc) 3444 if fc.Args, err = ec.field_Query_mapNestedStringInterface_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 3445 ec.Error(ctx, err) 3446 return 3447 } 3448 return fc, nil 3449 } 3450 3451 func (ec *executionContext) _Query_errorBubble(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3452 fc, err := ec.fieldContext_Query_errorBubble(ctx, field) 3453 if err != nil { 3454 return graphql.Null 3455 } 3456 ctx = graphql.WithFieldContext(ctx, fc) 3457 defer func() { 3458 if r := recover(); r != nil { 3459 ec.Error(ctx, ec.Recover(ctx, r)) 3460 ret = graphql.Null 3461 } 3462 }() 3463 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3464 ctx = rctx // use context from middleware stack in children 3465 return ec.resolvers.Query().ErrorBubble(rctx) 3466 }) 3467 3468 if resTmp == nil { 3469 return graphql.Null 3470 } 3471 res := resTmp.(*Error) 3472 fc.Result = res 3473 return ec.marshalOError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐError(ctx, field.Selections, res) 3474 } 3475 3476 func (ec *executionContext) fieldContext_Query_errorBubble(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3477 fc = &graphql.FieldContext{ 3478 Object: "Query", 3479 Field: field, 3480 IsMethod: true, 3481 IsResolver: true, 3482 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3483 switch field.Name { 3484 case "id": 3485 return ec.fieldContext_Error_id(ctx, field) 3486 case "errorOnNonRequiredField": 3487 return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field) 3488 case "errorOnRequiredField": 3489 return ec.fieldContext_Error_errorOnRequiredField(ctx, field) 3490 case "nilOnRequiredField": 3491 return ec.fieldContext_Error_nilOnRequiredField(ctx, field) 3492 } 3493 return nil, fmt.Errorf("no field named %q was found under type Error", field.Name) 3494 }, 3495 } 3496 return fc, nil 3497 } 3498 3499 func (ec *executionContext) _Query_errorBubbleList(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3500 fc, err := ec.fieldContext_Query_errorBubbleList(ctx, field) 3501 if err != nil { 3502 return graphql.Null 3503 } 3504 ctx = graphql.WithFieldContext(ctx, fc) 3505 defer func() { 3506 if r := recover(); r != nil { 3507 ec.Error(ctx, ec.Recover(ctx, r)) 3508 ret = graphql.Null 3509 } 3510 }() 3511 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3512 ctx = rctx // use context from middleware stack in children 3513 return ec.resolvers.Query().ErrorBubbleList(rctx) 3514 }) 3515 3516 if resTmp == nil { 3517 return graphql.Null 3518 } 3519 res := resTmp.([]*Error) 3520 fc.Result = res 3521 return ec.marshalOError2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐErrorᚄ(ctx, field.Selections, res) 3522 } 3523 3524 func (ec *executionContext) fieldContext_Query_errorBubbleList(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3525 fc = &graphql.FieldContext{ 3526 Object: "Query", 3527 Field: field, 3528 IsMethod: true, 3529 IsResolver: true, 3530 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3531 switch field.Name { 3532 case "id": 3533 return ec.fieldContext_Error_id(ctx, field) 3534 case "errorOnNonRequiredField": 3535 return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field) 3536 case "errorOnRequiredField": 3537 return ec.fieldContext_Error_errorOnRequiredField(ctx, field) 3538 case "nilOnRequiredField": 3539 return ec.fieldContext_Error_nilOnRequiredField(ctx, field) 3540 } 3541 return nil, fmt.Errorf("no field named %q was found under type Error", field.Name) 3542 }, 3543 } 3544 return fc, nil 3545 } 3546 3547 func (ec *executionContext) _Query_errorList(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3548 fc, err := ec.fieldContext_Query_errorList(ctx, field) 3549 if err != nil { 3550 return graphql.Null 3551 } 3552 ctx = graphql.WithFieldContext(ctx, fc) 3553 defer func() { 3554 if r := recover(); r != nil { 3555 ec.Error(ctx, ec.Recover(ctx, r)) 3556 ret = graphql.Null 3557 } 3558 }() 3559 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3560 ctx = rctx // use context from middleware stack in children 3561 return ec.resolvers.Query().ErrorList(rctx) 3562 }) 3563 3564 if resTmp == nil { 3565 return graphql.Null 3566 } 3567 res := resTmp.([]*Error) 3568 fc.Result = res 3569 return ec.marshalOError2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐError(ctx, field.Selections, res) 3570 } 3571 3572 func (ec *executionContext) fieldContext_Query_errorList(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3573 fc = &graphql.FieldContext{ 3574 Object: "Query", 3575 Field: field, 3576 IsMethod: true, 3577 IsResolver: true, 3578 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3579 switch field.Name { 3580 case "id": 3581 return ec.fieldContext_Error_id(ctx, field) 3582 case "errorOnNonRequiredField": 3583 return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field) 3584 case "errorOnRequiredField": 3585 return ec.fieldContext_Error_errorOnRequiredField(ctx, field) 3586 case "nilOnRequiredField": 3587 return ec.fieldContext_Error_nilOnRequiredField(ctx, field) 3588 } 3589 return nil, fmt.Errorf("no field named %q was found under type Error", field.Name) 3590 }, 3591 } 3592 return fc, nil 3593 } 3594 3595 func (ec *executionContext) _Query_errors(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3596 fc, err := ec.fieldContext_Query_errors(ctx, field) 3597 if err != nil { 3598 return graphql.Null 3599 } 3600 ctx = graphql.WithFieldContext(ctx, fc) 3601 defer func() { 3602 if r := recover(); r != nil { 3603 ec.Error(ctx, ec.Recover(ctx, r)) 3604 ret = graphql.Null 3605 } 3606 }() 3607 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3608 ctx = rctx // use context from middleware stack in children 3609 return ec.resolvers.Query().Errors(rctx) 3610 }) 3611 3612 if resTmp == nil { 3613 return graphql.Null 3614 } 3615 res := resTmp.(*Errors) 3616 fc.Result = res 3617 return ec.marshalOErrors2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐErrors(ctx, field.Selections, res) 3618 } 3619 3620 func (ec *executionContext) fieldContext_Query_errors(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3621 fc = &graphql.FieldContext{ 3622 Object: "Query", 3623 Field: field, 3624 IsMethod: true, 3625 IsResolver: true, 3626 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3627 switch field.Name { 3628 case "a": 3629 return ec.fieldContext_Errors_a(ctx, field) 3630 case "b": 3631 return ec.fieldContext_Errors_b(ctx, field) 3632 case "c": 3633 return ec.fieldContext_Errors_c(ctx, field) 3634 case "d": 3635 return ec.fieldContext_Errors_d(ctx, field) 3636 case "e": 3637 return ec.fieldContext_Errors_e(ctx, field) 3638 } 3639 return nil, fmt.Errorf("no field named %q was found under type Errors", field.Name) 3640 }, 3641 } 3642 return fc, nil 3643 } 3644 3645 func (ec *executionContext) _Query_valid(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3646 fc, err := ec.fieldContext_Query_valid(ctx, field) 3647 if err != nil { 3648 return graphql.Null 3649 } 3650 ctx = graphql.WithFieldContext(ctx, fc) 3651 defer func() { 3652 if r := recover(); r != nil { 3653 ec.Error(ctx, ec.Recover(ctx, r)) 3654 ret = graphql.Null 3655 } 3656 }() 3657 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3658 ctx = rctx // use context from middleware stack in children 3659 return ec.resolvers.Query().Valid(rctx) 3660 }) 3661 3662 if resTmp == nil { 3663 if !graphql.HasFieldError(ctx, fc) { 3664 ec.Errorf(ctx, "must not be null") 3665 } 3666 return graphql.Null 3667 } 3668 res := resTmp.(string) 3669 fc.Result = res 3670 return ec.marshalNString2string(ctx, field.Selections, res) 3671 } 3672 3673 func (ec *executionContext) fieldContext_Query_valid(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3674 fc = &graphql.FieldContext{ 3675 Object: "Query", 3676 Field: field, 3677 IsMethod: true, 3678 IsResolver: true, 3679 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3680 return nil, errors.New("field of type String does not have child fields") 3681 }, 3682 } 3683 return fc, nil 3684 } 3685 3686 func (ec *executionContext) _Query_panics(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3687 fc, err := ec.fieldContext_Query_panics(ctx, field) 3688 if err != nil { 3689 return graphql.Null 3690 } 3691 ctx = graphql.WithFieldContext(ctx, fc) 3692 defer func() { 3693 if r := recover(); r != nil { 3694 ec.Error(ctx, ec.Recover(ctx, r)) 3695 ret = graphql.Null 3696 } 3697 }() 3698 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3699 ctx = rctx // use context from middleware stack in children 3700 return ec.resolvers.Query().Panics(rctx) 3701 }) 3702 3703 if resTmp == nil { 3704 return graphql.Null 3705 } 3706 res := resTmp.(*Panics) 3707 fc.Result = res 3708 return ec.marshalOPanics2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPanics(ctx, field.Selections, res) 3709 } 3710 3711 func (ec *executionContext) fieldContext_Query_panics(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3712 fc = &graphql.FieldContext{ 3713 Object: "Query", 3714 Field: field, 3715 IsMethod: true, 3716 IsResolver: true, 3717 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3718 switch field.Name { 3719 case "fieldScalarMarshal": 3720 return ec.fieldContext_Panics_fieldScalarMarshal(ctx, field) 3721 case "fieldFuncMarshal": 3722 return ec.fieldContext_Panics_fieldFuncMarshal(ctx, field) 3723 case "argUnmarshal": 3724 return ec.fieldContext_Panics_argUnmarshal(ctx, field) 3725 } 3726 return nil, fmt.Errorf("no field named %q was found under type Panics", field.Name) 3727 }, 3728 } 3729 return fc, nil 3730 } 3731 3732 func (ec *executionContext) _Query_primitiveObject(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3733 fc, err := ec.fieldContext_Query_primitiveObject(ctx, field) 3734 if err != nil { 3735 return graphql.Null 3736 } 3737 ctx = graphql.WithFieldContext(ctx, fc) 3738 defer func() { 3739 if r := recover(); r != nil { 3740 ec.Error(ctx, ec.Recover(ctx, r)) 3741 ret = graphql.Null 3742 } 3743 }() 3744 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3745 ctx = rctx // use context from middleware stack in children 3746 return ec.resolvers.Query().PrimitiveObject(rctx) 3747 }) 3748 3749 if resTmp == nil { 3750 if !graphql.HasFieldError(ctx, fc) { 3751 ec.Errorf(ctx, "must not be null") 3752 } 3753 return graphql.Null 3754 } 3755 res := resTmp.([]Primitive) 3756 fc.Result = res 3757 return ec.marshalNPrimitive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPrimitiveᚄ(ctx, field.Selections, res) 3758 } 3759 3760 func (ec *executionContext) fieldContext_Query_primitiveObject(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3761 fc = &graphql.FieldContext{ 3762 Object: "Query", 3763 Field: field, 3764 IsMethod: true, 3765 IsResolver: true, 3766 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3767 switch field.Name { 3768 case "value": 3769 return ec.fieldContext_Primitive_value(ctx, field) 3770 case "squared": 3771 return ec.fieldContext_Primitive_squared(ctx, field) 3772 } 3773 return nil, fmt.Errorf("no field named %q was found under type Primitive", field.Name) 3774 }, 3775 } 3776 return fc, nil 3777 } 3778 3779 func (ec *executionContext) _Query_primitiveStringObject(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3780 fc, err := ec.fieldContext_Query_primitiveStringObject(ctx, field) 3781 if err != nil { 3782 return graphql.Null 3783 } 3784 ctx = graphql.WithFieldContext(ctx, fc) 3785 defer func() { 3786 if r := recover(); r != nil { 3787 ec.Error(ctx, ec.Recover(ctx, r)) 3788 ret = graphql.Null 3789 } 3790 }() 3791 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3792 ctx = rctx // use context from middleware stack in children 3793 return ec.resolvers.Query().PrimitiveStringObject(rctx) 3794 }) 3795 3796 if resTmp == nil { 3797 if !graphql.HasFieldError(ctx, fc) { 3798 ec.Errorf(ctx, "must not be null") 3799 } 3800 return graphql.Null 3801 } 3802 res := resTmp.([]PrimitiveString) 3803 fc.Result = res 3804 return ec.marshalNPrimitiveString2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPrimitiveStringᚄ(ctx, field.Selections, res) 3805 } 3806 3807 func (ec *executionContext) fieldContext_Query_primitiveStringObject(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3808 fc = &graphql.FieldContext{ 3809 Object: "Query", 3810 Field: field, 3811 IsMethod: true, 3812 IsResolver: true, 3813 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3814 switch field.Name { 3815 case "value": 3816 return ec.fieldContext_PrimitiveString_value(ctx, field) 3817 case "doubled": 3818 return ec.fieldContext_PrimitiveString_doubled(ctx, field) 3819 case "len": 3820 return ec.fieldContext_PrimitiveString_len(ctx, field) 3821 } 3822 return nil, fmt.Errorf("no field named %q was found under type PrimitiveString", field.Name) 3823 }, 3824 } 3825 return fc, nil 3826 } 3827 3828 func (ec *executionContext) _Query_ptrToSliceContainer(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3829 fc, err := ec.fieldContext_Query_ptrToSliceContainer(ctx, field) 3830 if err != nil { 3831 return graphql.Null 3832 } 3833 ctx = graphql.WithFieldContext(ctx, fc) 3834 defer func() { 3835 if r := recover(); r != nil { 3836 ec.Error(ctx, ec.Recover(ctx, r)) 3837 ret = graphql.Null 3838 } 3839 }() 3840 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3841 ctx = rctx // use context from middleware stack in children 3842 return ec.resolvers.Query().PtrToSliceContainer(rctx) 3843 }) 3844 3845 if resTmp == nil { 3846 if !graphql.HasFieldError(ctx, fc) { 3847 ec.Errorf(ctx, "must not be null") 3848 } 3849 return graphql.Null 3850 } 3851 res := resTmp.(*PtrToSliceContainer) 3852 fc.Result = res 3853 return ec.marshalNPtrToSliceContainer2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPtrToSliceContainer(ctx, field.Selections, res) 3854 } 3855 3856 func (ec *executionContext) fieldContext_Query_ptrToSliceContainer(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3857 fc = &graphql.FieldContext{ 3858 Object: "Query", 3859 Field: field, 3860 IsMethod: true, 3861 IsResolver: true, 3862 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3863 switch field.Name { 3864 case "ptrToSlice": 3865 return ec.fieldContext_PtrToSliceContainer_ptrToSlice(ctx, field) 3866 } 3867 return nil, fmt.Errorf("no field named %q was found under type PtrToSliceContainer", field.Name) 3868 }, 3869 } 3870 return fc, nil 3871 } 3872 3873 func (ec *executionContext) _Query_infinity(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3874 fc, err := ec.fieldContext_Query_infinity(ctx, field) 3875 if err != nil { 3876 return graphql.Null 3877 } 3878 ctx = graphql.WithFieldContext(ctx, fc) 3879 defer func() { 3880 if r := recover(); r != nil { 3881 ec.Error(ctx, ec.Recover(ctx, r)) 3882 ret = graphql.Null 3883 } 3884 }() 3885 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3886 ctx = rctx // use context from middleware stack in children 3887 return ec.resolvers.Query().Infinity(rctx) 3888 }) 3889 3890 if resTmp == nil { 3891 if !graphql.HasFieldError(ctx, fc) { 3892 ec.Errorf(ctx, "must not be null") 3893 } 3894 return graphql.Null 3895 } 3896 res := resTmp.(float64) 3897 fc.Result = res 3898 return ec.marshalNFloat2float64(ctx, field.Selections, res) 3899 } 3900 3901 func (ec *executionContext) fieldContext_Query_infinity(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3902 fc = &graphql.FieldContext{ 3903 Object: "Query", 3904 Field: field, 3905 IsMethod: true, 3906 IsResolver: true, 3907 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3908 return nil, errors.New("field of type Float does not have child fields") 3909 }, 3910 } 3911 return fc, nil 3912 } 3913 3914 func (ec *executionContext) _Query_stringFromContextInterface(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3915 fc, err := ec.fieldContext_Query_stringFromContextInterface(ctx, field) 3916 if err != nil { 3917 return graphql.Null 3918 } 3919 ctx = graphql.WithFieldContext(ctx, fc) 3920 defer func() { 3921 if r := recover(); r != nil { 3922 ec.Error(ctx, ec.Recover(ctx, r)) 3923 ret = graphql.Null 3924 } 3925 }() 3926 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3927 ctx = rctx // use context from middleware stack in children 3928 return ec.resolvers.Query().StringFromContextInterface(rctx) 3929 }) 3930 3931 if resTmp == nil { 3932 if !graphql.HasFieldError(ctx, fc) { 3933 ec.Errorf(ctx, "must not be null") 3934 } 3935 return graphql.Null 3936 } 3937 res := resTmp.(*StringFromContextInterface) 3938 fc.Result = res 3939 return ec.marshalNStringFromContextInterface2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐStringFromContextInterface(ctx, field.Selections, res) 3940 } 3941 3942 func (ec *executionContext) fieldContext_Query_stringFromContextInterface(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3943 fc = &graphql.FieldContext{ 3944 Object: "Query", 3945 Field: field, 3946 IsMethod: true, 3947 IsResolver: true, 3948 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3949 return nil, errors.New("field of type StringFromContextInterface does not have child fields") 3950 }, 3951 } 3952 return fc, nil 3953 } 3954 3955 func (ec *executionContext) _Query_stringFromContextFunction(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3956 fc, err := ec.fieldContext_Query_stringFromContextFunction(ctx, field) 3957 if err != nil { 3958 return graphql.Null 3959 } 3960 ctx = graphql.WithFieldContext(ctx, fc) 3961 defer func() { 3962 if r := recover(); r != nil { 3963 ec.Error(ctx, ec.Recover(ctx, r)) 3964 ret = graphql.Null 3965 } 3966 }() 3967 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 3968 ctx = rctx // use context from middleware stack in children 3969 return ec.resolvers.Query().StringFromContextFunction(rctx) 3970 }) 3971 3972 if resTmp == nil { 3973 if !graphql.HasFieldError(ctx, fc) { 3974 ec.Errorf(ctx, "must not be null") 3975 } 3976 return graphql.Null 3977 } 3978 res := resTmp.(string) 3979 fc.Result = res 3980 return ec.marshalNStringFromContextFunction2string(ctx, field.Selections, res) 3981 } 3982 3983 func (ec *executionContext) fieldContext_Query_stringFromContextFunction(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 3984 fc = &graphql.FieldContext{ 3985 Object: "Query", 3986 Field: field, 3987 IsMethod: true, 3988 IsResolver: true, 3989 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 3990 return nil, errors.New("field of type StringFromContextFunction does not have child fields") 3991 }, 3992 } 3993 return fc, nil 3994 } 3995 3996 func (ec *executionContext) _Query_defaultScalar(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 3997 fc, err := ec.fieldContext_Query_defaultScalar(ctx, field) 3998 if err != nil { 3999 return graphql.Null 4000 } 4001 ctx = graphql.WithFieldContext(ctx, fc) 4002 defer func() { 4003 if r := recover(); r != nil { 4004 ec.Error(ctx, ec.Recover(ctx, r)) 4005 ret = graphql.Null 4006 } 4007 }() 4008 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4009 ctx = rctx // use context from middleware stack in children 4010 return ec.resolvers.Query().DefaultScalar(rctx, fc.Args["arg"].(string)) 4011 }) 4012 4013 if resTmp == nil { 4014 if !graphql.HasFieldError(ctx, fc) { 4015 ec.Errorf(ctx, "must not be null") 4016 } 4017 return graphql.Null 4018 } 4019 res := resTmp.(string) 4020 fc.Result = res 4021 return ec.marshalNDefaultScalarImplementation2string(ctx, field.Selections, res) 4022 } 4023 4024 func (ec *executionContext) fieldContext_Query_defaultScalar(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4025 fc = &graphql.FieldContext{ 4026 Object: "Query", 4027 Field: field, 4028 IsMethod: true, 4029 IsResolver: true, 4030 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4031 return nil, errors.New("field of type DefaultScalarImplementation does not have child fields") 4032 }, 4033 } 4034 defer func() { 4035 if r := recover(); r != nil { 4036 err = ec.Recover(ctx, r) 4037 ec.Error(ctx, err) 4038 } 4039 }() 4040 ctx = graphql.WithFieldContext(ctx, fc) 4041 if fc.Args, err = ec.field_Query_defaultScalar_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 4042 ec.Error(ctx, err) 4043 return 4044 } 4045 return fc, nil 4046 } 4047 4048 func (ec *executionContext) _Query_slices(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 4049 fc, err := ec.fieldContext_Query_slices(ctx, field) 4050 if err != nil { 4051 return graphql.Null 4052 } 4053 ctx = graphql.WithFieldContext(ctx, fc) 4054 defer func() { 4055 if r := recover(); r != nil { 4056 ec.Error(ctx, ec.Recover(ctx, r)) 4057 ret = graphql.Null 4058 } 4059 }() 4060 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4061 ctx = rctx // use context from middleware stack in children 4062 return ec.resolvers.Query().Slices(rctx) 4063 }) 4064 4065 if resTmp == nil { 4066 return graphql.Null 4067 } 4068 res := resTmp.(*Slices) 4069 fc.Result = res 4070 return ec.marshalOSlices2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐSlices(ctx, field.Selections, res) 4071 } 4072 4073 func (ec *executionContext) fieldContext_Query_slices(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4074 fc = &graphql.FieldContext{ 4075 Object: "Query", 4076 Field: field, 4077 IsMethod: true, 4078 IsResolver: true, 4079 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4080 switch field.Name { 4081 case "test1": 4082 return ec.fieldContext_Slices_test1(ctx, field) 4083 case "test2": 4084 return ec.fieldContext_Slices_test2(ctx, field) 4085 case "test3": 4086 return ec.fieldContext_Slices_test3(ctx, field) 4087 case "test4": 4088 return ec.fieldContext_Slices_test4(ctx, field) 4089 } 4090 return nil, fmt.Errorf("no field named %q was found under type Slices", field.Name) 4091 }, 4092 } 4093 return fc, nil 4094 } 4095 4096 func (ec *executionContext) _Query_scalarSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 4097 fc, err := ec.fieldContext_Query_scalarSlice(ctx, field) 4098 if err != nil { 4099 return graphql.Null 4100 } 4101 ctx = graphql.WithFieldContext(ctx, fc) 4102 defer func() { 4103 if r := recover(); r != nil { 4104 ec.Error(ctx, ec.Recover(ctx, r)) 4105 ret = graphql.Null 4106 } 4107 }() 4108 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4109 ctx = rctx // use context from middleware stack in children 4110 return ec.resolvers.Query().ScalarSlice(rctx) 4111 }) 4112 4113 if resTmp == nil { 4114 if !graphql.HasFieldError(ctx, fc) { 4115 ec.Errorf(ctx, "must not be null") 4116 } 4117 return graphql.Null 4118 } 4119 res := resTmp.([]byte) 4120 fc.Result = res 4121 return ec.marshalNBytes2ᚕbyte(ctx, field.Selections, res) 4122 } 4123 4124 func (ec *executionContext) fieldContext_Query_scalarSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4125 fc = &graphql.FieldContext{ 4126 Object: "Query", 4127 Field: field, 4128 IsMethod: true, 4129 IsResolver: true, 4130 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4131 return nil, errors.New("field of type Bytes does not have child fields") 4132 }, 4133 } 4134 return fc, nil 4135 } 4136 4137 func (ec *executionContext) _Query_fallback(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 4138 fc, err := ec.fieldContext_Query_fallback(ctx, field) 4139 if err != nil { 4140 return graphql.Null 4141 } 4142 ctx = graphql.WithFieldContext(ctx, fc) 4143 defer func() { 4144 if r := recover(); r != nil { 4145 ec.Error(ctx, ec.Recover(ctx, r)) 4146 ret = graphql.Null 4147 } 4148 }() 4149 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4150 ctx = rctx // use context from middleware stack in children 4151 return ec.resolvers.Query().Fallback(rctx, fc.Args["arg"].(FallbackToStringEncoding)) 4152 }) 4153 4154 if resTmp == nil { 4155 if !graphql.HasFieldError(ctx, fc) { 4156 ec.Errorf(ctx, "must not be null") 4157 } 4158 return graphql.Null 4159 } 4160 res := resTmp.(FallbackToStringEncoding) 4161 fc.Result = res 4162 return ec.marshalNFallbackToStringEncoding2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐFallbackToStringEncoding(ctx, field.Selections, res) 4163 } 4164 4165 func (ec *executionContext) fieldContext_Query_fallback(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4166 fc = &graphql.FieldContext{ 4167 Object: "Query", 4168 Field: field, 4169 IsMethod: true, 4170 IsResolver: true, 4171 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4172 return nil, errors.New("field of type FallbackToStringEncoding does not have child fields") 4173 }, 4174 } 4175 defer func() { 4176 if r := recover(); r != nil { 4177 err = ec.Recover(ctx, r) 4178 ec.Error(ctx, err) 4179 } 4180 }() 4181 ctx = graphql.WithFieldContext(ctx, fc) 4182 if fc.Args, err = ec.field_Query_fallback_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 4183 ec.Error(ctx, err) 4184 return 4185 } 4186 return fc, nil 4187 } 4188 4189 func (ec *executionContext) _Query_optionalUnion(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 4190 fc, err := ec.fieldContext_Query_optionalUnion(ctx, field) 4191 if err != nil { 4192 return graphql.Null 4193 } 4194 ctx = graphql.WithFieldContext(ctx, fc) 4195 defer func() { 4196 if r := recover(); r != nil { 4197 ec.Error(ctx, ec.Recover(ctx, r)) 4198 ret = graphql.Null 4199 } 4200 }() 4201 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4202 ctx = rctx // use context from middleware stack in children 4203 return ec.resolvers.Query().OptionalUnion(rctx) 4204 }) 4205 4206 if resTmp == nil { 4207 return graphql.Null 4208 } 4209 res := resTmp.(TestUnion) 4210 fc.Result = res 4211 return ec.marshalOTestUnion2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐTestUnion(ctx, field.Selections, res) 4212 } 4213 4214 func (ec *executionContext) fieldContext_Query_optionalUnion(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4215 fc = &graphql.FieldContext{ 4216 Object: "Query", 4217 Field: field, 4218 IsMethod: true, 4219 IsResolver: true, 4220 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4221 return nil, errors.New("field of type TestUnion does not have child fields") 4222 }, 4223 } 4224 return fc, nil 4225 } 4226 4227 func (ec *executionContext) _Query_vOkCaseValue(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 4228 fc, err := ec.fieldContext_Query_vOkCaseValue(ctx, field) 4229 if err != nil { 4230 return graphql.Null 4231 } 4232 ctx = graphql.WithFieldContext(ctx, fc) 4233 defer func() { 4234 if r := recover(); r != nil { 4235 ec.Error(ctx, ec.Recover(ctx, r)) 4236 ret = graphql.Null 4237 } 4238 }() 4239 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4240 ctx = rctx // use context from middleware stack in children 4241 return ec.resolvers.Query().VOkCaseValue(rctx) 4242 }) 4243 4244 if resTmp == nil { 4245 return graphql.Null 4246 } 4247 res := resTmp.(*VOkCaseValue) 4248 fc.Result = res 4249 return ec.marshalOVOkCaseValue2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐVOkCaseValue(ctx, field.Selections, res) 4250 } 4251 4252 func (ec *executionContext) fieldContext_Query_vOkCaseValue(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4253 fc = &graphql.FieldContext{ 4254 Object: "Query", 4255 Field: field, 4256 IsMethod: true, 4257 IsResolver: true, 4258 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4259 switch field.Name { 4260 case "value": 4261 return ec.fieldContext_VOkCaseValue_value(ctx, field) 4262 } 4263 return nil, fmt.Errorf("no field named %q was found under type VOkCaseValue", field.Name) 4264 }, 4265 } 4266 return fc, nil 4267 } 4268 4269 func (ec *executionContext) _Query_vOkCaseNil(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 4270 fc, err := ec.fieldContext_Query_vOkCaseNil(ctx, field) 4271 if err != nil { 4272 return graphql.Null 4273 } 4274 ctx = graphql.WithFieldContext(ctx, fc) 4275 defer func() { 4276 if r := recover(); r != nil { 4277 ec.Error(ctx, ec.Recover(ctx, r)) 4278 ret = graphql.Null 4279 } 4280 }() 4281 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4282 ctx = rctx // use context from middleware stack in children 4283 return ec.resolvers.Query().VOkCaseNil(rctx) 4284 }) 4285 4286 if resTmp == nil { 4287 return graphql.Null 4288 } 4289 res := resTmp.(*VOkCaseNil) 4290 fc.Result = res 4291 return ec.marshalOVOkCaseNil2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐVOkCaseNil(ctx, field.Selections, res) 4292 } 4293 4294 func (ec *executionContext) fieldContext_Query_vOkCaseNil(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4295 fc = &graphql.FieldContext{ 4296 Object: "Query", 4297 Field: field, 4298 IsMethod: true, 4299 IsResolver: true, 4300 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4301 switch field.Name { 4302 case "value": 4303 return ec.fieldContext_VOkCaseNil_value(ctx, field) 4304 } 4305 return nil, fmt.Errorf("no field named %q was found under type VOkCaseNil", field.Name) 4306 }, 4307 } 4308 return fc, nil 4309 } 4310 4311 func (ec *executionContext) _Query_validType(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 4312 fc, err := ec.fieldContext_Query_validType(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, nil, func(rctx context.Context) (interface{}, error) { 4324 ctx = rctx // use context from middleware stack in children 4325 return ec.resolvers.Query().ValidType(rctx) 4326 }) 4327 4328 if resTmp == nil { 4329 return graphql.Null 4330 } 4331 res := resTmp.(*ValidType) 4332 fc.Result = res 4333 return ec.marshalOValidType2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐValidType(ctx, field.Selections, res) 4334 } 4335 4336 func (ec *executionContext) fieldContext_Query_validType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4337 fc = &graphql.FieldContext{ 4338 Object: "Query", 4339 Field: field, 4340 IsMethod: true, 4341 IsResolver: true, 4342 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4343 switch field.Name { 4344 case "differentCase": 4345 return ec.fieldContext_ValidType_differentCase(ctx, field) 4346 case "different_case": 4347 return ec.fieldContext_ValidType_different_case(ctx, field) 4348 case "validInputKeywords": 4349 return ec.fieldContext_ValidType_validInputKeywords(ctx, field) 4350 case "validArgs": 4351 return ec.fieldContext_ValidType_validArgs(ctx, field) 4352 } 4353 return nil, fmt.Errorf("no field named %q was found under type ValidType", field.Name) 4354 }, 4355 } 4356 return fc, nil 4357 } 4358 4359 func (ec *executionContext) _Query_variadicModel(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 4360 fc, err := ec.fieldContext_Query_variadicModel(ctx, field) 4361 if err != nil { 4362 return graphql.Null 4363 } 4364 ctx = graphql.WithFieldContext(ctx, fc) 4365 defer func() { 4366 if r := recover(); r != nil { 4367 ec.Error(ctx, ec.Recover(ctx, r)) 4368 ret = graphql.Null 4369 } 4370 }() 4371 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4372 ctx = rctx // use context from middleware stack in children 4373 return ec.resolvers.Query().VariadicModel(rctx) 4374 }) 4375 4376 if resTmp == nil { 4377 return graphql.Null 4378 } 4379 res := resTmp.(*VariadicModel) 4380 fc.Result = res 4381 return ec.marshalOVariadicModel2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐVariadicModel(ctx, field.Selections, res) 4382 } 4383 4384 func (ec *executionContext) fieldContext_Query_variadicModel(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4385 fc = &graphql.FieldContext{ 4386 Object: "Query", 4387 Field: field, 4388 IsMethod: true, 4389 IsResolver: true, 4390 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4391 switch field.Name { 4392 case "value": 4393 return ec.fieldContext_VariadicModel_value(ctx, field) 4394 } 4395 return nil, fmt.Errorf("no field named %q was found under type VariadicModel", field.Name) 4396 }, 4397 } 4398 return fc, nil 4399 } 4400 4401 func (ec *executionContext) _Query_wrappedStruct(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 4402 fc, err := ec.fieldContext_Query_wrappedStruct(ctx, field) 4403 if err != nil { 4404 return graphql.Null 4405 } 4406 ctx = graphql.WithFieldContext(ctx, fc) 4407 defer func() { 4408 if r := recover(); r != nil { 4409 ec.Error(ctx, ec.Recover(ctx, r)) 4410 ret = graphql.Null 4411 } 4412 }() 4413 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4414 ctx = rctx // use context from middleware stack in children 4415 return ec.resolvers.Query().WrappedStruct(rctx) 4416 }) 4417 4418 if resTmp == nil { 4419 if !graphql.HasFieldError(ctx, fc) { 4420 ec.Errorf(ctx, "must not be null") 4421 } 4422 return graphql.Null 4423 } 4424 res := resTmp.(*WrappedStruct) 4425 fc.Result = res 4426 return ec.marshalNWrappedStruct2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐWrappedStruct(ctx, field.Selections, res) 4427 } 4428 4429 func (ec *executionContext) fieldContext_Query_wrappedStruct(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4430 fc = &graphql.FieldContext{ 4431 Object: "Query", 4432 Field: field, 4433 IsMethod: true, 4434 IsResolver: true, 4435 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4436 switch field.Name { 4437 case "name": 4438 return ec.fieldContext_WrappedStruct_name(ctx, field) 4439 case "desc": 4440 return ec.fieldContext_WrappedStruct_desc(ctx, field) 4441 } 4442 return nil, fmt.Errorf("no field named %q was found under type WrappedStruct", field.Name) 4443 }, 4444 } 4445 return fc, nil 4446 } 4447 4448 func (ec *executionContext) _Query_wrappedScalar(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 4449 fc, err := ec.fieldContext_Query_wrappedScalar(ctx, field) 4450 if err != nil { 4451 return graphql.Null 4452 } 4453 ctx = graphql.WithFieldContext(ctx, fc) 4454 defer func() { 4455 if r := recover(); r != nil { 4456 ec.Error(ctx, ec.Recover(ctx, r)) 4457 ret = graphql.Null 4458 } 4459 }() 4460 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4461 ctx = rctx // use context from middleware stack in children 4462 return ec.resolvers.Query().WrappedScalar(rctx) 4463 }) 4464 4465 if resTmp == nil { 4466 if !graphql.HasFieldError(ctx, fc) { 4467 ec.Errorf(ctx, "must not be null") 4468 } 4469 return graphql.Null 4470 } 4471 res := resTmp.(otherpkg.Scalar) 4472 fc.Result = res 4473 return ec.marshalNWrappedScalar2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋotherpkgᚐScalar(ctx, field.Selections, res) 4474 } 4475 4476 func (ec *executionContext) fieldContext_Query_wrappedScalar(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4477 fc = &graphql.FieldContext{ 4478 Object: "Query", 4479 Field: field, 4480 IsMethod: true, 4481 IsResolver: true, 4482 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4483 return nil, errors.New("field of type WrappedScalar does not have child fields") 4484 }, 4485 } 4486 return fc, nil 4487 } 4488 4489 func (ec *executionContext) _Query_wrappedMap(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 4490 fc, err := ec.fieldContext_Query_wrappedMap(ctx, field) 4491 if err != nil { 4492 return graphql.Null 4493 } 4494 ctx = graphql.WithFieldContext(ctx, fc) 4495 defer func() { 4496 if r := recover(); r != nil { 4497 ec.Error(ctx, ec.Recover(ctx, r)) 4498 ret = graphql.Null 4499 } 4500 }() 4501 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4502 ctx = rctx // use context from middleware stack in children 4503 return ec.resolvers.Query().WrappedMap(rctx) 4504 }) 4505 4506 if resTmp == nil { 4507 if !graphql.HasFieldError(ctx, fc) { 4508 ec.Errorf(ctx, "must not be null") 4509 } 4510 return graphql.Null 4511 } 4512 res := resTmp.(WrappedMap) 4513 fc.Result = res 4514 return ec.marshalNWrappedMap2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐWrappedMap(ctx, field.Selections, res) 4515 } 4516 4517 func (ec *executionContext) fieldContext_Query_wrappedMap(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4518 fc = &graphql.FieldContext{ 4519 Object: "Query", 4520 Field: field, 4521 IsMethod: true, 4522 IsResolver: true, 4523 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4524 switch field.Name { 4525 case "get": 4526 return ec.fieldContext_WrappedMap_get(ctx, field) 4527 } 4528 return nil, fmt.Errorf("no field named %q was found under type WrappedMap", field.Name) 4529 }, 4530 } 4531 return fc, nil 4532 } 4533 4534 func (ec *executionContext) _Query_wrappedSlice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 4535 fc, err := ec.fieldContext_Query_wrappedSlice(ctx, field) 4536 if err != nil { 4537 return graphql.Null 4538 } 4539 ctx = graphql.WithFieldContext(ctx, fc) 4540 defer func() { 4541 if r := recover(); r != nil { 4542 ec.Error(ctx, ec.Recover(ctx, r)) 4543 ret = graphql.Null 4544 } 4545 }() 4546 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4547 ctx = rctx // use context from middleware stack in children 4548 return ec.resolvers.Query().WrappedSlice(rctx) 4549 }) 4550 4551 if resTmp == nil { 4552 if !graphql.HasFieldError(ctx, fc) { 4553 ec.Errorf(ctx, "must not be null") 4554 } 4555 return graphql.Null 4556 } 4557 res := resTmp.(WrappedSlice) 4558 fc.Result = res 4559 return ec.marshalNWrappedSlice2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐWrappedSlice(ctx, field.Selections, res) 4560 } 4561 4562 func (ec *executionContext) fieldContext_Query_wrappedSlice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4563 fc = &graphql.FieldContext{ 4564 Object: "Query", 4565 Field: field, 4566 IsMethod: true, 4567 IsResolver: true, 4568 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4569 switch field.Name { 4570 case "get": 4571 return ec.fieldContext_WrappedSlice_get(ctx, field) 4572 } 4573 return nil, fmt.Errorf("no field named %q was found under type WrappedSlice", field.Name) 4574 }, 4575 } 4576 return fc, nil 4577 } 4578 4579 func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 4580 fc, err := ec.fieldContext_Query___type(ctx, field) 4581 if err != nil { 4582 return graphql.Null 4583 } 4584 ctx = graphql.WithFieldContext(ctx, fc) 4585 defer func() { 4586 if r := recover(); r != nil { 4587 ec.Error(ctx, ec.Recover(ctx, r)) 4588 ret = graphql.Null 4589 } 4590 }() 4591 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4592 ctx = rctx // use context from middleware stack in children 4593 return ec.introspectType(fc.Args["name"].(string)) 4594 }) 4595 4596 if resTmp == nil { 4597 return graphql.Null 4598 } 4599 res := resTmp.(*introspection.Type) 4600 fc.Result = res 4601 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res) 4602 } 4603 4604 func (ec *executionContext) fieldContext_Query___type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4605 fc = &graphql.FieldContext{ 4606 Object: "Query", 4607 Field: field, 4608 IsMethod: true, 4609 IsResolver: false, 4610 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4611 switch field.Name { 4612 case "kind": 4613 return ec.fieldContext___Type_kind(ctx, field) 4614 case "name": 4615 return ec.fieldContext___Type_name(ctx, field) 4616 case "description": 4617 return ec.fieldContext___Type_description(ctx, field) 4618 case "fields": 4619 return ec.fieldContext___Type_fields(ctx, field) 4620 case "interfaces": 4621 return ec.fieldContext___Type_interfaces(ctx, field) 4622 case "possibleTypes": 4623 return ec.fieldContext___Type_possibleTypes(ctx, field) 4624 case "enumValues": 4625 return ec.fieldContext___Type_enumValues(ctx, field) 4626 case "inputFields": 4627 return ec.fieldContext___Type_inputFields(ctx, field) 4628 case "ofType": 4629 return ec.fieldContext___Type_ofType(ctx, field) 4630 case "specifiedByURL": 4631 return ec.fieldContext___Type_specifiedByURL(ctx, field) 4632 } 4633 return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) 4634 }, 4635 } 4636 defer func() { 4637 if r := recover(); r != nil { 4638 err = ec.Recover(ctx, r) 4639 ec.Error(ctx, err) 4640 } 4641 }() 4642 ctx = graphql.WithFieldContext(ctx, fc) 4643 if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 4644 ec.Error(ctx, err) 4645 return 4646 } 4647 return fc, nil 4648 } 4649 4650 func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 4651 fc, err := ec.fieldContext_Query___schema(ctx, field) 4652 if err != nil { 4653 return graphql.Null 4654 } 4655 ctx = graphql.WithFieldContext(ctx, fc) 4656 defer func() { 4657 if r := recover(); r != nil { 4658 ec.Error(ctx, ec.Recover(ctx, r)) 4659 ret = graphql.Null 4660 } 4661 }() 4662 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4663 ctx = rctx // use context from middleware stack in children 4664 return ec.introspectSchema() 4665 }) 4666 4667 if resTmp == nil { 4668 return graphql.Null 4669 } 4670 res := resTmp.(*introspection.Schema) 4671 fc.Result = res 4672 return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res) 4673 } 4674 4675 func (ec *executionContext) fieldContext_Query___schema(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4676 fc = &graphql.FieldContext{ 4677 Object: "Query", 4678 Field: field, 4679 IsMethod: true, 4680 IsResolver: false, 4681 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4682 switch field.Name { 4683 case "description": 4684 return ec.fieldContext___Schema_description(ctx, field) 4685 case "types": 4686 return ec.fieldContext___Schema_types(ctx, field) 4687 case "queryType": 4688 return ec.fieldContext___Schema_queryType(ctx, field) 4689 case "mutationType": 4690 return ec.fieldContext___Schema_mutationType(ctx, field) 4691 case "subscriptionType": 4692 return ec.fieldContext___Schema_subscriptionType(ctx, field) 4693 case "directives": 4694 return ec.fieldContext___Schema_directives(ctx, field) 4695 } 4696 return nil, fmt.Errorf("no field named %q was found under type __Schema", field.Name) 4697 }, 4698 } 4699 return fc, nil 4700 } 4701 4702 func (ec *executionContext) _Subscription_updated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) { 4703 fc, err := ec.fieldContext_Subscription_updated(ctx, field) 4704 if err != nil { 4705 return nil 4706 } 4707 ctx = graphql.WithFieldContext(ctx, fc) 4708 defer func() { 4709 if r := recover(); r != nil { 4710 ec.Error(ctx, ec.Recover(ctx, r)) 4711 ret = nil 4712 } 4713 }() 4714 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4715 ctx = rctx // use context from middleware stack in children 4716 return ec.resolvers.Subscription().Updated(rctx) 4717 }) 4718 4719 if resTmp == nil { 4720 if !graphql.HasFieldError(ctx, fc) { 4721 ec.Errorf(ctx, "must not be null") 4722 } 4723 return nil 4724 } 4725 return func(ctx context.Context) graphql.Marshaler { 4726 select { 4727 case res, ok := <-resTmp.(<-chan string): 4728 if !ok { 4729 return nil 4730 } 4731 return graphql.WriterFunc(func(w io.Writer) { 4732 w.Write([]byte{'{'}) 4733 graphql.MarshalString(field.Alias).MarshalGQL(w) 4734 w.Write([]byte{':'}) 4735 ec.marshalNString2string(ctx, field.Selections, res).MarshalGQL(w) 4736 w.Write([]byte{'}'}) 4737 }) 4738 case <-ctx.Done(): 4739 return nil 4740 } 4741 } 4742 } 4743 4744 func (ec *executionContext) fieldContext_Subscription_updated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4745 fc = &graphql.FieldContext{ 4746 Object: "Subscription", 4747 Field: field, 4748 IsMethod: true, 4749 IsResolver: true, 4750 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4751 return nil, errors.New("field of type String does not have child fields") 4752 }, 4753 } 4754 return fc, nil 4755 } 4756 4757 func (ec *executionContext) _Subscription_initPayload(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) { 4758 fc, err := ec.fieldContext_Subscription_initPayload(ctx, field) 4759 if err != nil { 4760 return nil 4761 } 4762 ctx = graphql.WithFieldContext(ctx, fc) 4763 defer func() { 4764 if r := recover(); r != nil { 4765 ec.Error(ctx, ec.Recover(ctx, r)) 4766 ret = nil 4767 } 4768 }() 4769 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4770 ctx = rctx // use context from middleware stack in children 4771 return ec.resolvers.Subscription().InitPayload(rctx) 4772 }) 4773 4774 if resTmp == nil { 4775 if !graphql.HasFieldError(ctx, fc) { 4776 ec.Errorf(ctx, "must not be null") 4777 } 4778 return nil 4779 } 4780 return func(ctx context.Context) graphql.Marshaler { 4781 select { 4782 case res, ok := <-resTmp.(<-chan string): 4783 if !ok { 4784 return nil 4785 } 4786 return graphql.WriterFunc(func(w io.Writer) { 4787 w.Write([]byte{'{'}) 4788 graphql.MarshalString(field.Alias).MarshalGQL(w) 4789 w.Write([]byte{':'}) 4790 ec.marshalNString2string(ctx, field.Selections, res).MarshalGQL(w) 4791 w.Write([]byte{'}'}) 4792 }) 4793 case <-ctx.Done(): 4794 return nil 4795 } 4796 } 4797 } 4798 4799 func (ec *executionContext) fieldContext_Subscription_initPayload(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4800 fc = &graphql.FieldContext{ 4801 Object: "Subscription", 4802 Field: field, 4803 IsMethod: true, 4804 IsResolver: true, 4805 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4806 return nil, errors.New("field of type String does not have child fields") 4807 }, 4808 } 4809 return fc, nil 4810 } 4811 4812 func (ec *executionContext) _Subscription_directiveArg(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) { 4813 fc, err := ec.fieldContext_Subscription_directiveArg(ctx, field) 4814 if err != nil { 4815 return nil 4816 } 4817 ctx = graphql.WithFieldContext(ctx, fc) 4818 defer func() { 4819 if r := recover(); r != nil { 4820 ec.Error(ctx, ec.Recover(ctx, r)) 4821 ret = nil 4822 } 4823 }() 4824 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4825 ctx = rctx // use context from middleware stack in children 4826 return ec.resolvers.Subscription().DirectiveArg(rctx, fc.Args["arg"].(string)) 4827 }) 4828 4829 if resTmp == nil { 4830 return nil 4831 } 4832 return func(ctx context.Context) graphql.Marshaler { 4833 select { 4834 case res, ok := <-resTmp.(<-chan *string): 4835 if !ok { 4836 return nil 4837 } 4838 return graphql.WriterFunc(func(w io.Writer) { 4839 w.Write([]byte{'{'}) 4840 graphql.MarshalString(field.Alias).MarshalGQL(w) 4841 w.Write([]byte{':'}) 4842 ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w) 4843 w.Write([]byte{'}'}) 4844 }) 4845 case <-ctx.Done(): 4846 return nil 4847 } 4848 } 4849 } 4850 4851 func (ec *executionContext) fieldContext_Subscription_directiveArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4852 fc = &graphql.FieldContext{ 4853 Object: "Subscription", 4854 Field: field, 4855 IsMethod: true, 4856 IsResolver: true, 4857 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4858 return nil, errors.New("field of type String does not have child fields") 4859 }, 4860 } 4861 defer func() { 4862 if r := recover(); r != nil { 4863 err = ec.Recover(ctx, r) 4864 ec.Error(ctx, err) 4865 } 4866 }() 4867 ctx = graphql.WithFieldContext(ctx, fc) 4868 if fc.Args, err = ec.field_Subscription_directiveArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 4869 ec.Error(ctx, err) 4870 return 4871 } 4872 return fc, nil 4873 } 4874 4875 func (ec *executionContext) _Subscription_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) { 4876 fc, err := ec.fieldContext_Subscription_directiveNullableArg(ctx, field) 4877 if err != nil { 4878 return nil 4879 } 4880 ctx = graphql.WithFieldContext(ctx, fc) 4881 defer func() { 4882 if r := recover(); r != nil { 4883 ec.Error(ctx, ec.Recover(ctx, r)) 4884 ret = nil 4885 } 4886 }() 4887 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4888 ctx = rctx // use context from middleware stack in children 4889 return ec.resolvers.Subscription().DirectiveNullableArg(rctx, fc.Args["arg"].(*int), fc.Args["arg2"].(*int), fc.Args["arg3"].(*string)) 4890 }) 4891 4892 if resTmp == nil { 4893 return nil 4894 } 4895 return func(ctx context.Context) graphql.Marshaler { 4896 select { 4897 case res, ok := <-resTmp.(<-chan *string): 4898 if !ok { 4899 return nil 4900 } 4901 return graphql.WriterFunc(func(w io.Writer) { 4902 w.Write([]byte{'{'}) 4903 graphql.MarshalString(field.Alias).MarshalGQL(w) 4904 w.Write([]byte{':'}) 4905 ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w) 4906 w.Write([]byte{'}'}) 4907 }) 4908 case <-ctx.Done(): 4909 return nil 4910 } 4911 } 4912 } 4913 4914 func (ec *executionContext) fieldContext_Subscription_directiveNullableArg(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 4915 fc = &graphql.FieldContext{ 4916 Object: "Subscription", 4917 Field: field, 4918 IsMethod: true, 4919 IsResolver: true, 4920 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 4921 return nil, errors.New("field of type String does not have child fields") 4922 }, 4923 } 4924 defer func() { 4925 if r := recover(); r != nil { 4926 err = ec.Recover(ctx, r) 4927 ec.Error(ctx, err) 4928 } 4929 }() 4930 ctx = graphql.WithFieldContext(ctx, fc) 4931 if fc.Args, err = ec.field_Subscription_directiveNullableArg_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 4932 ec.Error(ctx, err) 4933 return 4934 } 4935 return fc, nil 4936 } 4937 4938 func (ec *executionContext) _Subscription_directiveDouble(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) { 4939 fc, err := ec.fieldContext_Subscription_directiveDouble(ctx, field) 4940 if err != nil { 4941 return nil 4942 } 4943 ctx = graphql.WithFieldContext(ctx, fc) 4944 defer func() { 4945 if r := recover(); r != nil { 4946 ec.Error(ctx, ec.Recover(ctx, r)) 4947 ret = nil 4948 } 4949 }() 4950 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 4951 directive0 := func(rctx context.Context) (interface{}, error) { 4952 ctx = rctx // use context from middleware stack in children 4953 return ec.resolvers.Subscription().DirectiveDouble(rctx) 4954 } 4955 directive1 := func(ctx context.Context) (interface{}, error) { 4956 if ec.directives.Directive1 == nil { 4957 return nil, errors.New("directive directive1 is not implemented") 4958 } 4959 return ec.directives.Directive1(ctx, nil, directive0) 4960 } 4961 directive2 := func(ctx context.Context) (interface{}, error) { 4962 if ec.directives.Directive2 == nil { 4963 return nil, errors.New("directive directive2 is not implemented") 4964 } 4965 return ec.directives.Directive2(ctx, nil, directive1) 4966 } 4967 4968 tmp, err := directive2(rctx) 4969 if err != nil { 4970 return nil, graphql.ErrorOnPath(ctx, err) 4971 } 4972 if tmp == nil { 4973 return nil, nil 4974 } 4975 if data, ok := tmp.(<-chan *string); ok { 4976 return data, nil 4977 } 4978 return nil, fmt.Errorf(`unexpected type %T from directive, should be <-chan *string`, tmp) 4979 }) 4980 4981 if resTmp == nil { 4982 return nil 4983 } 4984 return func(ctx context.Context) graphql.Marshaler { 4985 select { 4986 case res, ok := <-resTmp.(<-chan *string): 4987 if !ok { 4988 return nil 4989 } 4990 return graphql.WriterFunc(func(w io.Writer) { 4991 w.Write([]byte{'{'}) 4992 graphql.MarshalString(field.Alias).MarshalGQL(w) 4993 w.Write([]byte{':'}) 4994 ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w) 4995 w.Write([]byte{'}'}) 4996 }) 4997 case <-ctx.Done(): 4998 return nil 4999 } 5000 } 5001 } 5002 5003 func (ec *executionContext) fieldContext_Subscription_directiveDouble(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 5004 fc = &graphql.FieldContext{ 5005 Object: "Subscription", 5006 Field: field, 5007 IsMethod: true, 5008 IsResolver: true, 5009 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 5010 return nil, errors.New("field of type String does not have child fields") 5011 }, 5012 } 5013 return fc, nil 5014 } 5015 5016 func (ec *executionContext) _Subscription_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) { 5017 fc, err := ec.fieldContext_Subscription_directiveUnimplemented(ctx, field) 5018 if err != nil { 5019 return nil 5020 } 5021 ctx = graphql.WithFieldContext(ctx, fc) 5022 defer func() { 5023 if r := recover(); r != nil { 5024 ec.Error(ctx, ec.Recover(ctx, r)) 5025 ret = nil 5026 } 5027 }() 5028 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 5029 directive0 := func(rctx context.Context) (interface{}, error) { 5030 ctx = rctx // use context from middleware stack in children 5031 return ec.resolvers.Subscription().DirectiveUnimplemented(rctx) 5032 } 5033 directive1 := func(ctx context.Context) (interface{}, error) { 5034 if ec.directives.Unimplemented == nil { 5035 return nil, errors.New("directive unimplemented is not implemented") 5036 } 5037 return ec.directives.Unimplemented(ctx, nil, directive0) 5038 } 5039 5040 tmp, err := directive1(rctx) 5041 if err != nil { 5042 return nil, graphql.ErrorOnPath(ctx, err) 5043 } 5044 if tmp == nil { 5045 return nil, nil 5046 } 5047 if data, ok := tmp.(<-chan *string); ok { 5048 return data, nil 5049 } 5050 return nil, fmt.Errorf(`unexpected type %T from directive, should be <-chan *string`, tmp) 5051 }) 5052 5053 if resTmp == nil { 5054 return nil 5055 } 5056 return func(ctx context.Context) graphql.Marshaler { 5057 select { 5058 case res, ok := <-resTmp.(<-chan *string): 5059 if !ok { 5060 return nil 5061 } 5062 return graphql.WriterFunc(func(w io.Writer) { 5063 w.Write([]byte{'{'}) 5064 graphql.MarshalString(field.Alias).MarshalGQL(w) 5065 w.Write([]byte{':'}) 5066 ec.marshalOString2ᚖstring(ctx, field.Selections, res).MarshalGQL(w) 5067 w.Write([]byte{'}'}) 5068 }) 5069 case <-ctx.Done(): 5070 return nil 5071 } 5072 } 5073 } 5074 5075 func (ec *executionContext) fieldContext_Subscription_directiveUnimplemented(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 5076 fc = &graphql.FieldContext{ 5077 Object: "Subscription", 5078 Field: field, 5079 IsMethod: true, 5080 IsResolver: true, 5081 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 5082 return nil, errors.New("field of type String does not have child fields") 5083 }, 5084 } 5085 return fc, nil 5086 } 5087 5088 func (ec *executionContext) _Subscription_issue896b(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) { 5089 fc, err := ec.fieldContext_Subscription_issue896b(ctx, field) 5090 if err != nil { 5091 return nil 5092 } 5093 ctx = graphql.WithFieldContext(ctx, fc) 5094 defer func() { 5095 if r := recover(); r != nil { 5096 ec.Error(ctx, ec.Recover(ctx, r)) 5097 ret = nil 5098 } 5099 }() 5100 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 5101 ctx = rctx // use context from middleware stack in children 5102 return ec.resolvers.Subscription().Issue896b(rctx) 5103 }) 5104 5105 if resTmp == nil { 5106 return nil 5107 } 5108 return func(ctx context.Context) graphql.Marshaler { 5109 select { 5110 case res, ok := <-resTmp.(<-chan []*CheckIssue896): 5111 if !ok { 5112 return nil 5113 } 5114 return graphql.WriterFunc(func(w io.Writer) { 5115 w.Write([]byte{'{'}) 5116 graphql.MarshalString(field.Alias).MarshalGQL(w) 5117 w.Write([]byte{':'}) 5118 ec.marshalOCheckIssue8962ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐCheckIssue896(ctx, field.Selections, res).MarshalGQL(w) 5119 w.Write([]byte{'}'}) 5120 }) 5121 case <-ctx.Done(): 5122 return nil 5123 } 5124 } 5125 } 5126 5127 func (ec *executionContext) fieldContext_Subscription_issue896b(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 5128 fc = &graphql.FieldContext{ 5129 Object: "Subscription", 5130 Field: field, 5131 IsMethod: true, 5132 IsResolver: true, 5133 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 5134 switch field.Name { 5135 case "id": 5136 return ec.fieldContext_CheckIssue896_id(ctx, field) 5137 } 5138 return nil, fmt.Errorf("no field named %q was found under type CheckIssue896", field.Name) 5139 }, 5140 } 5141 return fc, nil 5142 } 5143 5144 func (ec *executionContext) _Subscription_errorRequired(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) { 5145 fc, err := ec.fieldContext_Subscription_errorRequired(ctx, field) 5146 if err != nil { 5147 return nil 5148 } 5149 ctx = graphql.WithFieldContext(ctx, fc) 5150 defer func() { 5151 if r := recover(); r != nil { 5152 ec.Error(ctx, ec.Recover(ctx, r)) 5153 ret = nil 5154 } 5155 }() 5156 resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { 5157 ctx = rctx // use context from middleware stack in children 5158 return ec.resolvers.Subscription().ErrorRequired(rctx) 5159 }) 5160 5161 if resTmp == nil { 5162 if !graphql.HasFieldError(ctx, fc) { 5163 ec.Errorf(ctx, "must not be null") 5164 } 5165 return nil 5166 } 5167 return func(ctx context.Context) graphql.Marshaler { 5168 select { 5169 case res, ok := <-resTmp.(<-chan *Error): 5170 if !ok { 5171 return nil 5172 } 5173 return graphql.WriterFunc(func(w io.Writer) { 5174 w.Write([]byte{'{'}) 5175 graphql.MarshalString(field.Alias).MarshalGQL(w) 5176 w.Write([]byte{':'}) 5177 ec.marshalNError2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐError(ctx, field.Selections, res).MarshalGQL(w) 5178 w.Write([]byte{'}'}) 5179 }) 5180 case <-ctx.Done(): 5181 return nil 5182 } 5183 } 5184 } 5185 5186 func (ec *executionContext) fieldContext_Subscription_errorRequired(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 5187 fc = &graphql.FieldContext{ 5188 Object: "Subscription", 5189 Field: field, 5190 IsMethod: true, 5191 IsResolver: true, 5192 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 5193 switch field.Name { 5194 case "id": 5195 return ec.fieldContext_Error_id(ctx, field) 5196 case "errorOnNonRequiredField": 5197 return ec.fieldContext_Error_errorOnNonRequiredField(ctx, field) 5198 case "errorOnRequiredField": 5199 return ec.fieldContext_Error_errorOnRequiredField(ctx, field) 5200 case "nilOnRequiredField": 5201 return ec.fieldContext_Error_nilOnRequiredField(ctx, field) 5202 } 5203 return nil, fmt.Errorf("no field named %q was found under type Error", field.Name) 5204 }, 5205 } 5206 return fc, nil 5207 } 5208 5209 func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) { 5210 fc, err := ec.fieldContext_User_id(ctx, field) 5211 if err != nil { 5212 return graphql.Null 5213 } 5214 ctx = graphql.WithFieldContext(ctx, fc) 5215 defer func() { 5216 if r := recover(); r != nil { 5217 ec.Error(ctx, ec.Recover(ctx, r)) 5218 ret = graphql.Null 5219 } 5220 }() 5221 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 5222 ctx = rctx // use context from middleware stack in children 5223 return obj.ID, nil 5224 }) 5225 5226 if resTmp == nil { 5227 if !graphql.HasFieldError(ctx, fc) { 5228 ec.Errorf(ctx, "must not be null") 5229 } 5230 return graphql.Null 5231 } 5232 res := resTmp.(int) 5233 fc.Result = res 5234 return ec.marshalNInt2int(ctx, field.Selections, res) 5235 } 5236 5237 func (ec *executionContext) fieldContext_User_id(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 5238 fc = &graphql.FieldContext{ 5239 Object: "User", 5240 Field: field, 5241 IsMethod: false, 5242 IsResolver: false, 5243 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 5244 return nil, errors.New("field of type Int does not have child fields") 5245 }, 5246 } 5247 return fc, nil 5248 } 5249 5250 func (ec *executionContext) _User_friends(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) { 5251 fc, err := ec.fieldContext_User_friends(ctx, field) 5252 if err != nil { 5253 return graphql.Null 5254 } 5255 ctx = graphql.WithFieldContext(ctx, fc) 5256 defer func() { 5257 if r := recover(); r != nil { 5258 ec.Error(ctx, ec.Recover(ctx, r)) 5259 ret = graphql.Null 5260 } 5261 }() 5262 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 5263 ctx = rctx // use context from middleware stack in children 5264 return ec.resolvers.User().Friends(rctx, obj) 5265 }) 5266 5267 if resTmp == nil { 5268 if !graphql.HasFieldError(ctx, fc) { 5269 ec.Errorf(ctx, "must not be null") 5270 } 5271 return graphql.Null 5272 } 5273 res := resTmp.([]*User) 5274 fc.Result = res 5275 return ec.marshalNUser2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUserᚄ(ctx, field.Selections, res) 5276 } 5277 5278 func (ec *executionContext) fieldContext_User_friends(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 5279 fc = &graphql.FieldContext{ 5280 Object: "User", 5281 Field: field, 5282 IsMethod: true, 5283 IsResolver: true, 5284 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 5285 switch field.Name { 5286 case "id": 5287 return ec.fieldContext_User_id(ctx, field) 5288 case "friends": 5289 return ec.fieldContext_User_friends(ctx, field) 5290 case "created": 5291 return ec.fieldContext_User_created(ctx, field) 5292 case "updated": 5293 return ec.fieldContext_User_updated(ctx, field) 5294 case "pets": 5295 return ec.fieldContext_User_pets(ctx, field) 5296 } 5297 return nil, fmt.Errorf("no field named %q was found under type User", field.Name) 5298 }, 5299 } 5300 return fc, nil 5301 } 5302 5303 func (ec *executionContext) _User_created(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) { 5304 fc, err := ec.fieldContext_User_created(ctx, field) 5305 if err != nil { 5306 return graphql.Null 5307 } 5308 ctx = graphql.WithFieldContext(ctx, fc) 5309 defer func() { 5310 if r := recover(); r != nil { 5311 ec.Error(ctx, ec.Recover(ctx, r)) 5312 ret = graphql.Null 5313 } 5314 }() 5315 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 5316 ctx = rctx // use context from middleware stack in children 5317 return obj.Created, nil 5318 }) 5319 5320 if resTmp == nil { 5321 if !graphql.HasFieldError(ctx, fc) { 5322 ec.Errorf(ctx, "must not be null") 5323 } 5324 return graphql.Null 5325 } 5326 res := resTmp.(time.Time) 5327 fc.Result = res 5328 return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res) 5329 } 5330 5331 func (ec *executionContext) fieldContext_User_created(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 5332 fc = &graphql.FieldContext{ 5333 Object: "User", 5334 Field: field, 5335 IsMethod: false, 5336 IsResolver: false, 5337 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 5338 return nil, errors.New("field of type Time does not have child fields") 5339 }, 5340 } 5341 return fc, nil 5342 } 5343 5344 func (ec *executionContext) _User_updated(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) { 5345 fc, err := ec.fieldContext_User_updated(ctx, field) 5346 if err != nil { 5347 return graphql.Null 5348 } 5349 ctx = graphql.WithFieldContext(ctx, fc) 5350 defer func() { 5351 if r := recover(); r != nil { 5352 ec.Error(ctx, ec.Recover(ctx, r)) 5353 ret = graphql.Null 5354 } 5355 }() 5356 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 5357 ctx = rctx // use context from middleware stack in children 5358 return obj.Updated, nil 5359 }) 5360 5361 if resTmp == nil { 5362 return graphql.Null 5363 } 5364 res := resTmp.(*time.Time) 5365 fc.Result = res 5366 return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res) 5367 } 5368 5369 func (ec *executionContext) fieldContext_User_updated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 5370 fc = &graphql.FieldContext{ 5371 Object: "User", 5372 Field: field, 5373 IsMethod: false, 5374 IsResolver: false, 5375 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 5376 return nil, errors.New("field of type Time does not have child fields") 5377 }, 5378 } 5379 return fc, nil 5380 } 5381 5382 func (ec *executionContext) _User_pets(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) { 5383 fc, err := ec.fieldContext_User_pets(ctx, field) 5384 if err != nil { 5385 return graphql.Null 5386 } 5387 ctx = graphql.WithFieldContext(ctx, fc) 5388 defer func() { 5389 if r := recover(); r != nil { 5390 ec.Error(ctx, ec.Recover(ctx, r)) 5391 ret = graphql.Null 5392 } 5393 }() 5394 resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { 5395 ctx = rctx // use context from middleware stack in children 5396 return ec.resolvers.User().Pets(rctx, obj, fc.Args["limit"].(*int)) 5397 }) 5398 5399 if resTmp == nil { 5400 return graphql.Null 5401 } 5402 res := resTmp.([]*Pet) 5403 fc.Result = res 5404 return ec.marshalOPet2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPetᚄ(ctx, field.Selections, res) 5405 } 5406 5407 func (ec *executionContext) fieldContext_User_pets(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { 5408 fc = &graphql.FieldContext{ 5409 Object: "User", 5410 Field: field, 5411 IsMethod: true, 5412 IsResolver: true, 5413 Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { 5414 switch field.Name { 5415 case "id": 5416 return ec.fieldContext_Pet_id(ctx, field) 5417 case "friends": 5418 return ec.fieldContext_Pet_friends(ctx, field) 5419 } 5420 return nil, fmt.Errorf("no field named %q was found under type Pet", field.Name) 5421 }, 5422 } 5423 defer func() { 5424 if r := recover(); r != nil { 5425 err = ec.Recover(ctx, r) 5426 ec.Error(ctx, err) 5427 } 5428 }() 5429 ctx = graphql.WithFieldContext(ctx, fc) 5430 if fc.Args, err = ec.field_User_pets_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { 5431 ec.Error(ctx, err) 5432 return 5433 } 5434 return fc, nil 5435 } 5436 5437 // endregion **************************** field.gotpl ***************************** 5438 5439 // region **************************** input.gotpl ***************************** 5440 5441 func (ec *executionContext) unmarshalInputInnerInput(ctx context.Context, obj interface{}) (InnerInput, error) { 5442 var it InnerInput 5443 asMap := map[string]interface{}{} 5444 for k, v := range obj.(map[string]interface{}) { 5445 asMap[k] = v 5446 } 5447 5448 fieldsInOrder := [...]string{"id"} 5449 for _, k := range fieldsInOrder { 5450 v, ok := asMap[k] 5451 if !ok { 5452 continue 5453 } 5454 switch k { 5455 case "id": 5456 var err error 5457 5458 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) 5459 it.ID, err = ec.unmarshalNInt2int(ctx, v) 5460 if err != nil { 5461 return it, err 5462 } 5463 } 5464 } 5465 5466 return it, nil 5467 } 5468 5469 func (ec *executionContext) unmarshalInputOuterInput(ctx context.Context, obj interface{}) (OuterInput, error) { 5470 var it OuterInput 5471 asMap := map[string]interface{}{} 5472 for k, v := range obj.(map[string]interface{}) { 5473 asMap[k] = v 5474 } 5475 5476 fieldsInOrder := [...]string{"inner"} 5477 for _, k := range fieldsInOrder { 5478 v, ok := asMap[k] 5479 if !ok { 5480 continue 5481 } 5482 switch k { 5483 case "inner": 5484 var err error 5485 5486 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("inner")) 5487 it.Inner, err = ec.unmarshalNInnerInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerInput(ctx, v) 5488 if err != nil { 5489 return it, err 5490 } 5491 } 5492 } 5493 5494 return it, nil 5495 } 5496 5497 func (ec *executionContext) unmarshalInputRecursiveInputSlice(ctx context.Context, obj interface{}) (RecursiveInputSlice, error) { 5498 var it RecursiveInputSlice 5499 asMap := map[string]interface{}{} 5500 for k, v := range obj.(map[string]interface{}) { 5501 asMap[k] = v 5502 } 5503 5504 fieldsInOrder := [...]string{"self"} 5505 for _, k := range fieldsInOrder { 5506 v, ok := asMap[k] 5507 if !ok { 5508 continue 5509 } 5510 switch k { 5511 case "self": 5512 var err error 5513 5514 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("self")) 5515 it.Self, err = ec.unmarshalORecursiveInputSlice2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSliceᚄ(ctx, v) 5516 if err != nil { 5517 return it, err 5518 } 5519 } 5520 } 5521 5522 return it, nil 5523 } 5524 5525 // endregion **************************** input.gotpl ***************************** 5526 5527 // region ************************** interface.gotpl *************************** 5528 5529 // endregion ************************** interface.gotpl *************************** 5530 5531 // region **************************** object.gotpl **************************** 5532 5533 var autobindImplementors = []string{"Autobind"} 5534 5535 func (ec *executionContext) _Autobind(ctx context.Context, sel ast.SelectionSet, obj *Autobind) graphql.Marshaler { 5536 fields := graphql.CollectFields(ec.OperationContext, sel, autobindImplementors) 5537 out := graphql.NewFieldSet(fields) 5538 var invalids uint32 5539 for i, field := range fields { 5540 switch field.Name { 5541 case "__typename": 5542 out.Values[i] = graphql.MarshalString("Autobind") 5543 case "int": 5544 5545 out.Values[i] = ec._Autobind_int(ctx, field, obj) 5546 5547 if out.Values[i] == graphql.Null { 5548 invalids++ 5549 } 5550 case "int32": 5551 5552 out.Values[i] = ec._Autobind_int32(ctx, field, obj) 5553 5554 if out.Values[i] == graphql.Null { 5555 invalids++ 5556 } 5557 case "int64": 5558 5559 out.Values[i] = ec._Autobind_int64(ctx, field, obj) 5560 5561 if out.Values[i] == graphql.Null { 5562 invalids++ 5563 } 5564 case "idStr": 5565 5566 out.Values[i] = ec._Autobind_idStr(ctx, field, obj) 5567 5568 if out.Values[i] == graphql.Null { 5569 invalids++ 5570 } 5571 case "idInt": 5572 5573 out.Values[i] = ec._Autobind_idInt(ctx, field, obj) 5574 5575 if out.Values[i] == graphql.Null { 5576 invalids++ 5577 } 5578 default: 5579 panic("unknown field " + strconv.Quote(field.Name)) 5580 } 5581 } 5582 out.Dispatch() 5583 if invalids > 0 { 5584 return graphql.Null 5585 } 5586 return out 5587 } 5588 5589 var embeddedPointerImplementors = []string{"EmbeddedPointer"} 5590 5591 func (ec *executionContext) _EmbeddedPointer(ctx context.Context, sel ast.SelectionSet, obj *EmbeddedPointerModel) graphql.Marshaler { 5592 fields := graphql.CollectFields(ec.OperationContext, sel, embeddedPointerImplementors) 5593 out := graphql.NewFieldSet(fields) 5594 var invalids uint32 5595 for i, field := range fields { 5596 switch field.Name { 5597 case "__typename": 5598 out.Values[i] = graphql.MarshalString("EmbeddedPointer") 5599 case "ID": 5600 5601 out.Values[i] = ec._EmbeddedPointer_ID(ctx, field, obj) 5602 5603 case "Title": 5604 5605 out.Values[i] = ec._EmbeddedPointer_Title(ctx, field, obj) 5606 5607 default: 5608 panic("unknown field " + strconv.Quote(field.Name)) 5609 } 5610 } 5611 out.Dispatch() 5612 if invalids > 0 { 5613 return graphql.Null 5614 } 5615 return out 5616 } 5617 5618 var forcedResolverImplementors = []string{"ForcedResolver"} 5619 5620 func (ec *executionContext) _ForcedResolver(ctx context.Context, sel ast.SelectionSet, obj *ForcedResolver) graphql.Marshaler { 5621 fields := graphql.CollectFields(ec.OperationContext, sel, forcedResolverImplementors) 5622 out := graphql.NewFieldSet(fields) 5623 var invalids uint32 5624 for i, field := range fields { 5625 switch field.Name { 5626 case "__typename": 5627 out.Values[i] = graphql.MarshalString("ForcedResolver") 5628 case "field": 5629 field := field 5630 5631 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5632 defer func() { 5633 if r := recover(); r != nil { 5634 ec.Error(ctx, ec.Recover(ctx, r)) 5635 } 5636 }() 5637 res = ec._ForcedResolver_field(ctx, field, obj) 5638 return res 5639 } 5640 5641 out.Concurrently(i, func() graphql.Marshaler { 5642 return innerFunc(ctx) 5643 5644 }) 5645 default: 5646 panic("unknown field " + strconv.Quote(field.Name)) 5647 } 5648 } 5649 out.Dispatch() 5650 if invalids > 0 { 5651 return graphql.Null 5652 } 5653 return out 5654 } 5655 5656 var innerObjectImplementors = []string{"InnerObject"} 5657 5658 func (ec *executionContext) _InnerObject(ctx context.Context, sel ast.SelectionSet, obj *InnerObject) graphql.Marshaler { 5659 fields := graphql.CollectFields(ec.OperationContext, sel, innerObjectImplementors) 5660 out := graphql.NewFieldSet(fields) 5661 var invalids uint32 5662 for i, field := range fields { 5663 switch field.Name { 5664 case "__typename": 5665 out.Values[i] = graphql.MarshalString("InnerObject") 5666 case "id": 5667 5668 out.Values[i] = ec._InnerObject_id(ctx, field, obj) 5669 5670 if out.Values[i] == graphql.Null { 5671 invalids++ 5672 } 5673 default: 5674 panic("unknown field " + strconv.Quote(field.Name)) 5675 } 5676 } 5677 out.Dispatch() 5678 if invalids > 0 { 5679 return graphql.Null 5680 } 5681 return out 5682 } 5683 5684 var invalidIdentifierImplementors = []string{"InvalidIdentifier"} 5685 5686 func (ec *executionContext) _InvalidIdentifier(ctx context.Context, sel ast.SelectionSet, obj *invalid_packagename.InvalidIdentifier) graphql.Marshaler { 5687 fields := graphql.CollectFields(ec.OperationContext, sel, invalidIdentifierImplementors) 5688 out := graphql.NewFieldSet(fields) 5689 var invalids uint32 5690 for i, field := range fields { 5691 switch field.Name { 5692 case "__typename": 5693 out.Values[i] = graphql.MarshalString("InvalidIdentifier") 5694 case "id": 5695 5696 out.Values[i] = ec._InvalidIdentifier_id(ctx, field, obj) 5697 5698 if out.Values[i] == graphql.Null { 5699 invalids++ 5700 } 5701 default: 5702 panic("unknown field " + strconv.Quote(field.Name)) 5703 } 5704 } 5705 out.Dispatch() 5706 if invalids > 0 { 5707 return graphql.Null 5708 } 5709 return out 5710 } 5711 5712 var itImplementors = []string{"It"} 5713 5714 func (ec *executionContext) _It(ctx context.Context, sel ast.SelectionSet, obj *introspection1.It) graphql.Marshaler { 5715 fields := graphql.CollectFields(ec.OperationContext, sel, itImplementors) 5716 out := graphql.NewFieldSet(fields) 5717 var invalids uint32 5718 for i, field := range fields { 5719 switch field.Name { 5720 case "__typename": 5721 out.Values[i] = graphql.MarshalString("It") 5722 case "id": 5723 5724 out.Values[i] = ec._It_id(ctx, field, obj) 5725 5726 if out.Values[i] == graphql.Null { 5727 invalids++ 5728 } 5729 default: 5730 panic("unknown field " + strconv.Quote(field.Name)) 5731 } 5732 } 5733 out.Dispatch() 5734 if invalids > 0 { 5735 return graphql.Null 5736 } 5737 return out 5738 } 5739 5740 var modelMethodsImplementors = []string{"ModelMethods"} 5741 5742 func (ec *executionContext) _ModelMethods(ctx context.Context, sel ast.SelectionSet, obj *ModelMethods) graphql.Marshaler { 5743 fields := graphql.CollectFields(ec.OperationContext, sel, modelMethodsImplementors) 5744 out := graphql.NewFieldSet(fields) 5745 var invalids uint32 5746 for i, field := range fields { 5747 switch field.Name { 5748 case "__typename": 5749 out.Values[i] = graphql.MarshalString("ModelMethods") 5750 case "resolverField": 5751 field := field 5752 5753 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5754 defer func() { 5755 if r := recover(); r != nil { 5756 ec.Error(ctx, ec.Recover(ctx, r)) 5757 } 5758 }() 5759 res = ec._ModelMethods_resolverField(ctx, field, obj) 5760 if res == graphql.Null { 5761 atomic.AddUint32(&invalids, 1) 5762 } 5763 return res 5764 } 5765 5766 out.Concurrently(i, func() graphql.Marshaler { 5767 return innerFunc(ctx) 5768 5769 }) 5770 case "noContext": 5771 5772 out.Values[i] = ec._ModelMethods_noContext(ctx, field, obj) 5773 5774 if out.Values[i] == graphql.Null { 5775 atomic.AddUint32(&invalids, 1) 5776 } 5777 case "withContext": 5778 field := field 5779 5780 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5781 defer func() { 5782 if r := recover(); r != nil { 5783 ec.Error(ctx, ec.Recover(ctx, r)) 5784 } 5785 }() 5786 res = ec._ModelMethods_withContext(ctx, field, obj) 5787 if res == graphql.Null { 5788 atomic.AddUint32(&invalids, 1) 5789 } 5790 return res 5791 } 5792 5793 out.Concurrently(i, func() graphql.Marshaler { 5794 return innerFunc(ctx) 5795 5796 }) 5797 default: 5798 panic("unknown field " + strconv.Quote(field.Name)) 5799 } 5800 } 5801 out.Dispatch() 5802 if invalids > 0 { 5803 return graphql.Null 5804 } 5805 return out 5806 } 5807 5808 var outerObjectImplementors = []string{"OuterObject"} 5809 5810 func (ec *executionContext) _OuterObject(ctx context.Context, sel ast.SelectionSet, obj *OuterObject) graphql.Marshaler { 5811 fields := graphql.CollectFields(ec.OperationContext, sel, outerObjectImplementors) 5812 out := graphql.NewFieldSet(fields) 5813 var invalids uint32 5814 for i, field := range fields { 5815 switch field.Name { 5816 case "__typename": 5817 out.Values[i] = graphql.MarshalString("OuterObject") 5818 case "inner": 5819 5820 out.Values[i] = ec._OuterObject_inner(ctx, field, obj) 5821 5822 if out.Values[i] == graphql.Null { 5823 invalids++ 5824 } 5825 default: 5826 panic("unknown field " + strconv.Quote(field.Name)) 5827 } 5828 } 5829 out.Dispatch() 5830 if invalids > 0 { 5831 return graphql.Null 5832 } 5833 return out 5834 } 5835 5836 var petImplementors = []string{"Pet"} 5837 5838 func (ec *executionContext) _Pet(ctx context.Context, sel ast.SelectionSet, obj *Pet) graphql.Marshaler { 5839 fields := graphql.CollectFields(ec.OperationContext, sel, petImplementors) 5840 out := graphql.NewFieldSet(fields) 5841 var invalids uint32 5842 for i, field := range fields { 5843 switch field.Name { 5844 case "__typename": 5845 out.Values[i] = graphql.MarshalString("Pet") 5846 case "id": 5847 5848 out.Values[i] = ec._Pet_id(ctx, field, obj) 5849 5850 if out.Values[i] == graphql.Null { 5851 atomic.AddUint32(&invalids, 1) 5852 } 5853 case "friends": 5854 field := field 5855 5856 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5857 defer func() { 5858 if r := recover(); r != nil { 5859 ec.Error(ctx, ec.Recover(ctx, r)) 5860 } 5861 }() 5862 res = ec._Pet_friends(ctx, field, obj) 5863 return res 5864 } 5865 5866 out.Concurrently(i, func() graphql.Marshaler { 5867 return innerFunc(ctx) 5868 5869 }) 5870 default: 5871 panic("unknown field " + strconv.Quote(field.Name)) 5872 } 5873 } 5874 out.Dispatch() 5875 if invalids > 0 { 5876 return graphql.Null 5877 } 5878 return out 5879 } 5880 5881 var queryImplementors = []string{"Query"} 5882 5883 func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler { 5884 fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors) 5885 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ 5886 Object: "Query", 5887 }) 5888 5889 out := graphql.NewFieldSet(fields) 5890 var invalids uint32 5891 for i, field := range fields { 5892 innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{ 5893 Object: field.Name, 5894 Field: field, 5895 }) 5896 5897 switch field.Name { 5898 case "__typename": 5899 out.Values[i] = graphql.MarshalString("Query") 5900 case "invalidIdentifier": 5901 field := field 5902 5903 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5904 defer func() { 5905 if r := recover(); r != nil { 5906 ec.Error(ctx, ec.Recover(ctx, r)) 5907 } 5908 }() 5909 res = ec._Query_invalidIdentifier(ctx, field) 5910 return res 5911 } 5912 5913 rrm := func(ctx context.Context) graphql.Marshaler { 5914 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 5915 } 5916 5917 out.Concurrently(i, func() graphql.Marshaler { 5918 return rrm(innerCtx) 5919 }) 5920 case "collision": 5921 field := field 5922 5923 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5924 defer func() { 5925 if r := recover(); r != nil { 5926 ec.Error(ctx, ec.Recover(ctx, r)) 5927 } 5928 }() 5929 res = ec._Query_collision(ctx, field) 5930 return res 5931 } 5932 5933 rrm := func(ctx context.Context) graphql.Marshaler { 5934 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 5935 } 5936 5937 out.Concurrently(i, func() graphql.Marshaler { 5938 return rrm(innerCtx) 5939 }) 5940 case "mapInput": 5941 field := field 5942 5943 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5944 defer func() { 5945 if r := recover(); r != nil { 5946 ec.Error(ctx, ec.Recover(ctx, r)) 5947 } 5948 }() 5949 res = ec._Query_mapInput(ctx, field) 5950 return res 5951 } 5952 5953 rrm := func(ctx context.Context) graphql.Marshaler { 5954 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 5955 } 5956 5957 out.Concurrently(i, func() graphql.Marshaler { 5958 return rrm(innerCtx) 5959 }) 5960 case "recursive": 5961 field := field 5962 5963 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5964 defer func() { 5965 if r := recover(); r != nil { 5966 ec.Error(ctx, ec.Recover(ctx, r)) 5967 } 5968 }() 5969 res = ec._Query_recursive(ctx, field) 5970 return res 5971 } 5972 5973 rrm := func(ctx context.Context) graphql.Marshaler { 5974 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 5975 } 5976 5977 out.Concurrently(i, func() graphql.Marshaler { 5978 return rrm(innerCtx) 5979 }) 5980 case "nestedInputs": 5981 field := field 5982 5983 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5984 defer func() { 5985 if r := recover(); r != nil { 5986 ec.Error(ctx, ec.Recover(ctx, r)) 5987 } 5988 }() 5989 res = ec._Query_nestedInputs(ctx, field) 5990 return res 5991 } 5992 5993 rrm := func(ctx context.Context) graphql.Marshaler { 5994 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 5995 } 5996 5997 out.Concurrently(i, func() graphql.Marshaler { 5998 return rrm(innerCtx) 5999 }) 6000 case "nestedOutputs": 6001 field := field 6002 6003 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6004 defer func() { 6005 if r := recover(); r != nil { 6006 ec.Error(ctx, ec.Recover(ctx, r)) 6007 } 6008 }() 6009 res = ec._Query_nestedOutputs(ctx, field) 6010 return res 6011 } 6012 6013 rrm := func(ctx context.Context) graphql.Marshaler { 6014 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6015 } 6016 6017 out.Concurrently(i, func() graphql.Marshaler { 6018 return rrm(innerCtx) 6019 }) 6020 case "modelMethods": 6021 field := field 6022 6023 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6024 defer func() { 6025 if r := recover(); r != nil { 6026 ec.Error(ctx, ec.Recover(ctx, r)) 6027 } 6028 }() 6029 res = ec._Query_modelMethods(ctx, field) 6030 return res 6031 } 6032 6033 rrm := func(ctx context.Context) graphql.Marshaler { 6034 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6035 } 6036 6037 out.Concurrently(i, func() graphql.Marshaler { 6038 return rrm(innerCtx) 6039 }) 6040 case "user": 6041 field := field 6042 6043 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6044 defer func() { 6045 if r := recover(); r != nil { 6046 ec.Error(ctx, ec.Recover(ctx, r)) 6047 } 6048 }() 6049 res = ec._Query_user(ctx, field) 6050 if res == graphql.Null { 6051 atomic.AddUint32(&invalids, 1) 6052 } 6053 return res 6054 } 6055 6056 rrm := func(ctx context.Context) graphql.Marshaler { 6057 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6058 } 6059 6060 out.Concurrently(i, func() graphql.Marshaler { 6061 return rrm(innerCtx) 6062 }) 6063 case "nullableArg": 6064 field := field 6065 6066 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6067 defer func() { 6068 if r := recover(); r != nil { 6069 ec.Error(ctx, ec.Recover(ctx, r)) 6070 } 6071 }() 6072 res = ec._Query_nullableArg(ctx, field) 6073 return res 6074 } 6075 6076 rrm := func(ctx context.Context) graphql.Marshaler { 6077 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6078 } 6079 6080 out.Concurrently(i, func() graphql.Marshaler { 6081 return rrm(innerCtx) 6082 }) 6083 case "inputSlice": 6084 field := field 6085 6086 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6087 defer func() { 6088 if r := recover(); r != nil { 6089 ec.Error(ctx, ec.Recover(ctx, r)) 6090 } 6091 }() 6092 res = ec._Query_inputSlice(ctx, field) 6093 if res == graphql.Null { 6094 atomic.AddUint32(&invalids, 1) 6095 } 6096 return res 6097 } 6098 6099 rrm := func(ctx context.Context) graphql.Marshaler { 6100 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6101 } 6102 6103 out.Concurrently(i, func() graphql.Marshaler { 6104 return rrm(innerCtx) 6105 }) 6106 case "inputNullableSlice": 6107 field := field 6108 6109 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6110 defer func() { 6111 if r := recover(); r != nil { 6112 ec.Error(ctx, ec.Recover(ctx, r)) 6113 } 6114 }() 6115 res = ec._Query_inputNullableSlice(ctx, field) 6116 if res == graphql.Null { 6117 atomic.AddUint32(&invalids, 1) 6118 } 6119 return res 6120 } 6121 6122 rrm := func(ctx context.Context) graphql.Marshaler { 6123 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6124 } 6125 6126 out.Concurrently(i, func() graphql.Marshaler { 6127 return rrm(innerCtx) 6128 }) 6129 case "shapeUnion": 6130 field := field 6131 6132 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6133 defer func() { 6134 if r := recover(); r != nil { 6135 ec.Error(ctx, ec.Recover(ctx, r)) 6136 } 6137 }() 6138 res = ec._Query_shapeUnion(ctx, field) 6139 if res == graphql.Null { 6140 atomic.AddUint32(&invalids, 1) 6141 } 6142 return res 6143 } 6144 6145 rrm := func(ctx context.Context) graphql.Marshaler { 6146 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6147 } 6148 6149 out.Concurrently(i, func() graphql.Marshaler { 6150 return rrm(innerCtx) 6151 }) 6152 case "autobind": 6153 field := field 6154 6155 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6156 defer func() { 6157 if r := recover(); r != nil { 6158 ec.Error(ctx, ec.Recover(ctx, r)) 6159 } 6160 }() 6161 res = ec._Query_autobind(ctx, field) 6162 return res 6163 } 6164 6165 rrm := func(ctx context.Context) graphql.Marshaler { 6166 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6167 } 6168 6169 out.Concurrently(i, func() graphql.Marshaler { 6170 return rrm(innerCtx) 6171 }) 6172 case "deprecatedField": 6173 field := field 6174 6175 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6176 defer func() { 6177 if r := recover(); r != nil { 6178 ec.Error(ctx, ec.Recover(ctx, r)) 6179 } 6180 }() 6181 res = ec._Query_deprecatedField(ctx, field) 6182 if res == graphql.Null { 6183 atomic.AddUint32(&invalids, 1) 6184 } 6185 return res 6186 } 6187 6188 rrm := func(ctx context.Context) graphql.Marshaler { 6189 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6190 } 6191 6192 out.Concurrently(i, func() graphql.Marshaler { 6193 return rrm(innerCtx) 6194 }) 6195 case "overlapping": 6196 field := field 6197 6198 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6199 defer func() { 6200 if r := recover(); r != nil { 6201 ec.Error(ctx, ec.Recover(ctx, r)) 6202 } 6203 }() 6204 res = ec._Query_overlapping(ctx, field) 6205 return res 6206 } 6207 6208 rrm := func(ctx context.Context) graphql.Marshaler { 6209 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6210 } 6211 6212 out.Concurrently(i, func() graphql.Marshaler { 6213 return rrm(innerCtx) 6214 }) 6215 case "defaultParameters": 6216 field := field 6217 6218 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6219 defer func() { 6220 if r := recover(); r != nil { 6221 ec.Error(ctx, ec.Recover(ctx, r)) 6222 } 6223 }() 6224 res = ec._Query_defaultParameters(ctx, field) 6225 if res == graphql.Null { 6226 atomic.AddUint32(&invalids, 1) 6227 } 6228 return res 6229 } 6230 6231 rrm := func(ctx context.Context) graphql.Marshaler { 6232 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6233 } 6234 6235 out.Concurrently(i, func() graphql.Marshaler { 6236 return rrm(innerCtx) 6237 }) 6238 case "directiveArg": 6239 field := field 6240 6241 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6242 defer func() { 6243 if r := recover(); r != nil { 6244 ec.Error(ctx, ec.Recover(ctx, r)) 6245 } 6246 }() 6247 res = ec._Query_directiveArg(ctx, field) 6248 return res 6249 } 6250 6251 rrm := func(ctx context.Context) graphql.Marshaler { 6252 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6253 } 6254 6255 out.Concurrently(i, func() graphql.Marshaler { 6256 return rrm(innerCtx) 6257 }) 6258 case "directiveNullableArg": 6259 field := field 6260 6261 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6262 defer func() { 6263 if r := recover(); r != nil { 6264 ec.Error(ctx, ec.Recover(ctx, r)) 6265 } 6266 }() 6267 res = ec._Query_directiveNullableArg(ctx, field) 6268 return res 6269 } 6270 6271 rrm := func(ctx context.Context) graphql.Marshaler { 6272 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6273 } 6274 6275 out.Concurrently(i, func() graphql.Marshaler { 6276 return rrm(innerCtx) 6277 }) 6278 case "directiveInputNullable": 6279 field := field 6280 6281 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6282 defer func() { 6283 if r := recover(); r != nil { 6284 ec.Error(ctx, ec.Recover(ctx, r)) 6285 } 6286 }() 6287 res = ec._Query_directiveInputNullable(ctx, field) 6288 return res 6289 } 6290 6291 rrm := func(ctx context.Context) graphql.Marshaler { 6292 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6293 } 6294 6295 out.Concurrently(i, func() graphql.Marshaler { 6296 return rrm(innerCtx) 6297 }) 6298 case "directiveInput": 6299 field := field 6300 6301 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6302 defer func() { 6303 if r := recover(); r != nil { 6304 ec.Error(ctx, ec.Recover(ctx, r)) 6305 } 6306 }() 6307 res = ec._Query_directiveInput(ctx, field) 6308 return res 6309 } 6310 6311 rrm := func(ctx context.Context) graphql.Marshaler { 6312 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6313 } 6314 6315 out.Concurrently(i, func() graphql.Marshaler { 6316 return rrm(innerCtx) 6317 }) 6318 case "directiveInputType": 6319 field := field 6320 6321 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6322 defer func() { 6323 if r := recover(); r != nil { 6324 ec.Error(ctx, ec.Recover(ctx, r)) 6325 } 6326 }() 6327 res = ec._Query_directiveInputType(ctx, field) 6328 return res 6329 } 6330 6331 rrm := func(ctx context.Context) graphql.Marshaler { 6332 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6333 } 6334 6335 out.Concurrently(i, func() graphql.Marshaler { 6336 return rrm(innerCtx) 6337 }) 6338 case "directiveObject": 6339 field := field 6340 6341 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6342 defer func() { 6343 if r := recover(); r != nil { 6344 ec.Error(ctx, ec.Recover(ctx, r)) 6345 } 6346 }() 6347 res = ec._Query_directiveObject(ctx, field) 6348 return res 6349 } 6350 6351 rrm := func(ctx context.Context) graphql.Marshaler { 6352 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6353 } 6354 6355 out.Concurrently(i, func() graphql.Marshaler { 6356 return rrm(innerCtx) 6357 }) 6358 case "directiveObjectWithCustomGoModel": 6359 field := field 6360 6361 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6362 defer func() { 6363 if r := recover(); r != nil { 6364 ec.Error(ctx, ec.Recover(ctx, r)) 6365 } 6366 }() 6367 res = ec._Query_directiveObjectWithCustomGoModel(ctx, field) 6368 return res 6369 } 6370 6371 rrm := func(ctx context.Context) graphql.Marshaler { 6372 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6373 } 6374 6375 out.Concurrently(i, func() graphql.Marshaler { 6376 return rrm(innerCtx) 6377 }) 6378 case "directiveFieldDef": 6379 field := field 6380 6381 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6382 defer func() { 6383 if r := recover(); r != nil { 6384 ec.Error(ctx, ec.Recover(ctx, r)) 6385 } 6386 }() 6387 res = ec._Query_directiveFieldDef(ctx, field) 6388 if res == graphql.Null { 6389 atomic.AddUint32(&invalids, 1) 6390 } 6391 return res 6392 } 6393 6394 rrm := func(ctx context.Context) graphql.Marshaler { 6395 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6396 } 6397 6398 out.Concurrently(i, func() graphql.Marshaler { 6399 return rrm(innerCtx) 6400 }) 6401 case "directiveField": 6402 field := field 6403 6404 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6405 defer func() { 6406 if r := recover(); r != nil { 6407 ec.Error(ctx, ec.Recover(ctx, r)) 6408 } 6409 }() 6410 res = ec._Query_directiveField(ctx, field) 6411 return res 6412 } 6413 6414 rrm := func(ctx context.Context) graphql.Marshaler { 6415 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6416 } 6417 6418 out.Concurrently(i, func() graphql.Marshaler { 6419 return rrm(innerCtx) 6420 }) 6421 case "directiveDouble": 6422 field := field 6423 6424 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6425 defer func() { 6426 if r := recover(); r != nil { 6427 ec.Error(ctx, ec.Recover(ctx, r)) 6428 } 6429 }() 6430 res = ec._Query_directiveDouble(ctx, field) 6431 return res 6432 } 6433 6434 rrm := func(ctx context.Context) graphql.Marshaler { 6435 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6436 } 6437 6438 out.Concurrently(i, func() graphql.Marshaler { 6439 return rrm(innerCtx) 6440 }) 6441 case "directiveUnimplemented": 6442 field := field 6443 6444 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6445 defer func() { 6446 if r := recover(); r != nil { 6447 ec.Error(ctx, ec.Recover(ctx, r)) 6448 } 6449 }() 6450 res = ec._Query_directiveUnimplemented(ctx, field) 6451 return res 6452 } 6453 6454 rrm := func(ctx context.Context) graphql.Marshaler { 6455 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6456 } 6457 6458 out.Concurrently(i, func() graphql.Marshaler { 6459 return rrm(innerCtx) 6460 }) 6461 case "embeddedCase1": 6462 field := field 6463 6464 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6465 defer func() { 6466 if r := recover(); r != nil { 6467 ec.Error(ctx, ec.Recover(ctx, r)) 6468 } 6469 }() 6470 res = ec._Query_embeddedCase1(ctx, field) 6471 return res 6472 } 6473 6474 rrm := func(ctx context.Context) graphql.Marshaler { 6475 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6476 } 6477 6478 out.Concurrently(i, func() graphql.Marshaler { 6479 return rrm(innerCtx) 6480 }) 6481 case "embeddedCase2": 6482 field := field 6483 6484 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6485 defer func() { 6486 if r := recover(); r != nil { 6487 ec.Error(ctx, ec.Recover(ctx, r)) 6488 } 6489 }() 6490 res = ec._Query_embeddedCase2(ctx, field) 6491 return res 6492 } 6493 6494 rrm := func(ctx context.Context) graphql.Marshaler { 6495 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6496 } 6497 6498 out.Concurrently(i, func() graphql.Marshaler { 6499 return rrm(innerCtx) 6500 }) 6501 case "embeddedCase3": 6502 field := field 6503 6504 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6505 defer func() { 6506 if r := recover(); r != nil { 6507 ec.Error(ctx, ec.Recover(ctx, r)) 6508 } 6509 }() 6510 res = ec._Query_embeddedCase3(ctx, field) 6511 return res 6512 } 6513 6514 rrm := func(ctx context.Context) graphql.Marshaler { 6515 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6516 } 6517 6518 out.Concurrently(i, func() graphql.Marshaler { 6519 return rrm(innerCtx) 6520 }) 6521 case "enumInInput": 6522 field := field 6523 6524 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6525 defer func() { 6526 if r := recover(); r != nil { 6527 ec.Error(ctx, ec.Recover(ctx, r)) 6528 } 6529 }() 6530 res = ec._Query_enumInInput(ctx, field) 6531 if res == graphql.Null { 6532 atomic.AddUint32(&invalids, 1) 6533 } 6534 return res 6535 } 6536 6537 rrm := func(ctx context.Context) graphql.Marshaler { 6538 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6539 } 6540 6541 out.Concurrently(i, func() graphql.Marshaler { 6542 return rrm(innerCtx) 6543 }) 6544 case "shapes": 6545 field := field 6546 6547 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6548 defer func() { 6549 if r := recover(); r != nil { 6550 ec.Error(ctx, ec.Recover(ctx, r)) 6551 } 6552 }() 6553 res = ec._Query_shapes(ctx, field) 6554 return res 6555 } 6556 6557 rrm := func(ctx context.Context) graphql.Marshaler { 6558 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6559 } 6560 6561 out.Concurrently(i, func() graphql.Marshaler { 6562 return rrm(innerCtx) 6563 }) 6564 case "noShape": 6565 field := field 6566 6567 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6568 defer func() { 6569 if r := recover(); r != nil { 6570 ec.Error(ctx, ec.Recover(ctx, r)) 6571 } 6572 }() 6573 res = ec._Query_noShape(ctx, field) 6574 return res 6575 } 6576 6577 rrm := func(ctx context.Context) graphql.Marshaler { 6578 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6579 } 6580 6581 out.Concurrently(i, func() graphql.Marshaler { 6582 return rrm(innerCtx) 6583 }) 6584 case "node": 6585 field := field 6586 6587 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6588 defer func() { 6589 if r := recover(); r != nil { 6590 ec.Error(ctx, ec.Recover(ctx, r)) 6591 } 6592 }() 6593 res = ec._Query_node(ctx, field) 6594 if res == graphql.Null { 6595 atomic.AddUint32(&invalids, 1) 6596 } 6597 return res 6598 } 6599 6600 rrm := func(ctx context.Context) graphql.Marshaler { 6601 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6602 } 6603 6604 out.Concurrently(i, func() graphql.Marshaler { 6605 return rrm(innerCtx) 6606 }) 6607 case "noShapeTypedNil": 6608 field := field 6609 6610 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6611 defer func() { 6612 if r := recover(); r != nil { 6613 ec.Error(ctx, ec.Recover(ctx, r)) 6614 } 6615 }() 6616 res = ec._Query_noShapeTypedNil(ctx, field) 6617 return res 6618 } 6619 6620 rrm := func(ctx context.Context) graphql.Marshaler { 6621 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6622 } 6623 6624 out.Concurrently(i, func() graphql.Marshaler { 6625 return rrm(innerCtx) 6626 }) 6627 case "animal": 6628 field := field 6629 6630 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6631 defer func() { 6632 if r := recover(); r != nil { 6633 ec.Error(ctx, ec.Recover(ctx, r)) 6634 } 6635 }() 6636 res = ec._Query_animal(ctx, field) 6637 return res 6638 } 6639 6640 rrm := func(ctx context.Context) graphql.Marshaler { 6641 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6642 } 6643 6644 out.Concurrently(i, func() graphql.Marshaler { 6645 return rrm(innerCtx) 6646 }) 6647 case "notAnInterface": 6648 field := field 6649 6650 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6651 defer func() { 6652 if r := recover(); r != nil { 6653 ec.Error(ctx, ec.Recover(ctx, r)) 6654 } 6655 }() 6656 res = ec._Query_notAnInterface(ctx, field) 6657 return res 6658 } 6659 6660 rrm := func(ctx context.Context) graphql.Marshaler { 6661 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6662 } 6663 6664 out.Concurrently(i, func() graphql.Marshaler { 6665 return rrm(innerCtx) 6666 }) 6667 case "issue896a": 6668 field := field 6669 6670 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6671 defer func() { 6672 if r := recover(); r != nil { 6673 ec.Error(ctx, ec.Recover(ctx, r)) 6674 } 6675 }() 6676 res = ec._Query_issue896a(ctx, field) 6677 return res 6678 } 6679 6680 rrm := func(ctx context.Context) graphql.Marshaler { 6681 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6682 } 6683 6684 out.Concurrently(i, func() graphql.Marshaler { 6685 return rrm(innerCtx) 6686 }) 6687 case "mapStringInterface": 6688 field := field 6689 6690 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6691 defer func() { 6692 if r := recover(); r != nil { 6693 ec.Error(ctx, ec.Recover(ctx, r)) 6694 } 6695 }() 6696 res = ec._Query_mapStringInterface(ctx, field) 6697 return res 6698 } 6699 6700 rrm := func(ctx context.Context) graphql.Marshaler { 6701 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6702 } 6703 6704 out.Concurrently(i, func() graphql.Marshaler { 6705 return rrm(innerCtx) 6706 }) 6707 case "mapNestedStringInterface": 6708 field := field 6709 6710 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6711 defer func() { 6712 if r := recover(); r != nil { 6713 ec.Error(ctx, ec.Recover(ctx, r)) 6714 } 6715 }() 6716 res = ec._Query_mapNestedStringInterface(ctx, field) 6717 return res 6718 } 6719 6720 rrm := func(ctx context.Context) graphql.Marshaler { 6721 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6722 } 6723 6724 out.Concurrently(i, func() graphql.Marshaler { 6725 return rrm(innerCtx) 6726 }) 6727 case "errorBubble": 6728 field := field 6729 6730 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6731 defer func() { 6732 if r := recover(); r != nil { 6733 ec.Error(ctx, ec.Recover(ctx, r)) 6734 } 6735 }() 6736 res = ec._Query_errorBubble(ctx, field) 6737 return res 6738 } 6739 6740 rrm := func(ctx context.Context) graphql.Marshaler { 6741 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6742 } 6743 6744 out.Concurrently(i, func() graphql.Marshaler { 6745 return rrm(innerCtx) 6746 }) 6747 case "errorBubbleList": 6748 field := field 6749 6750 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6751 defer func() { 6752 if r := recover(); r != nil { 6753 ec.Error(ctx, ec.Recover(ctx, r)) 6754 } 6755 }() 6756 res = ec._Query_errorBubbleList(ctx, field) 6757 return res 6758 } 6759 6760 rrm := func(ctx context.Context) graphql.Marshaler { 6761 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6762 } 6763 6764 out.Concurrently(i, func() graphql.Marshaler { 6765 return rrm(innerCtx) 6766 }) 6767 case "errorList": 6768 field := field 6769 6770 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6771 defer func() { 6772 if r := recover(); r != nil { 6773 ec.Error(ctx, ec.Recover(ctx, r)) 6774 } 6775 }() 6776 res = ec._Query_errorList(ctx, field) 6777 return res 6778 } 6779 6780 rrm := func(ctx context.Context) graphql.Marshaler { 6781 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6782 } 6783 6784 out.Concurrently(i, func() graphql.Marshaler { 6785 return rrm(innerCtx) 6786 }) 6787 case "errors": 6788 field := field 6789 6790 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6791 defer func() { 6792 if r := recover(); r != nil { 6793 ec.Error(ctx, ec.Recover(ctx, r)) 6794 } 6795 }() 6796 res = ec._Query_errors(ctx, field) 6797 return res 6798 } 6799 6800 rrm := func(ctx context.Context) graphql.Marshaler { 6801 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6802 } 6803 6804 out.Concurrently(i, func() graphql.Marshaler { 6805 return rrm(innerCtx) 6806 }) 6807 case "valid": 6808 field := field 6809 6810 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6811 defer func() { 6812 if r := recover(); r != nil { 6813 ec.Error(ctx, ec.Recover(ctx, r)) 6814 } 6815 }() 6816 res = ec._Query_valid(ctx, field) 6817 if res == graphql.Null { 6818 atomic.AddUint32(&invalids, 1) 6819 } 6820 return res 6821 } 6822 6823 rrm := func(ctx context.Context) graphql.Marshaler { 6824 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6825 } 6826 6827 out.Concurrently(i, func() graphql.Marshaler { 6828 return rrm(innerCtx) 6829 }) 6830 case "panics": 6831 field := field 6832 6833 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6834 defer func() { 6835 if r := recover(); r != nil { 6836 ec.Error(ctx, ec.Recover(ctx, r)) 6837 } 6838 }() 6839 res = ec._Query_panics(ctx, field) 6840 return res 6841 } 6842 6843 rrm := func(ctx context.Context) graphql.Marshaler { 6844 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6845 } 6846 6847 out.Concurrently(i, func() graphql.Marshaler { 6848 return rrm(innerCtx) 6849 }) 6850 case "primitiveObject": 6851 field := field 6852 6853 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6854 defer func() { 6855 if r := recover(); r != nil { 6856 ec.Error(ctx, ec.Recover(ctx, r)) 6857 } 6858 }() 6859 res = ec._Query_primitiveObject(ctx, field) 6860 if res == graphql.Null { 6861 atomic.AddUint32(&invalids, 1) 6862 } 6863 return res 6864 } 6865 6866 rrm := func(ctx context.Context) graphql.Marshaler { 6867 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6868 } 6869 6870 out.Concurrently(i, func() graphql.Marshaler { 6871 return rrm(innerCtx) 6872 }) 6873 case "primitiveStringObject": 6874 field := field 6875 6876 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6877 defer func() { 6878 if r := recover(); r != nil { 6879 ec.Error(ctx, ec.Recover(ctx, r)) 6880 } 6881 }() 6882 res = ec._Query_primitiveStringObject(ctx, field) 6883 if res == graphql.Null { 6884 atomic.AddUint32(&invalids, 1) 6885 } 6886 return res 6887 } 6888 6889 rrm := func(ctx context.Context) graphql.Marshaler { 6890 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6891 } 6892 6893 out.Concurrently(i, func() graphql.Marshaler { 6894 return rrm(innerCtx) 6895 }) 6896 case "ptrToSliceContainer": 6897 field := field 6898 6899 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6900 defer func() { 6901 if r := recover(); r != nil { 6902 ec.Error(ctx, ec.Recover(ctx, r)) 6903 } 6904 }() 6905 res = ec._Query_ptrToSliceContainer(ctx, field) 6906 if res == graphql.Null { 6907 atomic.AddUint32(&invalids, 1) 6908 } 6909 return res 6910 } 6911 6912 rrm := func(ctx context.Context) graphql.Marshaler { 6913 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6914 } 6915 6916 out.Concurrently(i, func() graphql.Marshaler { 6917 return rrm(innerCtx) 6918 }) 6919 case "infinity": 6920 field := field 6921 6922 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6923 defer func() { 6924 if r := recover(); r != nil { 6925 ec.Error(ctx, ec.Recover(ctx, r)) 6926 } 6927 }() 6928 res = ec._Query_infinity(ctx, field) 6929 if res == graphql.Null { 6930 atomic.AddUint32(&invalids, 1) 6931 } 6932 return res 6933 } 6934 6935 rrm := func(ctx context.Context) graphql.Marshaler { 6936 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6937 } 6938 6939 out.Concurrently(i, func() graphql.Marshaler { 6940 return rrm(innerCtx) 6941 }) 6942 case "stringFromContextInterface": 6943 field := field 6944 6945 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6946 defer func() { 6947 if r := recover(); r != nil { 6948 ec.Error(ctx, ec.Recover(ctx, r)) 6949 } 6950 }() 6951 res = ec._Query_stringFromContextInterface(ctx, field) 6952 if res == graphql.Null { 6953 atomic.AddUint32(&invalids, 1) 6954 } 6955 return res 6956 } 6957 6958 rrm := func(ctx context.Context) graphql.Marshaler { 6959 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6960 } 6961 6962 out.Concurrently(i, func() graphql.Marshaler { 6963 return rrm(innerCtx) 6964 }) 6965 case "stringFromContextFunction": 6966 field := field 6967 6968 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6969 defer func() { 6970 if r := recover(); r != nil { 6971 ec.Error(ctx, ec.Recover(ctx, r)) 6972 } 6973 }() 6974 res = ec._Query_stringFromContextFunction(ctx, field) 6975 if res == graphql.Null { 6976 atomic.AddUint32(&invalids, 1) 6977 } 6978 return res 6979 } 6980 6981 rrm := func(ctx context.Context) graphql.Marshaler { 6982 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6983 } 6984 6985 out.Concurrently(i, func() graphql.Marshaler { 6986 return rrm(innerCtx) 6987 }) 6988 case "defaultScalar": 6989 field := field 6990 6991 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6992 defer func() { 6993 if r := recover(); r != nil { 6994 ec.Error(ctx, ec.Recover(ctx, r)) 6995 } 6996 }() 6997 res = ec._Query_defaultScalar(ctx, field) 6998 if res == graphql.Null { 6999 atomic.AddUint32(&invalids, 1) 7000 } 7001 return res 7002 } 7003 7004 rrm := func(ctx context.Context) graphql.Marshaler { 7005 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7006 } 7007 7008 out.Concurrently(i, func() graphql.Marshaler { 7009 return rrm(innerCtx) 7010 }) 7011 case "slices": 7012 field := field 7013 7014 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7015 defer func() { 7016 if r := recover(); r != nil { 7017 ec.Error(ctx, ec.Recover(ctx, r)) 7018 } 7019 }() 7020 res = ec._Query_slices(ctx, field) 7021 return res 7022 } 7023 7024 rrm := func(ctx context.Context) graphql.Marshaler { 7025 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7026 } 7027 7028 out.Concurrently(i, func() graphql.Marshaler { 7029 return rrm(innerCtx) 7030 }) 7031 case "scalarSlice": 7032 field := field 7033 7034 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7035 defer func() { 7036 if r := recover(); r != nil { 7037 ec.Error(ctx, ec.Recover(ctx, r)) 7038 } 7039 }() 7040 res = ec._Query_scalarSlice(ctx, field) 7041 if res == graphql.Null { 7042 atomic.AddUint32(&invalids, 1) 7043 } 7044 return res 7045 } 7046 7047 rrm := func(ctx context.Context) graphql.Marshaler { 7048 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7049 } 7050 7051 out.Concurrently(i, func() graphql.Marshaler { 7052 return rrm(innerCtx) 7053 }) 7054 case "fallback": 7055 field := field 7056 7057 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7058 defer func() { 7059 if r := recover(); r != nil { 7060 ec.Error(ctx, ec.Recover(ctx, r)) 7061 } 7062 }() 7063 res = ec._Query_fallback(ctx, field) 7064 if res == graphql.Null { 7065 atomic.AddUint32(&invalids, 1) 7066 } 7067 return res 7068 } 7069 7070 rrm := func(ctx context.Context) graphql.Marshaler { 7071 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7072 } 7073 7074 out.Concurrently(i, func() graphql.Marshaler { 7075 return rrm(innerCtx) 7076 }) 7077 case "optionalUnion": 7078 field := field 7079 7080 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7081 defer func() { 7082 if r := recover(); r != nil { 7083 ec.Error(ctx, ec.Recover(ctx, r)) 7084 } 7085 }() 7086 res = ec._Query_optionalUnion(ctx, field) 7087 return res 7088 } 7089 7090 rrm := func(ctx context.Context) graphql.Marshaler { 7091 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7092 } 7093 7094 out.Concurrently(i, func() graphql.Marshaler { 7095 return rrm(innerCtx) 7096 }) 7097 case "vOkCaseValue": 7098 field := field 7099 7100 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7101 defer func() { 7102 if r := recover(); r != nil { 7103 ec.Error(ctx, ec.Recover(ctx, r)) 7104 } 7105 }() 7106 res = ec._Query_vOkCaseValue(ctx, field) 7107 return res 7108 } 7109 7110 rrm := func(ctx context.Context) graphql.Marshaler { 7111 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7112 } 7113 7114 out.Concurrently(i, func() graphql.Marshaler { 7115 return rrm(innerCtx) 7116 }) 7117 case "vOkCaseNil": 7118 field := field 7119 7120 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7121 defer func() { 7122 if r := recover(); r != nil { 7123 ec.Error(ctx, ec.Recover(ctx, r)) 7124 } 7125 }() 7126 res = ec._Query_vOkCaseNil(ctx, field) 7127 return res 7128 } 7129 7130 rrm := func(ctx context.Context) graphql.Marshaler { 7131 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7132 } 7133 7134 out.Concurrently(i, func() graphql.Marshaler { 7135 return rrm(innerCtx) 7136 }) 7137 case "validType": 7138 field := field 7139 7140 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7141 defer func() { 7142 if r := recover(); r != nil { 7143 ec.Error(ctx, ec.Recover(ctx, r)) 7144 } 7145 }() 7146 res = ec._Query_validType(ctx, field) 7147 return res 7148 } 7149 7150 rrm := func(ctx context.Context) graphql.Marshaler { 7151 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7152 } 7153 7154 out.Concurrently(i, func() graphql.Marshaler { 7155 return rrm(innerCtx) 7156 }) 7157 case "variadicModel": 7158 field := field 7159 7160 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7161 defer func() { 7162 if r := recover(); r != nil { 7163 ec.Error(ctx, ec.Recover(ctx, r)) 7164 } 7165 }() 7166 res = ec._Query_variadicModel(ctx, field) 7167 return res 7168 } 7169 7170 rrm := func(ctx context.Context) graphql.Marshaler { 7171 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7172 } 7173 7174 out.Concurrently(i, func() graphql.Marshaler { 7175 return rrm(innerCtx) 7176 }) 7177 case "wrappedStruct": 7178 field := field 7179 7180 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7181 defer func() { 7182 if r := recover(); r != nil { 7183 ec.Error(ctx, ec.Recover(ctx, r)) 7184 } 7185 }() 7186 res = ec._Query_wrappedStruct(ctx, field) 7187 if res == graphql.Null { 7188 atomic.AddUint32(&invalids, 1) 7189 } 7190 return res 7191 } 7192 7193 rrm := func(ctx context.Context) graphql.Marshaler { 7194 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7195 } 7196 7197 out.Concurrently(i, func() graphql.Marshaler { 7198 return rrm(innerCtx) 7199 }) 7200 case "wrappedScalar": 7201 field := field 7202 7203 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7204 defer func() { 7205 if r := recover(); r != nil { 7206 ec.Error(ctx, ec.Recover(ctx, r)) 7207 } 7208 }() 7209 res = ec._Query_wrappedScalar(ctx, field) 7210 if res == graphql.Null { 7211 atomic.AddUint32(&invalids, 1) 7212 } 7213 return res 7214 } 7215 7216 rrm := func(ctx context.Context) graphql.Marshaler { 7217 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7218 } 7219 7220 out.Concurrently(i, func() graphql.Marshaler { 7221 return rrm(innerCtx) 7222 }) 7223 case "wrappedMap": 7224 field := field 7225 7226 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7227 defer func() { 7228 if r := recover(); r != nil { 7229 ec.Error(ctx, ec.Recover(ctx, r)) 7230 } 7231 }() 7232 res = ec._Query_wrappedMap(ctx, field) 7233 if res == graphql.Null { 7234 atomic.AddUint32(&invalids, 1) 7235 } 7236 return res 7237 } 7238 7239 rrm := func(ctx context.Context) graphql.Marshaler { 7240 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7241 } 7242 7243 out.Concurrently(i, func() graphql.Marshaler { 7244 return rrm(innerCtx) 7245 }) 7246 case "wrappedSlice": 7247 field := field 7248 7249 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7250 defer func() { 7251 if r := recover(); r != nil { 7252 ec.Error(ctx, ec.Recover(ctx, r)) 7253 } 7254 }() 7255 res = ec._Query_wrappedSlice(ctx, field) 7256 if res == graphql.Null { 7257 atomic.AddUint32(&invalids, 1) 7258 } 7259 return res 7260 } 7261 7262 rrm := func(ctx context.Context) graphql.Marshaler { 7263 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7264 } 7265 7266 out.Concurrently(i, func() graphql.Marshaler { 7267 return rrm(innerCtx) 7268 }) 7269 case "__type": 7270 7271 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { 7272 return ec._Query___type(ctx, field) 7273 }) 7274 7275 case "__schema": 7276 7277 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { 7278 return ec._Query___schema(ctx, field) 7279 }) 7280 7281 default: 7282 panic("unknown field " + strconv.Quote(field.Name)) 7283 } 7284 } 7285 out.Dispatch() 7286 if invalids > 0 { 7287 return graphql.Null 7288 } 7289 return out 7290 } 7291 7292 var subscriptionImplementors = []string{"Subscription"} 7293 7294 func (ec *executionContext) _Subscription(ctx context.Context, sel ast.SelectionSet) func(ctx context.Context) graphql.Marshaler { 7295 fields := graphql.CollectFields(ec.OperationContext, sel, subscriptionImplementors) 7296 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ 7297 Object: "Subscription", 7298 }) 7299 if len(fields) != 1 { 7300 ec.Errorf(ctx, "must subscribe to exactly one stream") 7301 return nil 7302 } 7303 7304 switch fields[0].Name { 7305 case "updated": 7306 return ec._Subscription_updated(ctx, fields[0]) 7307 case "initPayload": 7308 return ec._Subscription_initPayload(ctx, fields[0]) 7309 case "directiveArg": 7310 return ec._Subscription_directiveArg(ctx, fields[0]) 7311 case "directiveNullableArg": 7312 return ec._Subscription_directiveNullableArg(ctx, fields[0]) 7313 case "directiveDouble": 7314 return ec._Subscription_directiveDouble(ctx, fields[0]) 7315 case "directiveUnimplemented": 7316 return ec._Subscription_directiveUnimplemented(ctx, fields[0]) 7317 case "issue896b": 7318 return ec._Subscription_issue896b(ctx, fields[0]) 7319 case "errorRequired": 7320 return ec._Subscription_errorRequired(ctx, fields[0]) 7321 default: 7322 panic("unknown field " + strconv.Quote(fields[0].Name)) 7323 } 7324 } 7325 7326 var userImplementors = []string{"User"} 7327 7328 func (ec *executionContext) _User(ctx context.Context, sel ast.SelectionSet, obj *User) graphql.Marshaler { 7329 fields := graphql.CollectFields(ec.OperationContext, sel, userImplementors) 7330 out := graphql.NewFieldSet(fields) 7331 var invalids uint32 7332 for i, field := range fields { 7333 switch field.Name { 7334 case "__typename": 7335 out.Values[i] = graphql.MarshalString("User") 7336 case "id": 7337 7338 out.Values[i] = ec._User_id(ctx, field, obj) 7339 7340 if out.Values[i] == graphql.Null { 7341 atomic.AddUint32(&invalids, 1) 7342 } 7343 case "friends": 7344 field := field 7345 7346 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7347 defer func() { 7348 if r := recover(); r != nil { 7349 ec.Error(ctx, ec.Recover(ctx, r)) 7350 } 7351 }() 7352 res = ec._User_friends(ctx, field, obj) 7353 if res == graphql.Null { 7354 atomic.AddUint32(&invalids, 1) 7355 } 7356 return res 7357 } 7358 7359 out.Concurrently(i, func() graphql.Marshaler { 7360 return innerFunc(ctx) 7361 7362 }) 7363 case "created": 7364 7365 out.Values[i] = ec._User_created(ctx, field, obj) 7366 7367 if out.Values[i] == graphql.Null { 7368 atomic.AddUint32(&invalids, 1) 7369 } 7370 case "updated": 7371 7372 out.Values[i] = ec._User_updated(ctx, field, obj) 7373 7374 case "pets": 7375 field := field 7376 7377 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7378 defer func() { 7379 if r := recover(); r != nil { 7380 ec.Error(ctx, ec.Recover(ctx, r)) 7381 } 7382 }() 7383 res = ec._User_pets(ctx, field, obj) 7384 return res 7385 } 7386 7387 out.Concurrently(i, func() graphql.Marshaler { 7388 return innerFunc(ctx) 7389 7390 }) 7391 default: 7392 panic("unknown field " + strconv.Quote(field.Name)) 7393 } 7394 } 7395 out.Dispatch() 7396 if invalids > 0 { 7397 return graphql.Null 7398 } 7399 return out 7400 } 7401 7402 // endregion **************************** object.gotpl **************************** 7403 7404 // region ***************************** type.gotpl ***************************** 7405 7406 func (ec *executionContext) unmarshalNInnerInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerInput(ctx context.Context, v interface{}) (InnerInput, error) { 7407 res, err := ec.unmarshalInputInnerInput(ctx, v) 7408 return res, graphql.ErrorOnPath(ctx, err) 7409 } 7410 7411 func (ec *executionContext) unmarshalNInnerInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerInput(ctx context.Context, v interface{}) (*InnerInput, error) { 7412 res, err := ec.unmarshalInputInnerInput(ctx, v) 7413 return &res, graphql.ErrorOnPath(ctx, err) 7414 } 7415 7416 func (ec *executionContext) marshalNInnerObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerObject(ctx context.Context, sel ast.SelectionSet, v *InnerObject) graphql.Marshaler { 7417 if v == nil { 7418 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 7419 ec.Errorf(ctx, "the requested element is null which the schema does not allow") 7420 } 7421 return graphql.Null 7422 } 7423 return ec._InnerObject(ctx, sel, v) 7424 } 7425 7426 func (ec *executionContext) marshalNPet2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPet(ctx context.Context, sel ast.SelectionSet, v *Pet) graphql.Marshaler { 7427 if v == nil { 7428 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 7429 ec.Errorf(ctx, "the requested element is null which the schema does not allow") 7430 } 7431 return graphql.Null 7432 } 7433 return ec._Pet(ctx, sel, v) 7434 } 7435 7436 func (ec *executionContext) unmarshalNRecursiveInputSlice2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSlice(ctx context.Context, v interface{}) (RecursiveInputSlice, error) { 7437 res, err := ec.unmarshalInputRecursiveInputSlice(ctx, v) 7438 return res, graphql.ErrorOnPath(ctx, err) 7439 } 7440 7441 func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) { 7442 res, err := graphql.UnmarshalTime(v) 7443 return res, graphql.ErrorOnPath(ctx, err) 7444 } 7445 7446 func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler { 7447 res := graphql.MarshalTime(v) 7448 if res == graphql.Null { 7449 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 7450 ec.Errorf(ctx, "the requested element is null which the schema does not allow") 7451 } 7452 } 7453 return res 7454 } 7455 7456 func (ec *executionContext) unmarshalNUUID2string(ctx context.Context, v interface{}) (string, error) { 7457 res, err := graphql.UnmarshalString(v) 7458 return res, graphql.ErrorOnPath(ctx, err) 7459 } 7460 7461 func (ec *executionContext) marshalNUUID2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler { 7462 res := graphql.MarshalString(v) 7463 if res == graphql.Null { 7464 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 7465 ec.Errorf(ctx, "the requested element is null which the schema does not allow") 7466 } 7467 } 7468 return res 7469 } 7470 7471 func (ec *executionContext) marshalNUser2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUser(ctx context.Context, sel ast.SelectionSet, v User) graphql.Marshaler { 7472 return ec._User(ctx, sel, &v) 7473 } 7474 7475 func (ec *executionContext) marshalNUser2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUserᚄ(ctx context.Context, sel ast.SelectionSet, v []*User) graphql.Marshaler { 7476 ret := make(graphql.Array, len(v)) 7477 var wg sync.WaitGroup 7478 isLen1 := len(v) == 1 7479 if !isLen1 { 7480 wg.Add(len(v)) 7481 } 7482 for i := range v { 7483 i := i 7484 fc := &graphql.FieldContext{ 7485 Index: &i, 7486 Result: &v[i], 7487 } 7488 ctx := graphql.WithFieldContext(ctx, fc) 7489 f := func(i int) { 7490 defer func() { 7491 if r := recover(); r != nil { 7492 ec.Error(ctx, ec.Recover(ctx, r)) 7493 ret = nil 7494 } 7495 }() 7496 if !isLen1 { 7497 defer wg.Done() 7498 } 7499 ret[i] = ec.marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUser(ctx, sel, v[i]) 7500 } 7501 if isLen1 { 7502 f(i) 7503 } else { 7504 go f(i) 7505 } 7506 7507 } 7508 wg.Wait() 7509 7510 for _, e := range ret { 7511 if e == graphql.Null { 7512 return graphql.Null 7513 } 7514 } 7515 7516 return ret 7517 } 7518 7519 func (ec *executionContext) marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUser(ctx context.Context, sel ast.SelectionSet, v *User) graphql.Marshaler { 7520 if v == nil { 7521 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 7522 ec.Errorf(ctx, "the requested element is null which the schema does not allow") 7523 } 7524 return graphql.Null 7525 } 7526 return ec._User(ctx, sel, v) 7527 } 7528 7529 func (ec *executionContext) marshalOAutobind2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐAutobind(ctx context.Context, sel ast.SelectionSet, v *Autobind) graphql.Marshaler { 7530 if v == nil { 7531 return graphql.Null 7532 } 7533 return ec._Autobind(ctx, sel, v) 7534 } 7535 7536 func (ec *executionContext) unmarshalOChanges2map(ctx context.Context, v interface{}) (map[string]interface{}, error) { 7537 if v == nil { 7538 return nil, nil 7539 } 7540 return v.(map[string]interface{}), nil 7541 } 7542 7543 func (ec *executionContext) marshalOInvalidIdentifier2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋinvalidᚑpackagenameᚐInvalidIdentifier(ctx context.Context, sel ast.SelectionSet, v *invalid_packagename.InvalidIdentifier) graphql.Marshaler { 7544 if v == nil { 7545 return graphql.Null 7546 } 7547 return ec._InvalidIdentifier(ctx, sel, v) 7548 } 7549 7550 func (ec *executionContext) marshalOIt2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋintrospectionᚐIt(ctx context.Context, sel ast.SelectionSet, v *introspection1.It) graphql.Marshaler { 7551 if v == nil { 7552 return graphql.Null 7553 } 7554 return ec._It(ctx, sel, v) 7555 } 7556 7557 func (ec *executionContext) marshalOModelMethods2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐModelMethods(ctx context.Context, sel ast.SelectionSet, v *ModelMethods) graphql.Marshaler { 7558 if v == nil { 7559 return graphql.Null 7560 } 7561 return ec._ModelMethods(ctx, sel, v) 7562 } 7563 7564 func (ec *executionContext) unmarshalOOuterInput2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx context.Context, v interface{}) ([][]*OuterInput, error) { 7565 if v == nil { 7566 return nil, nil 7567 } 7568 var vSlice []interface{} 7569 if v != nil { 7570 vSlice = graphql.CoerceList(v) 7571 } 7572 var err error 7573 res := make([][]*OuterInput, len(vSlice)) 7574 for i := range vSlice { 7575 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i)) 7576 res[i], err = ec.unmarshalOOuterInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx, vSlice[i]) 7577 if err != nil { 7578 return nil, err 7579 } 7580 } 7581 return res, nil 7582 } 7583 7584 func (ec *executionContext) unmarshalOOuterInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx context.Context, v interface{}) ([]*OuterInput, error) { 7585 if v == nil { 7586 return nil, nil 7587 } 7588 var vSlice []interface{} 7589 if v != nil { 7590 vSlice = graphql.CoerceList(v) 7591 } 7592 var err error 7593 res := make([]*OuterInput, len(vSlice)) 7594 for i := range vSlice { 7595 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i)) 7596 res[i], err = ec.unmarshalOOuterInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx, vSlice[i]) 7597 if err != nil { 7598 return nil, err 7599 } 7600 } 7601 return res, nil 7602 } 7603 7604 func (ec *executionContext) unmarshalOOuterInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx context.Context, v interface{}) (*OuterInput, error) { 7605 if v == nil { 7606 return nil, nil 7607 } 7608 res, err := ec.unmarshalInputOuterInput(ctx, v) 7609 return &res, graphql.ErrorOnPath(ctx, err) 7610 } 7611 7612 func (ec *executionContext) marshalOOuterObject2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx context.Context, sel ast.SelectionSet, v [][]*OuterObject) graphql.Marshaler { 7613 if v == nil { 7614 return graphql.Null 7615 } 7616 ret := make(graphql.Array, len(v)) 7617 var wg sync.WaitGroup 7618 isLen1 := len(v) == 1 7619 if !isLen1 { 7620 wg.Add(len(v)) 7621 } 7622 for i := range v { 7623 i := i 7624 fc := &graphql.FieldContext{ 7625 Index: &i, 7626 Result: &v[i], 7627 } 7628 ctx := graphql.WithFieldContext(ctx, fc) 7629 f := func(i int) { 7630 defer func() { 7631 if r := recover(); r != nil { 7632 ec.Error(ctx, ec.Recover(ctx, r)) 7633 ret = nil 7634 } 7635 }() 7636 if !isLen1 { 7637 defer wg.Done() 7638 } 7639 ret[i] = ec.marshalOOuterObject2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx, sel, v[i]) 7640 } 7641 if isLen1 { 7642 f(i) 7643 } else { 7644 go f(i) 7645 } 7646 7647 } 7648 wg.Wait() 7649 7650 return ret 7651 } 7652 7653 func (ec *executionContext) marshalOOuterObject2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx context.Context, sel ast.SelectionSet, v []*OuterObject) graphql.Marshaler { 7654 if v == nil { 7655 return graphql.Null 7656 } 7657 ret := make(graphql.Array, len(v)) 7658 var wg sync.WaitGroup 7659 isLen1 := len(v) == 1 7660 if !isLen1 { 7661 wg.Add(len(v)) 7662 } 7663 for i := range v { 7664 i := i 7665 fc := &graphql.FieldContext{ 7666 Index: &i, 7667 Result: &v[i], 7668 } 7669 ctx := graphql.WithFieldContext(ctx, fc) 7670 f := func(i int) { 7671 defer func() { 7672 if r := recover(); r != nil { 7673 ec.Error(ctx, ec.Recover(ctx, r)) 7674 ret = nil 7675 } 7676 }() 7677 if !isLen1 { 7678 defer wg.Done() 7679 } 7680 ret[i] = ec.marshalOOuterObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx, sel, v[i]) 7681 } 7682 if isLen1 { 7683 f(i) 7684 } else { 7685 go f(i) 7686 } 7687 7688 } 7689 wg.Wait() 7690 7691 return ret 7692 } 7693 7694 func (ec *executionContext) marshalOOuterObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx context.Context, sel ast.SelectionSet, v *OuterObject) graphql.Marshaler { 7695 if v == nil { 7696 return graphql.Null 7697 } 7698 return ec._OuterObject(ctx, sel, v) 7699 } 7700 7701 func (ec *executionContext) marshalOPet2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPetᚄ(ctx context.Context, sel ast.SelectionSet, v []*Pet) graphql.Marshaler { 7702 if v == nil { 7703 return graphql.Null 7704 } 7705 ret := make(graphql.Array, len(v)) 7706 var wg sync.WaitGroup 7707 isLen1 := len(v) == 1 7708 if !isLen1 { 7709 wg.Add(len(v)) 7710 } 7711 for i := range v { 7712 i := i 7713 fc := &graphql.FieldContext{ 7714 Index: &i, 7715 Result: &v[i], 7716 } 7717 ctx := graphql.WithFieldContext(ctx, fc) 7718 f := func(i int) { 7719 defer func() { 7720 if r := recover(); r != nil { 7721 ec.Error(ctx, ec.Recover(ctx, r)) 7722 ret = nil 7723 } 7724 }() 7725 if !isLen1 { 7726 defer wg.Done() 7727 } 7728 ret[i] = ec.marshalNPet2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPet(ctx, sel, v[i]) 7729 } 7730 if isLen1 { 7731 f(i) 7732 } else { 7733 go f(i) 7734 } 7735 7736 } 7737 wg.Wait() 7738 7739 for _, e := range ret { 7740 if e == graphql.Null { 7741 return graphql.Null 7742 } 7743 } 7744 7745 return ret 7746 } 7747 7748 func (ec *executionContext) unmarshalORecursiveInputSlice2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSliceᚄ(ctx context.Context, v interface{}) ([]RecursiveInputSlice, error) { 7749 if v == nil { 7750 return nil, nil 7751 } 7752 var vSlice []interface{} 7753 if v != nil { 7754 vSlice = graphql.CoerceList(v) 7755 } 7756 var err error 7757 res := make([]RecursiveInputSlice, len(vSlice)) 7758 for i := range vSlice { 7759 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i)) 7760 res[i], err = ec.unmarshalNRecursiveInputSlice2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSlice(ctx, vSlice[i]) 7761 if err != nil { 7762 return nil, err 7763 } 7764 } 7765 return res, nil 7766 } 7767 7768 func (ec *executionContext) unmarshalORecursiveInputSlice2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSlice(ctx context.Context, v interface{}) (*RecursiveInputSlice, error) { 7769 if v == nil { 7770 return nil, nil 7771 } 7772 res, err := ec.unmarshalInputRecursiveInputSlice(ctx, v) 7773 return &res, graphql.ErrorOnPath(ctx, err) 7774 } 7775 7776 func (ec *executionContext) unmarshalOThirdParty2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐThirdParty(ctx context.Context, v interface{}) (*ThirdParty, error) { 7777 if v == nil { 7778 return nil, nil 7779 } 7780 res, err := UnmarshalThirdParty(v) 7781 return &res, graphql.ErrorOnPath(ctx, err) 7782 } 7783 7784 func (ec *executionContext) marshalOThirdParty2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐThirdParty(ctx context.Context, sel ast.SelectionSet, v *ThirdParty) graphql.Marshaler { 7785 if v == nil { 7786 return graphql.Null 7787 } 7788 res := MarshalThirdParty(*v) 7789 return res 7790 } 7791 7792 func (ec *executionContext) unmarshalOTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) { 7793 if v == nil { 7794 return nil, nil 7795 } 7796 res, err := graphql.UnmarshalTime(v) 7797 return &res, graphql.ErrorOnPath(ctx, err) 7798 } 7799 7800 func (ec *executionContext) marshalOTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler { 7801 if v == nil { 7802 return graphql.Null 7803 } 7804 res := graphql.MarshalTime(*v) 7805 return res 7806 } 7807 7808 // endregion ***************************** type.gotpl *****************************