github.com/senomas/gqlgen@v0.17.11-0.20220626120754-9aee61b0716a/codegen/testserver/followschema/schema.generated.go (about) 1 // Code generated by github.com/99designs/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/99designs/gqlgen/codegen/testserver/followschema/introspection" 16 invalid_packagename "github.com/99designs/gqlgen/codegen/testserver/followschema/invalid-packagename" 17 "github.com/99designs/gqlgen/codegen/testserver/followschema/otherpkg" 18 "github.com/99designs/gqlgen/graphql" 19 "github.com/99designs/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/99designs/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/99designs/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/99designs/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/99designs/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/99designs/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 for k, v := range asMap { 5449 switch k { 5450 case "id": 5451 var err error 5452 5453 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) 5454 it.ID, err = ec.unmarshalNInt2int(ctx, v) 5455 if err != nil { 5456 return it, err 5457 } 5458 } 5459 } 5460 5461 return it, nil 5462 } 5463 5464 func (ec *executionContext) unmarshalInputOuterInput(ctx context.Context, obj interface{}) (OuterInput, error) { 5465 var it OuterInput 5466 asMap := map[string]interface{}{} 5467 for k, v := range obj.(map[string]interface{}) { 5468 asMap[k] = v 5469 } 5470 5471 for k, v := range asMap { 5472 switch k { 5473 case "inner": 5474 var err error 5475 5476 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("inner")) 5477 it.Inner, err = ec.unmarshalNInnerInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerInput(ctx, v) 5478 if err != nil { 5479 return it, err 5480 } 5481 } 5482 } 5483 5484 return it, nil 5485 } 5486 5487 func (ec *executionContext) unmarshalInputRecursiveInputSlice(ctx context.Context, obj interface{}) (RecursiveInputSlice, error) { 5488 var it RecursiveInputSlice 5489 asMap := map[string]interface{}{} 5490 for k, v := range obj.(map[string]interface{}) { 5491 asMap[k] = v 5492 } 5493 5494 for k, v := range asMap { 5495 switch k { 5496 case "self": 5497 var err error 5498 5499 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("self")) 5500 it.Self, err = ec.unmarshalORecursiveInputSlice2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSliceᚄ(ctx, v) 5501 if err != nil { 5502 return it, err 5503 } 5504 } 5505 } 5506 5507 return it, nil 5508 } 5509 5510 // endregion **************************** input.gotpl ***************************** 5511 5512 // region ************************** interface.gotpl *************************** 5513 5514 // endregion ************************** interface.gotpl *************************** 5515 5516 // region **************************** object.gotpl **************************** 5517 5518 var autobindImplementors = []string{"Autobind"} 5519 5520 func (ec *executionContext) _Autobind(ctx context.Context, sel ast.SelectionSet, obj *Autobind) graphql.Marshaler { 5521 fields := graphql.CollectFields(ec.OperationContext, sel, autobindImplementors) 5522 out := graphql.NewFieldSet(fields) 5523 var invalids uint32 5524 for i, field := range fields { 5525 switch field.Name { 5526 case "__typename": 5527 out.Values[i] = graphql.MarshalString("Autobind") 5528 case "int": 5529 5530 out.Values[i] = ec._Autobind_int(ctx, field, obj) 5531 5532 if out.Values[i] == graphql.Null { 5533 invalids++ 5534 } 5535 case "int32": 5536 5537 out.Values[i] = ec._Autobind_int32(ctx, field, obj) 5538 5539 if out.Values[i] == graphql.Null { 5540 invalids++ 5541 } 5542 case "int64": 5543 5544 out.Values[i] = ec._Autobind_int64(ctx, field, obj) 5545 5546 if out.Values[i] == graphql.Null { 5547 invalids++ 5548 } 5549 case "idStr": 5550 5551 out.Values[i] = ec._Autobind_idStr(ctx, field, obj) 5552 5553 if out.Values[i] == graphql.Null { 5554 invalids++ 5555 } 5556 case "idInt": 5557 5558 out.Values[i] = ec._Autobind_idInt(ctx, field, obj) 5559 5560 if out.Values[i] == graphql.Null { 5561 invalids++ 5562 } 5563 default: 5564 panic("unknown field " + strconv.Quote(field.Name)) 5565 } 5566 } 5567 out.Dispatch() 5568 if invalids > 0 { 5569 return graphql.Null 5570 } 5571 return out 5572 } 5573 5574 var embeddedPointerImplementors = []string{"EmbeddedPointer"} 5575 5576 func (ec *executionContext) _EmbeddedPointer(ctx context.Context, sel ast.SelectionSet, obj *EmbeddedPointerModel) graphql.Marshaler { 5577 fields := graphql.CollectFields(ec.OperationContext, sel, embeddedPointerImplementors) 5578 out := graphql.NewFieldSet(fields) 5579 var invalids uint32 5580 for i, field := range fields { 5581 switch field.Name { 5582 case "__typename": 5583 out.Values[i] = graphql.MarshalString("EmbeddedPointer") 5584 case "ID": 5585 5586 out.Values[i] = ec._EmbeddedPointer_ID(ctx, field, obj) 5587 5588 case "Title": 5589 5590 out.Values[i] = ec._EmbeddedPointer_Title(ctx, field, obj) 5591 5592 default: 5593 panic("unknown field " + strconv.Quote(field.Name)) 5594 } 5595 } 5596 out.Dispatch() 5597 if invalids > 0 { 5598 return graphql.Null 5599 } 5600 return out 5601 } 5602 5603 var forcedResolverImplementors = []string{"ForcedResolver"} 5604 5605 func (ec *executionContext) _ForcedResolver(ctx context.Context, sel ast.SelectionSet, obj *ForcedResolver) graphql.Marshaler { 5606 fields := graphql.CollectFields(ec.OperationContext, sel, forcedResolverImplementors) 5607 out := graphql.NewFieldSet(fields) 5608 var invalids uint32 5609 for i, field := range fields { 5610 switch field.Name { 5611 case "__typename": 5612 out.Values[i] = graphql.MarshalString("ForcedResolver") 5613 case "field": 5614 field := field 5615 5616 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5617 defer func() { 5618 if r := recover(); r != nil { 5619 ec.Error(ctx, ec.Recover(ctx, r)) 5620 } 5621 }() 5622 res = ec._ForcedResolver_field(ctx, field, obj) 5623 return res 5624 } 5625 5626 out.Concurrently(i, func() graphql.Marshaler { 5627 return innerFunc(ctx) 5628 5629 }) 5630 default: 5631 panic("unknown field " + strconv.Quote(field.Name)) 5632 } 5633 } 5634 out.Dispatch() 5635 if invalids > 0 { 5636 return graphql.Null 5637 } 5638 return out 5639 } 5640 5641 var innerObjectImplementors = []string{"InnerObject"} 5642 5643 func (ec *executionContext) _InnerObject(ctx context.Context, sel ast.SelectionSet, obj *InnerObject) graphql.Marshaler { 5644 fields := graphql.CollectFields(ec.OperationContext, sel, innerObjectImplementors) 5645 out := graphql.NewFieldSet(fields) 5646 var invalids uint32 5647 for i, field := range fields { 5648 switch field.Name { 5649 case "__typename": 5650 out.Values[i] = graphql.MarshalString("InnerObject") 5651 case "id": 5652 5653 out.Values[i] = ec._InnerObject_id(ctx, field, obj) 5654 5655 if out.Values[i] == graphql.Null { 5656 invalids++ 5657 } 5658 default: 5659 panic("unknown field " + strconv.Quote(field.Name)) 5660 } 5661 } 5662 out.Dispatch() 5663 if invalids > 0 { 5664 return graphql.Null 5665 } 5666 return out 5667 } 5668 5669 var invalidIdentifierImplementors = []string{"InvalidIdentifier"} 5670 5671 func (ec *executionContext) _InvalidIdentifier(ctx context.Context, sel ast.SelectionSet, obj *invalid_packagename.InvalidIdentifier) graphql.Marshaler { 5672 fields := graphql.CollectFields(ec.OperationContext, sel, invalidIdentifierImplementors) 5673 out := graphql.NewFieldSet(fields) 5674 var invalids uint32 5675 for i, field := range fields { 5676 switch field.Name { 5677 case "__typename": 5678 out.Values[i] = graphql.MarshalString("InvalidIdentifier") 5679 case "id": 5680 5681 out.Values[i] = ec._InvalidIdentifier_id(ctx, field, obj) 5682 5683 if out.Values[i] == graphql.Null { 5684 invalids++ 5685 } 5686 default: 5687 panic("unknown field " + strconv.Quote(field.Name)) 5688 } 5689 } 5690 out.Dispatch() 5691 if invalids > 0 { 5692 return graphql.Null 5693 } 5694 return out 5695 } 5696 5697 var itImplementors = []string{"It"} 5698 5699 func (ec *executionContext) _It(ctx context.Context, sel ast.SelectionSet, obj *introspection1.It) graphql.Marshaler { 5700 fields := graphql.CollectFields(ec.OperationContext, sel, itImplementors) 5701 out := graphql.NewFieldSet(fields) 5702 var invalids uint32 5703 for i, field := range fields { 5704 switch field.Name { 5705 case "__typename": 5706 out.Values[i] = graphql.MarshalString("It") 5707 case "id": 5708 5709 out.Values[i] = ec._It_id(ctx, field, obj) 5710 5711 if out.Values[i] == graphql.Null { 5712 invalids++ 5713 } 5714 default: 5715 panic("unknown field " + strconv.Quote(field.Name)) 5716 } 5717 } 5718 out.Dispatch() 5719 if invalids > 0 { 5720 return graphql.Null 5721 } 5722 return out 5723 } 5724 5725 var modelMethodsImplementors = []string{"ModelMethods"} 5726 5727 func (ec *executionContext) _ModelMethods(ctx context.Context, sel ast.SelectionSet, obj *ModelMethods) graphql.Marshaler { 5728 fields := graphql.CollectFields(ec.OperationContext, sel, modelMethodsImplementors) 5729 out := graphql.NewFieldSet(fields) 5730 var invalids uint32 5731 for i, field := range fields { 5732 switch field.Name { 5733 case "__typename": 5734 out.Values[i] = graphql.MarshalString("ModelMethods") 5735 case "resolverField": 5736 field := field 5737 5738 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5739 defer func() { 5740 if r := recover(); r != nil { 5741 ec.Error(ctx, ec.Recover(ctx, r)) 5742 } 5743 }() 5744 res = ec._ModelMethods_resolverField(ctx, field, obj) 5745 if res == graphql.Null { 5746 atomic.AddUint32(&invalids, 1) 5747 } 5748 return res 5749 } 5750 5751 out.Concurrently(i, func() graphql.Marshaler { 5752 return innerFunc(ctx) 5753 5754 }) 5755 case "noContext": 5756 5757 out.Values[i] = ec._ModelMethods_noContext(ctx, field, obj) 5758 5759 if out.Values[i] == graphql.Null { 5760 atomic.AddUint32(&invalids, 1) 5761 } 5762 case "withContext": 5763 field := field 5764 5765 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5766 defer func() { 5767 if r := recover(); r != nil { 5768 ec.Error(ctx, ec.Recover(ctx, r)) 5769 } 5770 }() 5771 res = ec._ModelMethods_withContext(ctx, field, obj) 5772 if res == graphql.Null { 5773 atomic.AddUint32(&invalids, 1) 5774 } 5775 return res 5776 } 5777 5778 out.Concurrently(i, func() graphql.Marshaler { 5779 return innerFunc(ctx) 5780 5781 }) 5782 default: 5783 panic("unknown field " + strconv.Quote(field.Name)) 5784 } 5785 } 5786 out.Dispatch() 5787 if invalids > 0 { 5788 return graphql.Null 5789 } 5790 return out 5791 } 5792 5793 var outerObjectImplementors = []string{"OuterObject"} 5794 5795 func (ec *executionContext) _OuterObject(ctx context.Context, sel ast.SelectionSet, obj *OuterObject) graphql.Marshaler { 5796 fields := graphql.CollectFields(ec.OperationContext, sel, outerObjectImplementors) 5797 out := graphql.NewFieldSet(fields) 5798 var invalids uint32 5799 for i, field := range fields { 5800 switch field.Name { 5801 case "__typename": 5802 out.Values[i] = graphql.MarshalString("OuterObject") 5803 case "inner": 5804 5805 out.Values[i] = ec._OuterObject_inner(ctx, field, obj) 5806 5807 if out.Values[i] == graphql.Null { 5808 invalids++ 5809 } 5810 default: 5811 panic("unknown field " + strconv.Quote(field.Name)) 5812 } 5813 } 5814 out.Dispatch() 5815 if invalids > 0 { 5816 return graphql.Null 5817 } 5818 return out 5819 } 5820 5821 var petImplementors = []string{"Pet"} 5822 5823 func (ec *executionContext) _Pet(ctx context.Context, sel ast.SelectionSet, obj *Pet) graphql.Marshaler { 5824 fields := graphql.CollectFields(ec.OperationContext, sel, petImplementors) 5825 out := graphql.NewFieldSet(fields) 5826 var invalids uint32 5827 for i, field := range fields { 5828 switch field.Name { 5829 case "__typename": 5830 out.Values[i] = graphql.MarshalString("Pet") 5831 case "id": 5832 5833 out.Values[i] = ec._Pet_id(ctx, field, obj) 5834 5835 if out.Values[i] == graphql.Null { 5836 atomic.AddUint32(&invalids, 1) 5837 } 5838 case "friends": 5839 field := field 5840 5841 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5842 defer func() { 5843 if r := recover(); r != nil { 5844 ec.Error(ctx, ec.Recover(ctx, r)) 5845 } 5846 }() 5847 res = ec._Pet_friends(ctx, field, obj) 5848 return res 5849 } 5850 5851 out.Concurrently(i, func() graphql.Marshaler { 5852 return innerFunc(ctx) 5853 5854 }) 5855 default: 5856 panic("unknown field " + strconv.Quote(field.Name)) 5857 } 5858 } 5859 out.Dispatch() 5860 if invalids > 0 { 5861 return graphql.Null 5862 } 5863 return out 5864 } 5865 5866 var queryImplementors = []string{"Query"} 5867 5868 func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler { 5869 fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors) 5870 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ 5871 Object: "Query", 5872 }) 5873 5874 out := graphql.NewFieldSet(fields) 5875 var invalids uint32 5876 for i, field := range fields { 5877 innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{ 5878 Object: field.Name, 5879 Field: field, 5880 }) 5881 5882 switch field.Name { 5883 case "__typename": 5884 out.Values[i] = graphql.MarshalString("Query") 5885 case "invalidIdentifier": 5886 field := field 5887 5888 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5889 defer func() { 5890 if r := recover(); r != nil { 5891 ec.Error(ctx, ec.Recover(ctx, r)) 5892 } 5893 }() 5894 res = ec._Query_invalidIdentifier(ctx, field) 5895 return res 5896 } 5897 5898 rrm := func(ctx context.Context) graphql.Marshaler { 5899 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 5900 } 5901 5902 out.Concurrently(i, func() graphql.Marshaler { 5903 return rrm(innerCtx) 5904 }) 5905 case "collision": 5906 field := field 5907 5908 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5909 defer func() { 5910 if r := recover(); r != nil { 5911 ec.Error(ctx, ec.Recover(ctx, r)) 5912 } 5913 }() 5914 res = ec._Query_collision(ctx, field) 5915 return res 5916 } 5917 5918 rrm := func(ctx context.Context) graphql.Marshaler { 5919 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 5920 } 5921 5922 out.Concurrently(i, func() graphql.Marshaler { 5923 return rrm(innerCtx) 5924 }) 5925 case "mapInput": 5926 field := field 5927 5928 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5929 defer func() { 5930 if r := recover(); r != nil { 5931 ec.Error(ctx, ec.Recover(ctx, r)) 5932 } 5933 }() 5934 res = ec._Query_mapInput(ctx, field) 5935 return res 5936 } 5937 5938 rrm := func(ctx context.Context) graphql.Marshaler { 5939 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 5940 } 5941 5942 out.Concurrently(i, func() graphql.Marshaler { 5943 return rrm(innerCtx) 5944 }) 5945 case "recursive": 5946 field := field 5947 5948 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5949 defer func() { 5950 if r := recover(); r != nil { 5951 ec.Error(ctx, ec.Recover(ctx, r)) 5952 } 5953 }() 5954 res = ec._Query_recursive(ctx, field) 5955 return res 5956 } 5957 5958 rrm := func(ctx context.Context) graphql.Marshaler { 5959 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 5960 } 5961 5962 out.Concurrently(i, func() graphql.Marshaler { 5963 return rrm(innerCtx) 5964 }) 5965 case "nestedInputs": 5966 field := field 5967 5968 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5969 defer func() { 5970 if r := recover(); r != nil { 5971 ec.Error(ctx, ec.Recover(ctx, r)) 5972 } 5973 }() 5974 res = ec._Query_nestedInputs(ctx, field) 5975 return res 5976 } 5977 5978 rrm := func(ctx context.Context) graphql.Marshaler { 5979 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 5980 } 5981 5982 out.Concurrently(i, func() graphql.Marshaler { 5983 return rrm(innerCtx) 5984 }) 5985 case "nestedOutputs": 5986 field := field 5987 5988 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 5989 defer func() { 5990 if r := recover(); r != nil { 5991 ec.Error(ctx, ec.Recover(ctx, r)) 5992 } 5993 }() 5994 res = ec._Query_nestedOutputs(ctx, field) 5995 return res 5996 } 5997 5998 rrm := func(ctx context.Context) graphql.Marshaler { 5999 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6000 } 6001 6002 out.Concurrently(i, func() graphql.Marshaler { 6003 return rrm(innerCtx) 6004 }) 6005 case "modelMethods": 6006 field := field 6007 6008 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6009 defer func() { 6010 if r := recover(); r != nil { 6011 ec.Error(ctx, ec.Recover(ctx, r)) 6012 } 6013 }() 6014 res = ec._Query_modelMethods(ctx, field) 6015 return res 6016 } 6017 6018 rrm := func(ctx context.Context) graphql.Marshaler { 6019 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6020 } 6021 6022 out.Concurrently(i, func() graphql.Marshaler { 6023 return rrm(innerCtx) 6024 }) 6025 case "user": 6026 field := field 6027 6028 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6029 defer func() { 6030 if r := recover(); r != nil { 6031 ec.Error(ctx, ec.Recover(ctx, r)) 6032 } 6033 }() 6034 res = ec._Query_user(ctx, field) 6035 if res == graphql.Null { 6036 atomic.AddUint32(&invalids, 1) 6037 } 6038 return res 6039 } 6040 6041 rrm := func(ctx context.Context) graphql.Marshaler { 6042 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6043 } 6044 6045 out.Concurrently(i, func() graphql.Marshaler { 6046 return rrm(innerCtx) 6047 }) 6048 case "nullableArg": 6049 field := field 6050 6051 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6052 defer func() { 6053 if r := recover(); r != nil { 6054 ec.Error(ctx, ec.Recover(ctx, r)) 6055 } 6056 }() 6057 res = ec._Query_nullableArg(ctx, field) 6058 return res 6059 } 6060 6061 rrm := func(ctx context.Context) graphql.Marshaler { 6062 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6063 } 6064 6065 out.Concurrently(i, func() graphql.Marshaler { 6066 return rrm(innerCtx) 6067 }) 6068 case "inputSlice": 6069 field := field 6070 6071 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6072 defer func() { 6073 if r := recover(); r != nil { 6074 ec.Error(ctx, ec.Recover(ctx, r)) 6075 } 6076 }() 6077 res = ec._Query_inputSlice(ctx, field) 6078 if res == graphql.Null { 6079 atomic.AddUint32(&invalids, 1) 6080 } 6081 return res 6082 } 6083 6084 rrm := func(ctx context.Context) graphql.Marshaler { 6085 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6086 } 6087 6088 out.Concurrently(i, func() graphql.Marshaler { 6089 return rrm(innerCtx) 6090 }) 6091 case "inputNullableSlice": 6092 field := field 6093 6094 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6095 defer func() { 6096 if r := recover(); r != nil { 6097 ec.Error(ctx, ec.Recover(ctx, r)) 6098 } 6099 }() 6100 res = ec._Query_inputNullableSlice(ctx, field) 6101 if res == graphql.Null { 6102 atomic.AddUint32(&invalids, 1) 6103 } 6104 return res 6105 } 6106 6107 rrm := func(ctx context.Context) graphql.Marshaler { 6108 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6109 } 6110 6111 out.Concurrently(i, func() graphql.Marshaler { 6112 return rrm(innerCtx) 6113 }) 6114 case "shapeUnion": 6115 field := field 6116 6117 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6118 defer func() { 6119 if r := recover(); r != nil { 6120 ec.Error(ctx, ec.Recover(ctx, r)) 6121 } 6122 }() 6123 res = ec._Query_shapeUnion(ctx, field) 6124 if res == graphql.Null { 6125 atomic.AddUint32(&invalids, 1) 6126 } 6127 return res 6128 } 6129 6130 rrm := func(ctx context.Context) graphql.Marshaler { 6131 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6132 } 6133 6134 out.Concurrently(i, func() graphql.Marshaler { 6135 return rrm(innerCtx) 6136 }) 6137 case "autobind": 6138 field := field 6139 6140 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6141 defer func() { 6142 if r := recover(); r != nil { 6143 ec.Error(ctx, ec.Recover(ctx, r)) 6144 } 6145 }() 6146 res = ec._Query_autobind(ctx, field) 6147 return res 6148 } 6149 6150 rrm := func(ctx context.Context) graphql.Marshaler { 6151 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6152 } 6153 6154 out.Concurrently(i, func() graphql.Marshaler { 6155 return rrm(innerCtx) 6156 }) 6157 case "deprecatedField": 6158 field := field 6159 6160 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6161 defer func() { 6162 if r := recover(); r != nil { 6163 ec.Error(ctx, ec.Recover(ctx, r)) 6164 } 6165 }() 6166 res = ec._Query_deprecatedField(ctx, field) 6167 if res == graphql.Null { 6168 atomic.AddUint32(&invalids, 1) 6169 } 6170 return res 6171 } 6172 6173 rrm := func(ctx context.Context) graphql.Marshaler { 6174 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6175 } 6176 6177 out.Concurrently(i, func() graphql.Marshaler { 6178 return rrm(innerCtx) 6179 }) 6180 case "overlapping": 6181 field := field 6182 6183 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6184 defer func() { 6185 if r := recover(); r != nil { 6186 ec.Error(ctx, ec.Recover(ctx, r)) 6187 } 6188 }() 6189 res = ec._Query_overlapping(ctx, field) 6190 return res 6191 } 6192 6193 rrm := func(ctx context.Context) graphql.Marshaler { 6194 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6195 } 6196 6197 out.Concurrently(i, func() graphql.Marshaler { 6198 return rrm(innerCtx) 6199 }) 6200 case "defaultParameters": 6201 field := field 6202 6203 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6204 defer func() { 6205 if r := recover(); r != nil { 6206 ec.Error(ctx, ec.Recover(ctx, r)) 6207 } 6208 }() 6209 res = ec._Query_defaultParameters(ctx, field) 6210 if res == graphql.Null { 6211 atomic.AddUint32(&invalids, 1) 6212 } 6213 return res 6214 } 6215 6216 rrm := func(ctx context.Context) graphql.Marshaler { 6217 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6218 } 6219 6220 out.Concurrently(i, func() graphql.Marshaler { 6221 return rrm(innerCtx) 6222 }) 6223 case "directiveArg": 6224 field := field 6225 6226 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6227 defer func() { 6228 if r := recover(); r != nil { 6229 ec.Error(ctx, ec.Recover(ctx, r)) 6230 } 6231 }() 6232 res = ec._Query_directiveArg(ctx, field) 6233 return res 6234 } 6235 6236 rrm := func(ctx context.Context) graphql.Marshaler { 6237 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6238 } 6239 6240 out.Concurrently(i, func() graphql.Marshaler { 6241 return rrm(innerCtx) 6242 }) 6243 case "directiveNullableArg": 6244 field := field 6245 6246 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6247 defer func() { 6248 if r := recover(); r != nil { 6249 ec.Error(ctx, ec.Recover(ctx, r)) 6250 } 6251 }() 6252 res = ec._Query_directiveNullableArg(ctx, field) 6253 return res 6254 } 6255 6256 rrm := func(ctx context.Context) graphql.Marshaler { 6257 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6258 } 6259 6260 out.Concurrently(i, func() graphql.Marshaler { 6261 return rrm(innerCtx) 6262 }) 6263 case "directiveInputNullable": 6264 field := field 6265 6266 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6267 defer func() { 6268 if r := recover(); r != nil { 6269 ec.Error(ctx, ec.Recover(ctx, r)) 6270 } 6271 }() 6272 res = ec._Query_directiveInputNullable(ctx, field) 6273 return res 6274 } 6275 6276 rrm := func(ctx context.Context) graphql.Marshaler { 6277 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6278 } 6279 6280 out.Concurrently(i, func() graphql.Marshaler { 6281 return rrm(innerCtx) 6282 }) 6283 case "directiveInput": 6284 field := field 6285 6286 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6287 defer func() { 6288 if r := recover(); r != nil { 6289 ec.Error(ctx, ec.Recover(ctx, r)) 6290 } 6291 }() 6292 res = ec._Query_directiveInput(ctx, field) 6293 return res 6294 } 6295 6296 rrm := func(ctx context.Context) graphql.Marshaler { 6297 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6298 } 6299 6300 out.Concurrently(i, func() graphql.Marshaler { 6301 return rrm(innerCtx) 6302 }) 6303 case "directiveInputType": 6304 field := field 6305 6306 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6307 defer func() { 6308 if r := recover(); r != nil { 6309 ec.Error(ctx, ec.Recover(ctx, r)) 6310 } 6311 }() 6312 res = ec._Query_directiveInputType(ctx, field) 6313 return res 6314 } 6315 6316 rrm := func(ctx context.Context) graphql.Marshaler { 6317 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6318 } 6319 6320 out.Concurrently(i, func() graphql.Marshaler { 6321 return rrm(innerCtx) 6322 }) 6323 case "directiveObject": 6324 field := field 6325 6326 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6327 defer func() { 6328 if r := recover(); r != nil { 6329 ec.Error(ctx, ec.Recover(ctx, r)) 6330 } 6331 }() 6332 res = ec._Query_directiveObject(ctx, field) 6333 return res 6334 } 6335 6336 rrm := func(ctx context.Context) graphql.Marshaler { 6337 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6338 } 6339 6340 out.Concurrently(i, func() graphql.Marshaler { 6341 return rrm(innerCtx) 6342 }) 6343 case "directiveObjectWithCustomGoModel": 6344 field := field 6345 6346 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6347 defer func() { 6348 if r := recover(); r != nil { 6349 ec.Error(ctx, ec.Recover(ctx, r)) 6350 } 6351 }() 6352 res = ec._Query_directiveObjectWithCustomGoModel(ctx, field) 6353 return res 6354 } 6355 6356 rrm := func(ctx context.Context) graphql.Marshaler { 6357 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6358 } 6359 6360 out.Concurrently(i, func() graphql.Marshaler { 6361 return rrm(innerCtx) 6362 }) 6363 case "directiveFieldDef": 6364 field := field 6365 6366 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6367 defer func() { 6368 if r := recover(); r != nil { 6369 ec.Error(ctx, ec.Recover(ctx, r)) 6370 } 6371 }() 6372 res = ec._Query_directiveFieldDef(ctx, field) 6373 if res == graphql.Null { 6374 atomic.AddUint32(&invalids, 1) 6375 } 6376 return res 6377 } 6378 6379 rrm := func(ctx context.Context) graphql.Marshaler { 6380 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6381 } 6382 6383 out.Concurrently(i, func() graphql.Marshaler { 6384 return rrm(innerCtx) 6385 }) 6386 case "directiveField": 6387 field := field 6388 6389 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6390 defer func() { 6391 if r := recover(); r != nil { 6392 ec.Error(ctx, ec.Recover(ctx, r)) 6393 } 6394 }() 6395 res = ec._Query_directiveField(ctx, field) 6396 return res 6397 } 6398 6399 rrm := func(ctx context.Context) graphql.Marshaler { 6400 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6401 } 6402 6403 out.Concurrently(i, func() graphql.Marshaler { 6404 return rrm(innerCtx) 6405 }) 6406 case "directiveDouble": 6407 field := field 6408 6409 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6410 defer func() { 6411 if r := recover(); r != nil { 6412 ec.Error(ctx, ec.Recover(ctx, r)) 6413 } 6414 }() 6415 res = ec._Query_directiveDouble(ctx, field) 6416 return res 6417 } 6418 6419 rrm := func(ctx context.Context) graphql.Marshaler { 6420 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6421 } 6422 6423 out.Concurrently(i, func() graphql.Marshaler { 6424 return rrm(innerCtx) 6425 }) 6426 case "directiveUnimplemented": 6427 field := field 6428 6429 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6430 defer func() { 6431 if r := recover(); r != nil { 6432 ec.Error(ctx, ec.Recover(ctx, r)) 6433 } 6434 }() 6435 res = ec._Query_directiveUnimplemented(ctx, field) 6436 return res 6437 } 6438 6439 rrm := func(ctx context.Context) graphql.Marshaler { 6440 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6441 } 6442 6443 out.Concurrently(i, func() graphql.Marshaler { 6444 return rrm(innerCtx) 6445 }) 6446 case "embeddedCase1": 6447 field := field 6448 6449 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6450 defer func() { 6451 if r := recover(); r != nil { 6452 ec.Error(ctx, ec.Recover(ctx, r)) 6453 } 6454 }() 6455 res = ec._Query_embeddedCase1(ctx, field) 6456 return res 6457 } 6458 6459 rrm := func(ctx context.Context) graphql.Marshaler { 6460 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6461 } 6462 6463 out.Concurrently(i, func() graphql.Marshaler { 6464 return rrm(innerCtx) 6465 }) 6466 case "embeddedCase2": 6467 field := field 6468 6469 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6470 defer func() { 6471 if r := recover(); r != nil { 6472 ec.Error(ctx, ec.Recover(ctx, r)) 6473 } 6474 }() 6475 res = ec._Query_embeddedCase2(ctx, field) 6476 return res 6477 } 6478 6479 rrm := func(ctx context.Context) graphql.Marshaler { 6480 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6481 } 6482 6483 out.Concurrently(i, func() graphql.Marshaler { 6484 return rrm(innerCtx) 6485 }) 6486 case "embeddedCase3": 6487 field := field 6488 6489 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6490 defer func() { 6491 if r := recover(); r != nil { 6492 ec.Error(ctx, ec.Recover(ctx, r)) 6493 } 6494 }() 6495 res = ec._Query_embeddedCase3(ctx, field) 6496 return res 6497 } 6498 6499 rrm := func(ctx context.Context) graphql.Marshaler { 6500 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6501 } 6502 6503 out.Concurrently(i, func() graphql.Marshaler { 6504 return rrm(innerCtx) 6505 }) 6506 case "enumInInput": 6507 field := field 6508 6509 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6510 defer func() { 6511 if r := recover(); r != nil { 6512 ec.Error(ctx, ec.Recover(ctx, r)) 6513 } 6514 }() 6515 res = ec._Query_enumInInput(ctx, field) 6516 if res == graphql.Null { 6517 atomic.AddUint32(&invalids, 1) 6518 } 6519 return res 6520 } 6521 6522 rrm := func(ctx context.Context) graphql.Marshaler { 6523 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6524 } 6525 6526 out.Concurrently(i, func() graphql.Marshaler { 6527 return rrm(innerCtx) 6528 }) 6529 case "shapes": 6530 field := field 6531 6532 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6533 defer func() { 6534 if r := recover(); r != nil { 6535 ec.Error(ctx, ec.Recover(ctx, r)) 6536 } 6537 }() 6538 res = ec._Query_shapes(ctx, field) 6539 return res 6540 } 6541 6542 rrm := func(ctx context.Context) graphql.Marshaler { 6543 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6544 } 6545 6546 out.Concurrently(i, func() graphql.Marshaler { 6547 return rrm(innerCtx) 6548 }) 6549 case "noShape": 6550 field := field 6551 6552 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6553 defer func() { 6554 if r := recover(); r != nil { 6555 ec.Error(ctx, ec.Recover(ctx, r)) 6556 } 6557 }() 6558 res = ec._Query_noShape(ctx, field) 6559 return res 6560 } 6561 6562 rrm := func(ctx context.Context) graphql.Marshaler { 6563 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6564 } 6565 6566 out.Concurrently(i, func() graphql.Marshaler { 6567 return rrm(innerCtx) 6568 }) 6569 case "node": 6570 field := field 6571 6572 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6573 defer func() { 6574 if r := recover(); r != nil { 6575 ec.Error(ctx, ec.Recover(ctx, r)) 6576 } 6577 }() 6578 res = ec._Query_node(ctx, field) 6579 if res == graphql.Null { 6580 atomic.AddUint32(&invalids, 1) 6581 } 6582 return res 6583 } 6584 6585 rrm := func(ctx context.Context) graphql.Marshaler { 6586 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6587 } 6588 6589 out.Concurrently(i, func() graphql.Marshaler { 6590 return rrm(innerCtx) 6591 }) 6592 case "noShapeTypedNil": 6593 field := field 6594 6595 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6596 defer func() { 6597 if r := recover(); r != nil { 6598 ec.Error(ctx, ec.Recover(ctx, r)) 6599 } 6600 }() 6601 res = ec._Query_noShapeTypedNil(ctx, field) 6602 return res 6603 } 6604 6605 rrm := func(ctx context.Context) graphql.Marshaler { 6606 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6607 } 6608 6609 out.Concurrently(i, func() graphql.Marshaler { 6610 return rrm(innerCtx) 6611 }) 6612 case "animal": 6613 field := field 6614 6615 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6616 defer func() { 6617 if r := recover(); r != nil { 6618 ec.Error(ctx, ec.Recover(ctx, r)) 6619 } 6620 }() 6621 res = ec._Query_animal(ctx, field) 6622 return res 6623 } 6624 6625 rrm := func(ctx context.Context) graphql.Marshaler { 6626 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6627 } 6628 6629 out.Concurrently(i, func() graphql.Marshaler { 6630 return rrm(innerCtx) 6631 }) 6632 case "notAnInterface": 6633 field := field 6634 6635 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6636 defer func() { 6637 if r := recover(); r != nil { 6638 ec.Error(ctx, ec.Recover(ctx, r)) 6639 } 6640 }() 6641 res = ec._Query_notAnInterface(ctx, field) 6642 return res 6643 } 6644 6645 rrm := func(ctx context.Context) graphql.Marshaler { 6646 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6647 } 6648 6649 out.Concurrently(i, func() graphql.Marshaler { 6650 return rrm(innerCtx) 6651 }) 6652 case "issue896a": 6653 field := field 6654 6655 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6656 defer func() { 6657 if r := recover(); r != nil { 6658 ec.Error(ctx, ec.Recover(ctx, r)) 6659 } 6660 }() 6661 res = ec._Query_issue896a(ctx, field) 6662 return res 6663 } 6664 6665 rrm := func(ctx context.Context) graphql.Marshaler { 6666 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6667 } 6668 6669 out.Concurrently(i, func() graphql.Marshaler { 6670 return rrm(innerCtx) 6671 }) 6672 case "mapStringInterface": 6673 field := field 6674 6675 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6676 defer func() { 6677 if r := recover(); r != nil { 6678 ec.Error(ctx, ec.Recover(ctx, r)) 6679 } 6680 }() 6681 res = ec._Query_mapStringInterface(ctx, field) 6682 return res 6683 } 6684 6685 rrm := func(ctx context.Context) graphql.Marshaler { 6686 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6687 } 6688 6689 out.Concurrently(i, func() graphql.Marshaler { 6690 return rrm(innerCtx) 6691 }) 6692 case "mapNestedStringInterface": 6693 field := field 6694 6695 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6696 defer func() { 6697 if r := recover(); r != nil { 6698 ec.Error(ctx, ec.Recover(ctx, r)) 6699 } 6700 }() 6701 res = ec._Query_mapNestedStringInterface(ctx, field) 6702 return res 6703 } 6704 6705 rrm := func(ctx context.Context) graphql.Marshaler { 6706 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6707 } 6708 6709 out.Concurrently(i, func() graphql.Marshaler { 6710 return rrm(innerCtx) 6711 }) 6712 case "errorBubble": 6713 field := field 6714 6715 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6716 defer func() { 6717 if r := recover(); r != nil { 6718 ec.Error(ctx, ec.Recover(ctx, r)) 6719 } 6720 }() 6721 res = ec._Query_errorBubble(ctx, field) 6722 return res 6723 } 6724 6725 rrm := func(ctx context.Context) graphql.Marshaler { 6726 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6727 } 6728 6729 out.Concurrently(i, func() graphql.Marshaler { 6730 return rrm(innerCtx) 6731 }) 6732 case "errorBubbleList": 6733 field := field 6734 6735 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6736 defer func() { 6737 if r := recover(); r != nil { 6738 ec.Error(ctx, ec.Recover(ctx, r)) 6739 } 6740 }() 6741 res = ec._Query_errorBubbleList(ctx, field) 6742 return res 6743 } 6744 6745 rrm := func(ctx context.Context) graphql.Marshaler { 6746 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6747 } 6748 6749 out.Concurrently(i, func() graphql.Marshaler { 6750 return rrm(innerCtx) 6751 }) 6752 case "errorList": 6753 field := field 6754 6755 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6756 defer func() { 6757 if r := recover(); r != nil { 6758 ec.Error(ctx, ec.Recover(ctx, r)) 6759 } 6760 }() 6761 res = ec._Query_errorList(ctx, field) 6762 return res 6763 } 6764 6765 rrm := func(ctx context.Context) graphql.Marshaler { 6766 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6767 } 6768 6769 out.Concurrently(i, func() graphql.Marshaler { 6770 return rrm(innerCtx) 6771 }) 6772 case "errors": 6773 field := field 6774 6775 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6776 defer func() { 6777 if r := recover(); r != nil { 6778 ec.Error(ctx, ec.Recover(ctx, r)) 6779 } 6780 }() 6781 res = ec._Query_errors(ctx, field) 6782 return res 6783 } 6784 6785 rrm := func(ctx context.Context) graphql.Marshaler { 6786 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6787 } 6788 6789 out.Concurrently(i, func() graphql.Marshaler { 6790 return rrm(innerCtx) 6791 }) 6792 case "valid": 6793 field := field 6794 6795 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6796 defer func() { 6797 if r := recover(); r != nil { 6798 ec.Error(ctx, ec.Recover(ctx, r)) 6799 } 6800 }() 6801 res = ec._Query_valid(ctx, field) 6802 if res == graphql.Null { 6803 atomic.AddUint32(&invalids, 1) 6804 } 6805 return res 6806 } 6807 6808 rrm := func(ctx context.Context) graphql.Marshaler { 6809 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6810 } 6811 6812 out.Concurrently(i, func() graphql.Marshaler { 6813 return rrm(innerCtx) 6814 }) 6815 case "panics": 6816 field := field 6817 6818 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6819 defer func() { 6820 if r := recover(); r != nil { 6821 ec.Error(ctx, ec.Recover(ctx, r)) 6822 } 6823 }() 6824 res = ec._Query_panics(ctx, field) 6825 return res 6826 } 6827 6828 rrm := func(ctx context.Context) graphql.Marshaler { 6829 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6830 } 6831 6832 out.Concurrently(i, func() graphql.Marshaler { 6833 return rrm(innerCtx) 6834 }) 6835 case "primitiveObject": 6836 field := field 6837 6838 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6839 defer func() { 6840 if r := recover(); r != nil { 6841 ec.Error(ctx, ec.Recover(ctx, r)) 6842 } 6843 }() 6844 res = ec._Query_primitiveObject(ctx, field) 6845 if res == graphql.Null { 6846 atomic.AddUint32(&invalids, 1) 6847 } 6848 return res 6849 } 6850 6851 rrm := func(ctx context.Context) graphql.Marshaler { 6852 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6853 } 6854 6855 out.Concurrently(i, func() graphql.Marshaler { 6856 return rrm(innerCtx) 6857 }) 6858 case "primitiveStringObject": 6859 field := field 6860 6861 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6862 defer func() { 6863 if r := recover(); r != nil { 6864 ec.Error(ctx, ec.Recover(ctx, r)) 6865 } 6866 }() 6867 res = ec._Query_primitiveStringObject(ctx, field) 6868 if res == graphql.Null { 6869 atomic.AddUint32(&invalids, 1) 6870 } 6871 return res 6872 } 6873 6874 rrm := func(ctx context.Context) graphql.Marshaler { 6875 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6876 } 6877 6878 out.Concurrently(i, func() graphql.Marshaler { 6879 return rrm(innerCtx) 6880 }) 6881 case "ptrToSliceContainer": 6882 field := field 6883 6884 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6885 defer func() { 6886 if r := recover(); r != nil { 6887 ec.Error(ctx, ec.Recover(ctx, r)) 6888 } 6889 }() 6890 res = ec._Query_ptrToSliceContainer(ctx, field) 6891 if res == graphql.Null { 6892 atomic.AddUint32(&invalids, 1) 6893 } 6894 return res 6895 } 6896 6897 rrm := func(ctx context.Context) graphql.Marshaler { 6898 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6899 } 6900 6901 out.Concurrently(i, func() graphql.Marshaler { 6902 return rrm(innerCtx) 6903 }) 6904 case "infinity": 6905 field := field 6906 6907 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6908 defer func() { 6909 if r := recover(); r != nil { 6910 ec.Error(ctx, ec.Recover(ctx, r)) 6911 } 6912 }() 6913 res = ec._Query_infinity(ctx, field) 6914 if res == graphql.Null { 6915 atomic.AddUint32(&invalids, 1) 6916 } 6917 return res 6918 } 6919 6920 rrm := func(ctx context.Context) graphql.Marshaler { 6921 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6922 } 6923 6924 out.Concurrently(i, func() graphql.Marshaler { 6925 return rrm(innerCtx) 6926 }) 6927 case "stringFromContextInterface": 6928 field := field 6929 6930 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6931 defer func() { 6932 if r := recover(); r != nil { 6933 ec.Error(ctx, ec.Recover(ctx, r)) 6934 } 6935 }() 6936 res = ec._Query_stringFromContextInterface(ctx, field) 6937 if res == graphql.Null { 6938 atomic.AddUint32(&invalids, 1) 6939 } 6940 return res 6941 } 6942 6943 rrm := func(ctx context.Context) graphql.Marshaler { 6944 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6945 } 6946 6947 out.Concurrently(i, func() graphql.Marshaler { 6948 return rrm(innerCtx) 6949 }) 6950 case "stringFromContextFunction": 6951 field := field 6952 6953 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6954 defer func() { 6955 if r := recover(); r != nil { 6956 ec.Error(ctx, ec.Recover(ctx, r)) 6957 } 6958 }() 6959 res = ec._Query_stringFromContextFunction(ctx, field) 6960 if res == graphql.Null { 6961 atomic.AddUint32(&invalids, 1) 6962 } 6963 return res 6964 } 6965 6966 rrm := func(ctx context.Context) graphql.Marshaler { 6967 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6968 } 6969 6970 out.Concurrently(i, func() graphql.Marshaler { 6971 return rrm(innerCtx) 6972 }) 6973 case "defaultScalar": 6974 field := field 6975 6976 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 6977 defer func() { 6978 if r := recover(); r != nil { 6979 ec.Error(ctx, ec.Recover(ctx, r)) 6980 } 6981 }() 6982 res = ec._Query_defaultScalar(ctx, field) 6983 if res == graphql.Null { 6984 atomic.AddUint32(&invalids, 1) 6985 } 6986 return res 6987 } 6988 6989 rrm := func(ctx context.Context) graphql.Marshaler { 6990 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 6991 } 6992 6993 out.Concurrently(i, func() graphql.Marshaler { 6994 return rrm(innerCtx) 6995 }) 6996 case "slices": 6997 field := field 6998 6999 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7000 defer func() { 7001 if r := recover(); r != nil { 7002 ec.Error(ctx, ec.Recover(ctx, r)) 7003 } 7004 }() 7005 res = ec._Query_slices(ctx, field) 7006 return res 7007 } 7008 7009 rrm := func(ctx context.Context) graphql.Marshaler { 7010 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7011 } 7012 7013 out.Concurrently(i, func() graphql.Marshaler { 7014 return rrm(innerCtx) 7015 }) 7016 case "scalarSlice": 7017 field := field 7018 7019 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7020 defer func() { 7021 if r := recover(); r != nil { 7022 ec.Error(ctx, ec.Recover(ctx, r)) 7023 } 7024 }() 7025 res = ec._Query_scalarSlice(ctx, field) 7026 if res == graphql.Null { 7027 atomic.AddUint32(&invalids, 1) 7028 } 7029 return res 7030 } 7031 7032 rrm := func(ctx context.Context) graphql.Marshaler { 7033 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7034 } 7035 7036 out.Concurrently(i, func() graphql.Marshaler { 7037 return rrm(innerCtx) 7038 }) 7039 case "fallback": 7040 field := field 7041 7042 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7043 defer func() { 7044 if r := recover(); r != nil { 7045 ec.Error(ctx, ec.Recover(ctx, r)) 7046 } 7047 }() 7048 res = ec._Query_fallback(ctx, field) 7049 if res == graphql.Null { 7050 atomic.AddUint32(&invalids, 1) 7051 } 7052 return res 7053 } 7054 7055 rrm := func(ctx context.Context) graphql.Marshaler { 7056 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7057 } 7058 7059 out.Concurrently(i, func() graphql.Marshaler { 7060 return rrm(innerCtx) 7061 }) 7062 case "optionalUnion": 7063 field := field 7064 7065 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7066 defer func() { 7067 if r := recover(); r != nil { 7068 ec.Error(ctx, ec.Recover(ctx, r)) 7069 } 7070 }() 7071 res = ec._Query_optionalUnion(ctx, field) 7072 return res 7073 } 7074 7075 rrm := func(ctx context.Context) graphql.Marshaler { 7076 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7077 } 7078 7079 out.Concurrently(i, func() graphql.Marshaler { 7080 return rrm(innerCtx) 7081 }) 7082 case "vOkCaseValue": 7083 field := field 7084 7085 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7086 defer func() { 7087 if r := recover(); r != nil { 7088 ec.Error(ctx, ec.Recover(ctx, r)) 7089 } 7090 }() 7091 res = ec._Query_vOkCaseValue(ctx, field) 7092 return res 7093 } 7094 7095 rrm := func(ctx context.Context) graphql.Marshaler { 7096 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7097 } 7098 7099 out.Concurrently(i, func() graphql.Marshaler { 7100 return rrm(innerCtx) 7101 }) 7102 case "vOkCaseNil": 7103 field := field 7104 7105 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7106 defer func() { 7107 if r := recover(); r != nil { 7108 ec.Error(ctx, ec.Recover(ctx, r)) 7109 } 7110 }() 7111 res = ec._Query_vOkCaseNil(ctx, field) 7112 return res 7113 } 7114 7115 rrm := func(ctx context.Context) graphql.Marshaler { 7116 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7117 } 7118 7119 out.Concurrently(i, func() graphql.Marshaler { 7120 return rrm(innerCtx) 7121 }) 7122 case "validType": 7123 field := field 7124 7125 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7126 defer func() { 7127 if r := recover(); r != nil { 7128 ec.Error(ctx, ec.Recover(ctx, r)) 7129 } 7130 }() 7131 res = ec._Query_validType(ctx, field) 7132 return res 7133 } 7134 7135 rrm := func(ctx context.Context) graphql.Marshaler { 7136 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7137 } 7138 7139 out.Concurrently(i, func() graphql.Marshaler { 7140 return rrm(innerCtx) 7141 }) 7142 case "variadicModel": 7143 field := field 7144 7145 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7146 defer func() { 7147 if r := recover(); r != nil { 7148 ec.Error(ctx, ec.Recover(ctx, r)) 7149 } 7150 }() 7151 res = ec._Query_variadicModel(ctx, field) 7152 return res 7153 } 7154 7155 rrm := func(ctx context.Context) graphql.Marshaler { 7156 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7157 } 7158 7159 out.Concurrently(i, func() graphql.Marshaler { 7160 return rrm(innerCtx) 7161 }) 7162 case "wrappedStruct": 7163 field := field 7164 7165 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7166 defer func() { 7167 if r := recover(); r != nil { 7168 ec.Error(ctx, ec.Recover(ctx, r)) 7169 } 7170 }() 7171 res = ec._Query_wrappedStruct(ctx, field) 7172 if res == graphql.Null { 7173 atomic.AddUint32(&invalids, 1) 7174 } 7175 return res 7176 } 7177 7178 rrm := func(ctx context.Context) graphql.Marshaler { 7179 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7180 } 7181 7182 out.Concurrently(i, func() graphql.Marshaler { 7183 return rrm(innerCtx) 7184 }) 7185 case "wrappedScalar": 7186 field := field 7187 7188 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7189 defer func() { 7190 if r := recover(); r != nil { 7191 ec.Error(ctx, ec.Recover(ctx, r)) 7192 } 7193 }() 7194 res = ec._Query_wrappedScalar(ctx, field) 7195 if res == graphql.Null { 7196 atomic.AddUint32(&invalids, 1) 7197 } 7198 return res 7199 } 7200 7201 rrm := func(ctx context.Context) graphql.Marshaler { 7202 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7203 } 7204 7205 out.Concurrently(i, func() graphql.Marshaler { 7206 return rrm(innerCtx) 7207 }) 7208 case "wrappedMap": 7209 field := field 7210 7211 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7212 defer func() { 7213 if r := recover(); r != nil { 7214 ec.Error(ctx, ec.Recover(ctx, r)) 7215 } 7216 }() 7217 res = ec._Query_wrappedMap(ctx, field) 7218 if res == graphql.Null { 7219 atomic.AddUint32(&invalids, 1) 7220 } 7221 return res 7222 } 7223 7224 rrm := func(ctx context.Context) graphql.Marshaler { 7225 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7226 } 7227 7228 out.Concurrently(i, func() graphql.Marshaler { 7229 return rrm(innerCtx) 7230 }) 7231 case "wrappedSlice": 7232 field := field 7233 7234 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7235 defer func() { 7236 if r := recover(); r != nil { 7237 ec.Error(ctx, ec.Recover(ctx, r)) 7238 } 7239 }() 7240 res = ec._Query_wrappedSlice(ctx, field) 7241 if res == graphql.Null { 7242 atomic.AddUint32(&invalids, 1) 7243 } 7244 return res 7245 } 7246 7247 rrm := func(ctx context.Context) graphql.Marshaler { 7248 return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc) 7249 } 7250 7251 out.Concurrently(i, func() graphql.Marshaler { 7252 return rrm(innerCtx) 7253 }) 7254 case "__type": 7255 7256 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { 7257 return ec._Query___type(ctx, field) 7258 }) 7259 7260 case "__schema": 7261 7262 out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { 7263 return ec._Query___schema(ctx, field) 7264 }) 7265 7266 default: 7267 panic("unknown field " + strconv.Quote(field.Name)) 7268 } 7269 } 7270 out.Dispatch() 7271 if invalids > 0 { 7272 return graphql.Null 7273 } 7274 return out 7275 } 7276 7277 var subscriptionImplementors = []string{"Subscription"} 7278 7279 func (ec *executionContext) _Subscription(ctx context.Context, sel ast.SelectionSet) func(ctx context.Context) graphql.Marshaler { 7280 fields := graphql.CollectFields(ec.OperationContext, sel, subscriptionImplementors) 7281 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ 7282 Object: "Subscription", 7283 }) 7284 if len(fields) != 1 { 7285 ec.Errorf(ctx, "must subscribe to exactly one stream") 7286 return nil 7287 } 7288 7289 switch fields[0].Name { 7290 case "updated": 7291 return ec._Subscription_updated(ctx, fields[0]) 7292 case "initPayload": 7293 return ec._Subscription_initPayload(ctx, fields[0]) 7294 case "directiveArg": 7295 return ec._Subscription_directiveArg(ctx, fields[0]) 7296 case "directiveNullableArg": 7297 return ec._Subscription_directiveNullableArg(ctx, fields[0]) 7298 case "directiveDouble": 7299 return ec._Subscription_directiveDouble(ctx, fields[0]) 7300 case "directiveUnimplemented": 7301 return ec._Subscription_directiveUnimplemented(ctx, fields[0]) 7302 case "issue896b": 7303 return ec._Subscription_issue896b(ctx, fields[0]) 7304 case "errorRequired": 7305 return ec._Subscription_errorRequired(ctx, fields[0]) 7306 default: 7307 panic("unknown field " + strconv.Quote(fields[0].Name)) 7308 } 7309 } 7310 7311 var userImplementors = []string{"User"} 7312 7313 func (ec *executionContext) _User(ctx context.Context, sel ast.SelectionSet, obj *User) graphql.Marshaler { 7314 fields := graphql.CollectFields(ec.OperationContext, sel, userImplementors) 7315 out := graphql.NewFieldSet(fields) 7316 var invalids uint32 7317 for i, field := range fields { 7318 switch field.Name { 7319 case "__typename": 7320 out.Values[i] = graphql.MarshalString("User") 7321 case "id": 7322 7323 out.Values[i] = ec._User_id(ctx, field, obj) 7324 7325 if out.Values[i] == graphql.Null { 7326 atomic.AddUint32(&invalids, 1) 7327 } 7328 case "friends": 7329 field := field 7330 7331 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7332 defer func() { 7333 if r := recover(); r != nil { 7334 ec.Error(ctx, ec.Recover(ctx, r)) 7335 } 7336 }() 7337 res = ec._User_friends(ctx, field, obj) 7338 if res == graphql.Null { 7339 atomic.AddUint32(&invalids, 1) 7340 } 7341 return res 7342 } 7343 7344 out.Concurrently(i, func() graphql.Marshaler { 7345 return innerFunc(ctx) 7346 7347 }) 7348 case "created": 7349 7350 out.Values[i] = ec._User_created(ctx, field, obj) 7351 7352 if out.Values[i] == graphql.Null { 7353 atomic.AddUint32(&invalids, 1) 7354 } 7355 case "updated": 7356 7357 out.Values[i] = ec._User_updated(ctx, field, obj) 7358 7359 case "pets": 7360 field := field 7361 7362 innerFunc := func(ctx context.Context) (res graphql.Marshaler) { 7363 defer func() { 7364 if r := recover(); r != nil { 7365 ec.Error(ctx, ec.Recover(ctx, r)) 7366 } 7367 }() 7368 res = ec._User_pets(ctx, field, obj) 7369 return res 7370 } 7371 7372 out.Concurrently(i, func() graphql.Marshaler { 7373 return innerFunc(ctx) 7374 7375 }) 7376 default: 7377 panic("unknown field " + strconv.Quote(field.Name)) 7378 } 7379 } 7380 out.Dispatch() 7381 if invalids > 0 { 7382 return graphql.Null 7383 } 7384 return out 7385 } 7386 7387 // endregion **************************** object.gotpl **************************** 7388 7389 // region ***************************** type.gotpl ***************************** 7390 7391 func (ec *executionContext) unmarshalNInnerInput2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerInput(ctx context.Context, v interface{}) (InnerInput, error) { 7392 res, err := ec.unmarshalInputInnerInput(ctx, v) 7393 return res, graphql.ErrorOnPath(ctx, err) 7394 } 7395 7396 func (ec *executionContext) unmarshalNInnerInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerInput(ctx context.Context, v interface{}) (*InnerInput, error) { 7397 res, err := ec.unmarshalInputInnerInput(ctx, v) 7398 return &res, graphql.ErrorOnPath(ctx, err) 7399 } 7400 7401 func (ec *executionContext) marshalNInnerObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐInnerObject(ctx context.Context, sel ast.SelectionSet, v *InnerObject) graphql.Marshaler { 7402 if v == nil { 7403 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 7404 ec.Errorf(ctx, "the requested element is null which the schema does not allow") 7405 } 7406 return graphql.Null 7407 } 7408 return ec._InnerObject(ctx, sel, v) 7409 } 7410 7411 func (ec *executionContext) marshalNPet2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPet(ctx context.Context, sel ast.SelectionSet, v *Pet) graphql.Marshaler { 7412 if v == nil { 7413 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 7414 ec.Errorf(ctx, "the requested element is null which the schema does not allow") 7415 } 7416 return graphql.Null 7417 } 7418 return ec._Pet(ctx, sel, v) 7419 } 7420 7421 func (ec *executionContext) unmarshalNRecursiveInputSlice2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSlice(ctx context.Context, v interface{}) (RecursiveInputSlice, error) { 7422 res, err := ec.unmarshalInputRecursiveInputSlice(ctx, v) 7423 return res, graphql.ErrorOnPath(ctx, err) 7424 } 7425 7426 func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) { 7427 res, err := graphql.UnmarshalTime(v) 7428 return res, graphql.ErrorOnPath(ctx, err) 7429 } 7430 7431 func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler { 7432 res := graphql.MarshalTime(v) 7433 if res == graphql.Null { 7434 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 7435 ec.Errorf(ctx, "the requested element is null which the schema does not allow") 7436 } 7437 } 7438 return res 7439 } 7440 7441 func (ec *executionContext) unmarshalNUUID2string(ctx context.Context, v interface{}) (string, error) { 7442 res, err := graphql.UnmarshalString(v) 7443 return res, graphql.ErrorOnPath(ctx, err) 7444 } 7445 7446 func (ec *executionContext) marshalNUUID2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler { 7447 res := graphql.MarshalString(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) marshalNUser2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUser(ctx context.Context, sel ast.SelectionSet, v User) graphql.Marshaler { 7457 return ec._User(ctx, sel, &v) 7458 } 7459 7460 func (ec *executionContext) marshalNUser2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUserᚄ(ctx context.Context, sel ast.SelectionSet, v []*User) graphql.Marshaler { 7461 ret := make(graphql.Array, len(v)) 7462 var wg sync.WaitGroup 7463 isLen1 := len(v) == 1 7464 if !isLen1 { 7465 wg.Add(len(v)) 7466 } 7467 for i := range v { 7468 i := i 7469 fc := &graphql.FieldContext{ 7470 Index: &i, 7471 Result: &v[i], 7472 } 7473 ctx := graphql.WithFieldContext(ctx, fc) 7474 f := func(i int) { 7475 defer func() { 7476 if r := recover(); r != nil { 7477 ec.Error(ctx, ec.Recover(ctx, r)) 7478 ret = nil 7479 } 7480 }() 7481 if !isLen1 { 7482 defer wg.Done() 7483 } 7484 ret[i] = ec.marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUser(ctx, sel, v[i]) 7485 } 7486 if isLen1 { 7487 f(i) 7488 } else { 7489 go f(i) 7490 } 7491 7492 } 7493 wg.Wait() 7494 7495 for _, e := range ret { 7496 if e == graphql.Null { 7497 return graphql.Null 7498 } 7499 } 7500 7501 return ret 7502 } 7503 7504 func (ec *executionContext) marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐUser(ctx context.Context, sel ast.SelectionSet, v *User) graphql.Marshaler { 7505 if v == nil { 7506 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 7507 ec.Errorf(ctx, "the requested element is null which the schema does not allow") 7508 } 7509 return graphql.Null 7510 } 7511 return ec._User(ctx, sel, v) 7512 } 7513 7514 func (ec *executionContext) marshalOAutobind2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐAutobind(ctx context.Context, sel ast.SelectionSet, v *Autobind) graphql.Marshaler { 7515 if v == nil { 7516 return graphql.Null 7517 } 7518 return ec._Autobind(ctx, sel, v) 7519 } 7520 7521 func (ec *executionContext) unmarshalOChanges2map(ctx context.Context, v interface{}) (map[string]interface{}, error) { 7522 if v == nil { 7523 return nil, nil 7524 } 7525 return v.(map[string]interface{}), nil 7526 } 7527 7528 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 { 7529 if v == nil { 7530 return graphql.Null 7531 } 7532 return ec._InvalidIdentifier(ctx, sel, v) 7533 } 7534 7535 func (ec *executionContext) marshalOIt2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚋintrospectionᚐIt(ctx context.Context, sel ast.SelectionSet, v *introspection1.It) graphql.Marshaler { 7536 if v == nil { 7537 return graphql.Null 7538 } 7539 return ec._It(ctx, sel, v) 7540 } 7541 7542 func (ec *executionContext) marshalOModelMethods2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐModelMethods(ctx context.Context, sel ast.SelectionSet, v *ModelMethods) graphql.Marshaler { 7543 if v == nil { 7544 return graphql.Null 7545 } 7546 return ec._ModelMethods(ctx, sel, v) 7547 } 7548 7549 func (ec *executionContext) unmarshalOOuterInput2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx context.Context, v interface{}) ([][]*OuterInput, error) { 7550 if v == nil { 7551 return nil, nil 7552 } 7553 var vSlice []interface{} 7554 if v != nil { 7555 vSlice = graphql.CoerceList(v) 7556 } 7557 var err error 7558 res := make([][]*OuterInput, len(vSlice)) 7559 for i := range vSlice { 7560 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i)) 7561 res[i], err = ec.unmarshalOOuterInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx, vSlice[i]) 7562 if err != nil { 7563 return nil, err 7564 } 7565 } 7566 return res, nil 7567 } 7568 7569 func (ec *executionContext) unmarshalOOuterInput2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx context.Context, v interface{}) ([]*OuterInput, error) { 7570 if v == nil { 7571 return nil, nil 7572 } 7573 var vSlice []interface{} 7574 if v != nil { 7575 vSlice = graphql.CoerceList(v) 7576 } 7577 var err error 7578 res := make([]*OuterInput, len(vSlice)) 7579 for i := range vSlice { 7580 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i)) 7581 res[i], err = ec.unmarshalOOuterInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx, vSlice[i]) 7582 if err != nil { 7583 return nil, err 7584 } 7585 } 7586 return res, nil 7587 } 7588 7589 func (ec *executionContext) unmarshalOOuterInput2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterInput(ctx context.Context, v interface{}) (*OuterInput, error) { 7590 if v == nil { 7591 return nil, nil 7592 } 7593 res, err := ec.unmarshalInputOuterInput(ctx, v) 7594 return &res, graphql.ErrorOnPath(ctx, err) 7595 } 7596 7597 func (ec *executionContext) marshalOOuterObject2ᚕᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx context.Context, sel ast.SelectionSet, v [][]*OuterObject) graphql.Marshaler { 7598 if v == nil { 7599 return graphql.Null 7600 } 7601 ret := make(graphql.Array, len(v)) 7602 var wg sync.WaitGroup 7603 isLen1 := len(v) == 1 7604 if !isLen1 { 7605 wg.Add(len(v)) 7606 } 7607 for i := range v { 7608 i := i 7609 fc := &graphql.FieldContext{ 7610 Index: &i, 7611 Result: &v[i], 7612 } 7613 ctx := graphql.WithFieldContext(ctx, fc) 7614 f := func(i int) { 7615 defer func() { 7616 if r := recover(); r != nil { 7617 ec.Error(ctx, ec.Recover(ctx, r)) 7618 ret = nil 7619 } 7620 }() 7621 if !isLen1 { 7622 defer wg.Done() 7623 } 7624 ret[i] = ec.marshalOOuterObject2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx, sel, v[i]) 7625 } 7626 if isLen1 { 7627 f(i) 7628 } else { 7629 go f(i) 7630 } 7631 7632 } 7633 wg.Wait() 7634 7635 return ret 7636 } 7637 7638 func (ec *executionContext) marshalOOuterObject2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx context.Context, sel ast.SelectionSet, v []*OuterObject) graphql.Marshaler { 7639 if v == nil { 7640 return graphql.Null 7641 } 7642 ret := make(graphql.Array, len(v)) 7643 var wg sync.WaitGroup 7644 isLen1 := len(v) == 1 7645 if !isLen1 { 7646 wg.Add(len(v)) 7647 } 7648 for i := range v { 7649 i := i 7650 fc := &graphql.FieldContext{ 7651 Index: &i, 7652 Result: &v[i], 7653 } 7654 ctx := graphql.WithFieldContext(ctx, fc) 7655 f := func(i int) { 7656 defer func() { 7657 if r := recover(); r != nil { 7658 ec.Error(ctx, ec.Recover(ctx, r)) 7659 ret = nil 7660 } 7661 }() 7662 if !isLen1 { 7663 defer wg.Done() 7664 } 7665 ret[i] = ec.marshalOOuterObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx, sel, v[i]) 7666 } 7667 if isLen1 { 7668 f(i) 7669 } else { 7670 go f(i) 7671 } 7672 7673 } 7674 wg.Wait() 7675 7676 return ret 7677 } 7678 7679 func (ec *executionContext) marshalOOuterObject2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐOuterObject(ctx context.Context, sel ast.SelectionSet, v *OuterObject) graphql.Marshaler { 7680 if v == nil { 7681 return graphql.Null 7682 } 7683 return ec._OuterObject(ctx, sel, v) 7684 } 7685 7686 func (ec *executionContext) marshalOPet2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPetᚄ(ctx context.Context, sel ast.SelectionSet, v []*Pet) graphql.Marshaler { 7687 if v == nil { 7688 return graphql.Null 7689 } 7690 ret := make(graphql.Array, len(v)) 7691 var wg sync.WaitGroup 7692 isLen1 := len(v) == 1 7693 if !isLen1 { 7694 wg.Add(len(v)) 7695 } 7696 for i := range v { 7697 i := i 7698 fc := &graphql.FieldContext{ 7699 Index: &i, 7700 Result: &v[i], 7701 } 7702 ctx := graphql.WithFieldContext(ctx, fc) 7703 f := func(i int) { 7704 defer func() { 7705 if r := recover(); r != nil { 7706 ec.Error(ctx, ec.Recover(ctx, r)) 7707 ret = nil 7708 } 7709 }() 7710 if !isLen1 { 7711 defer wg.Done() 7712 } 7713 ret[i] = ec.marshalNPet2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐPet(ctx, sel, v[i]) 7714 } 7715 if isLen1 { 7716 f(i) 7717 } else { 7718 go f(i) 7719 } 7720 7721 } 7722 wg.Wait() 7723 7724 for _, e := range ret { 7725 if e == graphql.Null { 7726 return graphql.Null 7727 } 7728 } 7729 7730 return ret 7731 } 7732 7733 func (ec *executionContext) unmarshalORecursiveInputSlice2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSliceᚄ(ctx context.Context, v interface{}) ([]RecursiveInputSlice, error) { 7734 if v == nil { 7735 return nil, nil 7736 } 7737 var vSlice []interface{} 7738 if v != nil { 7739 vSlice = graphql.CoerceList(v) 7740 } 7741 var err error 7742 res := make([]RecursiveInputSlice, len(vSlice)) 7743 for i := range vSlice { 7744 ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i)) 7745 res[i], err = ec.unmarshalNRecursiveInputSlice2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSlice(ctx, vSlice[i]) 7746 if err != nil { 7747 return nil, err 7748 } 7749 } 7750 return res, nil 7751 } 7752 7753 func (ec *executionContext) unmarshalORecursiveInputSlice2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐRecursiveInputSlice(ctx context.Context, v interface{}) (*RecursiveInputSlice, error) { 7754 if v == nil { 7755 return nil, nil 7756 } 7757 res, err := ec.unmarshalInputRecursiveInputSlice(ctx, v) 7758 return &res, graphql.ErrorOnPath(ctx, err) 7759 } 7760 7761 func (ec *executionContext) unmarshalOThirdParty2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐThirdParty(ctx context.Context, v interface{}) (*ThirdParty, error) { 7762 if v == nil { 7763 return nil, nil 7764 } 7765 res, err := UnmarshalThirdParty(v) 7766 return &res, graphql.ErrorOnPath(ctx, err) 7767 } 7768 7769 func (ec *executionContext) marshalOThirdParty2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚋfollowschemaᚐThirdParty(ctx context.Context, sel ast.SelectionSet, v *ThirdParty) graphql.Marshaler { 7770 if v == nil { 7771 return graphql.Null 7772 } 7773 res := MarshalThirdParty(*v) 7774 return res 7775 } 7776 7777 func (ec *executionContext) unmarshalOTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) { 7778 if v == nil { 7779 return nil, nil 7780 } 7781 res, err := graphql.UnmarshalTime(v) 7782 return &res, graphql.ErrorOnPath(ctx, err) 7783 } 7784 7785 func (ec *executionContext) marshalOTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler { 7786 if v == nil { 7787 return graphql.Null 7788 } 7789 res := graphql.MarshalTime(*v) 7790 return res 7791 } 7792 7793 // endregion ***************************** type.gotpl *****************************