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