github.com/fortexxx/gqlgen@v0.10.3-0.20191216030626-ca5ea8b21ead/example/config/generated.go (about) 1 // Code generated by github.com/99designs/gqlgen, DO NOT EDIT. 2 3 package config 4 5 import ( 6 "bytes" 7 "context" 8 "errors" 9 "strconv" 10 "sync" 11 "sync/atomic" 12 13 "github.com/99designs/gqlgen/graphql" 14 "github.com/99designs/gqlgen/graphql/introspection" 15 "github.com/vektah/gqlparser" 16 "github.com/vektah/gqlparser/ast" 17 ) 18 19 // region ************************** generated!.gotpl ************************** 20 21 // NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface. 22 func NewExecutableSchema(cfg Config) graphql.ExecutableSchema { 23 return &executableSchema{ 24 resolvers: cfg.Resolvers, 25 directives: cfg.Directives, 26 complexity: cfg.Complexity, 27 } 28 } 29 30 type Config struct { 31 Resolvers ResolverRoot 32 Directives DirectiveRoot 33 Complexity ComplexityRoot 34 } 35 36 type ResolverRoot interface { 37 Mutation() MutationResolver 38 Query() QueryResolver 39 Todo() TodoResolver 40 } 41 42 type DirectiveRoot struct { 43 } 44 45 type ComplexityRoot struct { 46 Mutation struct { 47 CreateTodo func(childComplexity int, input NewTodo) int 48 } 49 50 Query struct { 51 Todos func(childComplexity int) int 52 } 53 54 Todo struct { 55 DatabaseID func(childComplexity int) int 56 Description func(childComplexity int) int 57 Done func(childComplexity int) int 58 ID func(childComplexity int) int 59 User func(childComplexity int) int 60 } 61 62 User struct { 63 FullName func(childComplexity int) int 64 ID func(childComplexity int) int 65 } 66 } 67 68 type MutationResolver interface { 69 CreateTodo(ctx context.Context, input NewTodo) (*Todo, error) 70 } 71 type QueryResolver interface { 72 Todos(ctx context.Context) ([]*Todo, error) 73 } 74 type TodoResolver interface { 75 ID(ctx context.Context, obj *Todo) (string, error) 76 } 77 78 type executableSchema struct { 79 resolvers ResolverRoot 80 directives DirectiveRoot 81 complexity ComplexityRoot 82 } 83 84 func (e *executableSchema) Schema() *ast.Schema { 85 return parsedSchema 86 } 87 88 func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) { 89 ec := executionContext{nil, e} 90 _ = ec 91 switch typeName + "." + field { 92 93 case "Mutation.createTodo": 94 if e.complexity.Mutation.CreateTodo == nil { 95 break 96 } 97 98 args, err := ec.field_Mutation_createTodo_args(context.TODO(), rawArgs) 99 if err != nil { 100 return 0, false 101 } 102 103 return e.complexity.Mutation.CreateTodo(childComplexity, args["input"].(NewTodo)), true 104 105 case "Query.todos": 106 if e.complexity.Query.Todos == nil { 107 break 108 } 109 110 return e.complexity.Query.Todos(childComplexity), true 111 112 case "Todo.databaseId": 113 if e.complexity.Todo.DatabaseID == nil { 114 break 115 } 116 117 return e.complexity.Todo.DatabaseID(childComplexity), true 118 119 case "Todo.text": 120 if e.complexity.Todo.Description == nil { 121 break 122 } 123 124 return e.complexity.Todo.Description(childComplexity), true 125 126 case "Todo.done": 127 if e.complexity.Todo.Done == nil { 128 break 129 } 130 131 return e.complexity.Todo.Done(childComplexity), true 132 133 case "Todo.id": 134 if e.complexity.Todo.ID == nil { 135 break 136 } 137 138 return e.complexity.Todo.ID(childComplexity), true 139 140 case "Todo.user": 141 if e.complexity.Todo.User == nil { 142 break 143 } 144 145 return e.complexity.Todo.User(childComplexity), true 146 147 case "User.name": 148 if e.complexity.User.FullName == nil { 149 break 150 } 151 152 return e.complexity.User.FullName(childComplexity), true 153 154 case "User.id": 155 if e.complexity.User.ID == nil { 156 break 157 } 158 159 return e.complexity.User.ID(childComplexity), true 160 161 } 162 return 0, false 163 } 164 165 func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { 166 rc := graphql.GetOperationContext(ctx) 167 ec := executionContext{rc, e} 168 first := true 169 170 switch rc.Operation.Operation { 171 case ast.Query: 172 return func(ctx context.Context) *graphql.Response { 173 if !first { 174 return nil 175 } 176 first = false 177 data := ec._Query(ctx, rc.Operation.SelectionSet) 178 var buf bytes.Buffer 179 data.MarshalGQL(&buf) 180 181 return &graphql.Response{ 182 Data: buf.Bytes(), 183 } 184 } 185 case ast.Mutation: 186 return func(ctx context.Context) *graphql.Response { 187 if !first { 188 return nil 189 } 190 first = false 191 data := ec._Mutation(ctx, rc.Operation.SelectionSet) 192 var buf bytes.Buffer 193 data.MarshalGQL(&buf) 194 195 return &graphql.Response{ 196 Data: buf.Bytes(), 197 } 198 } 199 200 default: 201 return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation")) 202 } 203 } 204 205 type executionContext struct { 206 *graphql.OperationContext 207 *executableSchema 208 } 209 210 func (ec *executionContext) introspectSchema() (*introspection.Schema, error) { 211 if ec.DisableIntrospection { 212 return nil, errors.New("introspection disabled") 213 } 214 return introspection.WrapSchema(parsedSchema), nil 215 } 216 217 func (ec *executionContext) introspectType(name string) (*introspection.Type, error) { 218 if ec.DisableIntrospection { 219 return nil, errors.New("introspection disabled") 220 } 221 return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil 222 } 223 224 var parsedSchema = gqlparser.MustLoadSchema( 225 &ast.Source{Name: "schema.graphql", Input: `directive @goModel(model: String, models: [String!]) on OBJECT | INPUT_OBJECT | SCALAR | ENUM | INTERFACE | UNION 226 directive @goField(forceResolver: Boolean, name: String) on INPUT_FIELD_DEFINITION | FIELD_DEFINITION 227 228 type Query { 229 todos: [Todo!]! 230 } 231 232 type Mutation { 233 createTodo(input: NewTodo!): Todo! 234 } 235 `}, 236 &ast.Source{Name: "todo.graphql", Input: `type Todo { 237 id: ID! @goField(forceResolver: true) 238 databaseId: Int! 239 text: String! 240 done: Boolean! 241 user: User! 242 } 243 244 input NewTodo { 245 text: String! 246 userId: String! 247 } 248 249 `}, 250 &ast.Source{Name: "user.graphql", Input: `type User 251 @goModel(model:"github.com/99designs/gqlgen/example/config.User") { 252 id: ID! 253 name: String! @goField(name:"FullName") 254 } 255 `}, 256 ) 257 258 // endregion ************************** generated!.gotpl ************************** 259 260 // region ***************************** args.gotpl ***************************** 261 262 func (ec *executionContext) field_Mutation_createTodo_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 263 var err error 264 args := map[string]interface{}{} 265 var arg0 NewTodo 266 if tmp, ok := rawArgs["input"]; ok { 267 arg0, err = ec.unmarshalNNewTodo2githubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐNewTodo(ctx, tmp) 268 if err != nil { 269 return nil, err 270 } 271 } 272 args["input"] = arg0 273 return args, nil 274 } 275 276 func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 277 var err error 278 args := map[string]interface{}{} 279 var arg0 string 280 if tmp, ok := rawArgs["name"]; ok { 281 arg0, err = ec.unmarshalNString2string(ctx, tmp) 282 if err != nil { 283 return nil, err 284 } 285 } 286 args["name"] = arg0 287 return args, nil 288 } 289 290 func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 291 var err error 292 args := map[string]interface{}{} 293 var arg0 bool 294 if tmp, ok := rawArgs["includeDeprecated"]; ok { 295 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp) 296 if err != nil { 297 return nil, err 298 } 299 } 300 args["includeDeprecated"] = arg0 301 return args, nil 302 } 303 304 func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { 305 var err error 306 args := map[string]interface{}{} 307 var arg0 bool 308 if tmp, ok := rawArgs["includeDeprecated"]; ok { 309 arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp) 310 if err != nil { 311 return nil, err 312 } 313 } 314 args["includeDeprecated"] = arg0 315 return args, nil 316 } 317 318 // endregion ***************************** args.gotpl ***************************** 319 320 // region ************************** directives.gotpl ************************** 321 322 // endregion ************************** directives.gotpl ************************** 323 324 // region **************************** field.gotpl ***************************** 325 326 func (ec *executionContext) _Mutation_createTodo(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 327 defer func() { 328 if r := recover(); r != nil { 329 ec.Error(ctx, ec.Recover(ctx, r)) 330 ret = graphql.Null 331 } 332 }() 333 fc := &graphql.FieldContext{ 334 Object: "Mutation", 335 Field: field, 336 Args: nil, 337 IsMethod: true, 338 } 339 340 ctx = graphql.WithFieldContext(ctx, fc) 341 rawArgs := field.ArgumentMap(ec.Variables) 342 args, err := ec.field_Mutation_createTodo_args(ctx, rawArgs) 343 if err != nil { 344 ec.Error(ctx, err) 345 return graphql.Null 346 } 347 fc.Args = args 348 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 349 ctx = rctx // use context from middleware stack in children 350 return ec.resolvers.Mutation().CreateTodo(rctx, args["input"].(NewTodo)) 351 }) 352 if err != nil { 353 ec.Error(ctx, err) 354 return graphql.Null 355 } 356 if resTmp == nil { 357 if !graphql.HasFieldError(ctx, fc) { 358 ec.Errorf(ctx, "must not be null") 359 } 360 return graphql.Null 361 } 362 res := resTmp.(*Todo) 363 fc.Result = res 364 return ec.marshalNTodo2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐTodo(ctx, field.Selections, res) 365 } 366 367 func (ec *executionContext) _Query_todos(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 368 defer func() { 369 if r := recover(); r != nil { 370 ec.Error(ctx, ec.Recover(ctx, r)) 371 ret = graphql.Null 372 } 373 }() 374 fc := &graphql.FieldContext{ 375 Object: "Query", 376 Field: field, 377 Args: nil, 378 IsMethod: true, 379 } 380 381 ctx = graphql.WithFieldContext(ctx, fc) 382 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 383 ctx = rctx // use context from middleware stack in children 384 return ec.resolvers.Query().Todos(rctx) 385 }) 386 if err != nil { 387 ec.Error(ctx, err) 388 return graphql.Null 389 } 390 if resTmp == nil { 391 if !graphql.HasFieldError(ctx, fc) { 392 ec.Errorf(ctx, "must not be null") 393 } 394 return graphql.Null 395 } 396 res := resTmp.([]*Todo) 397 fc.Result = res 398 return ec.marshalNTodo2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐTodoᚄ(ctx, field.Selections, res) 399 } 400 401 func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 402 defer func() { 403 if r := recover(); r != nil { 404 ec.Error(ctx, ec.Recover(ctx, r)) 405 ret = graphql.Null 406 } 407 }() 408 fc := &graphql.FieldContext{ 409 Object: "Query", 410 Field: field, 411 Args: nil, 412 IsMethod: true, 413 } 414 415 ctx = graphql.WithFieldContext(ctx, fc) 416 rawArgs := field.ArgumentMap(ec.Variables) 417 args, err := ec.field_Query___type_args(ctx, rawArgs) 418 if err != nil { 419 ec.Error(ctx, err) 420 return graphql.Null 421 } 422 fc.Args = args 423 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 424 ctx = rctx // use context from middleware stack in children 425 return ec.introspectType(args["name"].(string)) 426 }) 427 if err != nil { 428 ec.Error(ctx, err) 429 return graphql.Null 430 } 431 if resTmp == nil { 432 return graphql.Null 433 } 434 res := resTmp.(*introspection.Type) 435 fc.Result = res 436 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res) 437 } 438 439 func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { 440 defer func() { 441 if r := recover(); r != nil { 442 ec.Error(ctx, ec.Recover(ctx, r)) 443 ret = graphql.Null 444 } 445 }() 446 fc := &graphql.FieldContext{ 447 Object: "Query", 448 Field: field, 449 Args: nil, 450 IsMethod: true, 451 } 452 453 ctx = graphql.WithFieldContext(ctx, fc) 454 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 455 ctx = rctx // use context from middleware stack in children 456 return ec.introspectSchema() 457 }) 458 if err != nil { 459 ec.Error(ctx, err) 460 return graphql.Null 461 } 462 if resTmp == nil { 463 return graphql.Null 464 } 465 res := resTmp.(*introspection.Schema) 466 fc.Result = res 467 return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res) 468 } 469 470 func (ec *executionContext) _Todo_id(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { 471 defer func() { 472 if r := recover(); r != nil { 473 ec.Error(ctx, ec.Recover(ctx, r)) 474 ret = graphql.Null 475 } 476 }() 477 fc := &graphql.FieldContext{ 478 Object: "Todo", 479 Field: field, 480 Args: nil, 481 IsMethod: true, 482 } 483 484 ctx = graphql.WithFieldContext(ctx, fc) 485 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 486 ctx = rctx // use context from middleware stack in children 487 return ec.resolvers.Todo().ID(rctx, obj) 488 }) 489 if err != nil { 490 ec.Error(ctx, err) 491 return graphql.Null 492 } 493 if resTmp == nil { 494 if !graphql.HasFieldError(ctx, fc) { 495 ec.Errorf(ctx, "must not be null") 496 } 497 return graphql.Null 498 } 499 res := resTmp.(string) 500 fc.Result = res 501 return ec.marshalNID2string(ctx, field.Selections, res) 502 } 503 504 func (ec *executionContext) _Todo_databaseId(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { 505 defer func() { 506 if r := recover(); r != nil { 507 ec.Error(ctx, ec.Recover(ctx, r)) 508 ret = graphql.Null 509 } 510 }() 511 fc := &graphql.FieldContext{ 512 Object: "Todo", 513 Field: field, 514 Args: nil, 515 IsMethod: false, 516 } 517 518 ctx = graphql.WithFieldContext(ctx, fc) 519 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 520 ctx = rctx // use context from middleware stack in children 521 return obj.DatabaseID, nil 522 }) 523 if err != nil { 524 ec.Error(ctx, err) 525 return graphql.Null 526 } 527 if resTmp == nil { 528 if !graphql.HasFieldError(ctx, fc) { 529 ec.Errorf(ctx, "must not be null") 530 } 531 return graphql.Null 532 } 533 res := resTmp.(int) 534 fc.Result = res 535 return ec.marshalNInt2int(ctx, field.Selections, res) 536 } 537 538 func (ec *executionContext) _Todo_text(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { 539 defer func() { 540 if r := recover(); r != nil { 541 ec.Error(ctx, ec.Recover(ctx, r)) 542 ret = graphql.Null 543 } 544 }() 545 fc := &graphql.FieldContext{ 546 Object: "Todo", 547 Field: field, 548 Args: nil, 549 IsMethod: false, 550 } 551 552 ctx = graphql.WithFieldContext(ctx, fc) 553 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 554 ctx = rctx // use context from middleware stack in children 555 return obj.Description, nil 556 }) 557 if err != nil { 558 ec.Error(ctx, err) 559 return graphql.Null 560 } 561 if resTmp == nil { 562 if !graphql.HasFieldError(ctx, fc) { 563 ec.Errorf(ctx, "must not be null") 564 } 565 return graphql.Null 566 } 567 res := resTmp.(string) 568 fc.Result = res 569 return ec.marshalNString2string(ctx, field.Selections, res) 570 } 571 572 func (ec *executionContext) _Todo_done(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { 573 defer func() { 574 if r := recover(); r != nil { 575 ec.Error(ctx, ec.Recover(ctx, r)) 576 ret = graphql.Null 577 } 578 }() 579 fc := &graphql.FieldContext{ 580 Object: "Todo", 581 Field: field, 582 Args: nil, 583 IsMethod: false, 584 } 585 586 ctx = graphql.WithFieldContext(ctx, fc) 587 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 588 ctx = rctx // use context from middleware stack in children 589 return obj.Done, nil 590 }) 591 if err != nil { 592 ec.Error(ctx, err) 593 return graphql.Null 594 } 595 if resTmp == nil { 596 if !graphql.HasFieldError(ctx, fc) { 597 ec.Errorf(ctx, "must not be null") 598 } 599 return graphql.Null 600 } 601 res := resTmp.(bool) 602 fc.Result = res 603 return ec.marshalNBoolean2bool(ctx, field.Selections, res) 604 } 605 606 func (ec *executionContext) _Todo_user(ctx context.Context, field graphql.CollectedField, obj *Todo) (ret graphql.Marshaler) { 607 defer func() { 608 if r := recover(); r != nil { 609 ec.Error(ctx, ec.Recover(ctx, r)) 610 ret = graphql.Null 611 } 612 }() 613 fc := &graphql.FieldContext{ 614 Object: "Todo", 615 Field: field, 616 Args: nil, 617 IsMethod: false, 618 } 619 620 ctx = graphql.WithFieldContext(ctx, fc) 621 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 622 ctx = rctx // use context from middleware stack in children 623 return obj.User, nil 624 }) 625 if err != nil { 626 ec.Error(ctx, err) 627 return graphql.Null 628 } 629 if resTmp == nil { 630 if !graphql.HasFieldError(ctx, fc) { 631 ec.Errorf(ctx, "must not be null") 632 } 633 return graphql.Null 634 } 635 res := resTmp.(*User) 636 fc.Result = res 637 return ec.marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐUser(ctx, field.Selections, res) 638 } 639 640 func (ec *executionContext) _User_id(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) { 641 defer func() { 642 if r := recover(); r != nil { 643 ec.Error(ctx, ec.Recover(ctx, r)) 644 ret = graphql.Null 645 } 646 }() 647 fc := &graphql.FieldContext{ 648 Object: "User", 649 Field: field, 650 Args: nil, 651 IsMethod: false, 652 } 653 654 ctx = graphql.WithFieldContext(ctx, fc) 655 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 656 ctx = rctx // use context from middleware stack in children 657 return obj.ID, nil 658 }) 659 if err != nil { 660 ec.Error(ctx, err) 661 return graphql.Null 662 } 663 if resTmp == nil { 664 if !graphql.HasFieldError(ctx, fc) { 665 ec.Errorf(ctx, "must not be null") 666 } 667 return graphql.Null 668 } 669 res := resTmp.(string) 670 fc.Result = res 671 return ec.marshalNID2string(ctx, field.Selections, res) 672 } 673 674 func (ec *executionContext) _User_name(ctx context.Context, field graphql.CollectedField, obj *User) (ret graphql.Marshaler) { 675 defer func() { 676 if r := recover(); r != nil { 677 ec.Error(ctx, ec.Recover(ctx, r)) 678 ret = graphql.Null 679 } 680 }() 681 fc := &graphql.FieldContext{ 682 Object: "User", 683 Field: field, 684 Args: nil, 685 IsMethod: true, 686 } 687 688 ctx = graphql.WithFieldContext(ctx, fc) 689 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 690 ctx = rctx // use context from middleware stack in children 691 return obj.FullName(), nil 692 }) 693 if err != nil { 694 ec.Error(ctx, err) 695 return graphql.Null 696 } 697 if resTmp == nil { 698 if !graphql.HasFieldError(ctx, fc) { 699 ec.Errorf(ctx, "must not be null") 700 } 701 return graphql.Null 702 } 703 res := resTmp.(string) 704 fc.Result = res 705 return ec.marshalNString2string(ctx, field.Selections, res) 706 } 707 708 func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { 709 defer func() { 710 if r := recover(); r != nil { 711 ec.Error(ctx, ec.Recover(ctx, r)) 712 ret = graphql.Null 713 } 714 }() 715 fc := &graphql.FieldContext{ 716 Object: "__Directive", 717 Field: field, 718 Args: nil, 719 IsMethod: false, 720 } 721 722 ctx = graphql.WithFieldContext(ctx, fc) 723 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 724 ctx = rctx // use context from middleware stack in children 725 return obj.Name, nil 726 }) 727 if err != nil { 728 ec.Error(ctx, err) 729 return graphql.Null 730 } 731 if resTmp == nil { 732 if !graphql.HasFieldError(ctx, fc) { 733 ec.Errorf(ctx, "must not be null") 734 } 735 return graphql.Null 736 } 737 res := resTmp.(string) 738 fc.Result = res 739 return ec.marshalNString2string(ctx, field.Selections, res) 740 } 741 742 func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { 743 defer func() { 744 if r := recover(); r != nil { 745 ec.Error(ctx, ec.Recover(ctx, r)) 746 ret = graphql.Null 747 } 748 }() 749 fc := &graphql.FieldContext{ 750 Object: "__Directive", 751 Field: field, 752 Args: nil, 753 IsMethod: false, 754 } 755 756 ctx = graphql.WithFieldContext(ctx, fc) 757 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 758 ctx = rctx // use context from middleware stack in children 759 return obj.Description, nil 760 }) 761 if err != nil { 762 ec.Error(ctx, err) 763 return graphql.Null 764 } 765 if resTmp == nil { 766 return graphql.Null 767 } 768 res := resTmp.(string) 769 fc.Result = res 770 return ec.marshalOString2string(ctx, field.Selections, res) 771 } 772 773 func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { 774 defer func() { 775 if r := recover(); r != nil { 776 ec.Error(ctx, ec.Recover(ctx, r)) 777 ret = graphql.Null 778 } 779 }() 780 fc := &graphql.FieldContext{ 781 Object: "__Directive", 782 Field: field, 783 Args: nil, 784 IsMethod: false, 785 } 786 787 ctx = graphql.WithFieldContext(ctx, fc) 788 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 789 ctx = rctx // use context from middleware stack in children 790 return obj.Locations, nil 791 }) 792 if err != nil { 793 ec.Error(ctx, err) 794 return graphql.Null 795 } 796 if resTmp == nil { 797 if !graphql.HasFieldError(ctx, fc) { 798 ec.Errorf(ctx, "must not be null") 799 } 800 return graphql.Null 801 } 802 res := resTmp.([]string) 803 fc.Result = res 804 return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res) 805 } 806 807 func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { 808 defer func() { 809 if r := recover(); r != nil { 810 ec.Error(ctx, ec.Recover(ctx, r)) 811 ret = graphql.Null 812 } 813 }() 814 fc := &graphql.FieldContext{ 815 Object: "__Directive", 816 Field: field, 817 Args: nil, 818 IsMethod: false, 819 } 820 821 ctx = graphql.WithFieldContext(ctx, fc) 822 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 823 ctx = rctx // use context from middleware stack in children 824 return obj.Args, nil 825 }) 826 if err != nil { 827 ec.Error(ctx, err) 828 return graphql.Null 829 } 830 if resTmp == nil { 831 if !graphql.HasFieldError(ctx, fc) { 832 ec.Errorf(ctx, "must not be null") 833 } 834 return graphql.Null 835 } 836 res := resTmp.([]introspection.InputValue) 837 fc.Result = res 838 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res) 839 } 840 841 func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { 842 defer func() { 843 if r := recover(); r != nil { 844 ec.Error(ctx, ec.Recover(ctx, r)) 845 ret = graphql.Null 846 } 847 }() 848 fc := &graphql.FieldContext{ 849 Object: "__EnumValue", 850 Field: field, 851 Args: nil, 852 IsMethod: false, 853 } 854 855 ctx = graphql.WithFieldContext(ctx, fc) 856 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 857 ctx = rctx // use context from middleware stack in children 858 return obj.Name, nil 859 }) 860 if err != nil { 861 ec.Error(ctx, err) 862 return graphql.Null 863 } 864 if resTmp == nil { 865 if !graphql.HasFieldError(ctx, fc) { 866 ec.Errorf(ctx, "must not be null") 867 } 868 return graphql.Null 869 } 870 res := resTmp.(string) 871 fc.Result = res 872 return ec.marshalNString2string(ctx, field.Selections, res) 873 } 874 875 func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { 876 defer func() { 877 if r := recover(); r != nil { 878 ec.Error(ctx, ec.Recover(ctx, r)) 879 ret = graphql.Null 880 } 881 }() 882 fc := &graphql.FieldContext{ 883 Object: "__EnumValue", 884 Field: field, 885 Args: nil, 886 IsMethod: false, 887 } 888 889 ctx = graphql.WithFieldContext(ctx, fc) 890 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 891 ctx = rctx // use context from middleware stack in children 892 return obj.Description, nil 893 }) 894 if err != nil { 895 ec.Error(ctx, err) 896 return graphql.Null 897 } 898 if resTmp == nil { 899 return graphql.Null 900 } 901 res := resTmp.(string) 902 fc.Result = res 903 return ec.marshalOString2string(ctx, field.Selections, res) 904 } 905 906 func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { 907 defer func() { 908 if r := recover(); r != nil { 909 ec.Error(ctx, ec.Recover(ctx, r)) 910 ret = graphql.Null 911 } 912 }() 913 fc := &graphql.FieldContext{ 914 Object: "__EnumValue", 915 Field: field, 916 Args: nil, 917 IsMethod: true, 918 } 919 920 ctx = graphql.WithFieldContext(ctx, fc) 921 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 922 ctx = rctx // use context from middleware stack in children 923 return obj.IsDeprecated(), nil 924 }) 925 if err != nil { 926 ec.Error(ctx, err) 927 return graphql.Null 928 } 929 if resTmp == nil { 930 if !graphql.HasFieldError(ctx, fc) { 931 ec.Errorf(ctx, "must not be null") 932 } 933 return graphql.Null 934 } 935 res := resTmp.(bool) 936 fc.Result = res 937 return ec.marshalNBoolean2bool(ctx, field.Selections, res) 938 } 939 940 func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { 941 defer func() { 942 if r := recover(); r != nil { 943 ec.Error(ctx, ec.Recover(ctx, r)) 944 ret = graphql.Null 945 } 946 }() 947 fc := &graphql.FieldContext{ 948 Object: "__EnumValue", 949 Field: field, 950 Args: nil, 951 IsMethod: true, 952 } 953 954 ctx = graphql.WithFieldContext(ctx, fc) 955 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 956 ctx = rctx // use context from middleware stack in children 957 return obj.DeprecationReason(), nil 958 }) 959 if err != nil { 960 ec.Error(ctx, err) 961 return graphql.Null 962 } 963 if resTmp == nil { 964 return graphql.Null 965 } 966 res := resTmp.(*string) 967 fc.Result = res 968 return ec.marshalOString2ᚖstring(ctx, field.Selections, res) 969 } 970 971 func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { 972 defer func() { 973 if r := recover(); r != nil { 974 ec.Error(ctx, ec.Recover(ctx, r)) 975 ret = graphql.Null 976 } 977 }() 978 fc := &graphql.FieldContext{ 979 Object: "__Field", 980 Field: field, 981 Args: nil, 982 IsMethod: false, 983 } 984 985 ctx = graphql.WithFieldContext(ctx, fc) 986 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 987 ctx = rctx // use context from middleware stack in children 988 return obj.Name, nil 989 }) 990 if err != nil { 991 ec.Error(ctx, err) 992 return graphql.Null 993 } 994 if resTmp == nil { 995 if !graphql.HasFieldError(ctx, fc) { 996 ec.Errorf(ctx, "must not be null") 997 } 998 return graphql.Null 999 } 1000 res := resTmp.(string) 1001 fc.Result = res 1002 return ec.marshalNString2string(ctx, field.Selections, res) 1003 } 1004 1005 func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { 1006 defer func() { 1007 if r := recover(); r != nil { 1008 ec.Error(ctx, ec.Recover(ctx, r)) 1009 ret = graphql.Null 1010 } 1011 }() 1012 fc := &graphql.FieldContext{ 1013 Object: "__Field", 1014 Field: field, 1015 Args: nil, 1016 IsMethod: false, 1017 } 1018 1019 ctx = graphql.WithFieldContext(ctx, fc) 1020 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1021 ctx = rctx // use context from middleware stack in children 1022 return obj.Description, nil 1023 }) 1024 if err != nil { 1025 ec.Error(ctx, err) 1026 return graphql.Null 1027 } 1028 if resTmp == nil { 1029 return graphql.Null 1030 } 1031 res := resTmp.(string) 1032 fc.Result = res 1033 return ec.marshalOString2string(ctx, field.Selections, res) 1034 } 1035 1036 func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { 1037 defer func() { 1038 if r := recover(); r != nil { 1039 ec.Error(ctx, ec.Recover(ctx, r)) 1040 ret = graphql.Null 1041 } 1042 }() 1043 fc := &graphql.FieldContext{ 1044 Object: "__Field", 1045 Field: field, 1046 Args: nil, 1047 IsMethod: false, 1048 } 1049 1050 ctx = graphql.WithFieldContext(ctx, fc) 1051 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1052 ctx = rctx // use context from middleware stack in children 1053 return obj.Args, nil 1054 }) 1055 if err != nil { 1056 ec.Error(ctx, err) 1057 return graphql.Null 1058 } 1059 if resTmp == nil { 1060 if !graphql.HasFieldError(ctx, fc) { 1061 ec.Errorf(ctx, "must not be null") 1062 } 1063 return graphql.Null 1064 } 1065 res := resTmp.([]introspection.InputValue) 1066 fc.Result = res 1067 return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res) 1068 } 1069 1070 func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { 1071 defer func() { 1072 if r := recover(); r != nil { 1073 ec.Error(ctx, ec.Recover(ctx, r)) 1074 ret = graphql.Null 1075 } 1076 }() 1077 fc := &graphql.FieldContext{ 1078 Object: "__Field", 1079 Field: field, 1080 Args: nil, 1081 IsMethod: false, 1082 } 1083 1084 ctx = graphql.WithFieldContext(ctx, fc) 1085 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1086 ctx = rctx // use context from middleware stack in children 1087 return obj.Type, nil 1088 }) 1089 if err != nil { 1090 ec.Error(ctx, err) 1091 return graphql.Null 1092 } 1093 if resTmp == nil { 1094 if !graphql.HasFieldError(ctx, fc) { 1095 ec.Errorf(ctx, "must not be null") 1096 } 1097 return graphql.Null 1098 } 1099 res := resTmp.(*introspection.Type) 1100 fc.Result = res 1101 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res) 1102 } 1103 1104 func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { 1105 defer func() { 1106 if r := recover(); r != nil { 1107 ec.Error(ctx, ec.Recover(ctx, r)) 1108 ret = graphql.Null 1109 } 1110 }() 1111 fc := &graphql.FieldContext{ 1112 Object: "__Field", 1113 Field: field, 1114 Args: nil, 1115 IsMethod: true, 1116 } 1117 1118 ctx = graphql.WithFieldContext(ctx, fc) 1119 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1120 ctx = rctx // use context from middleware stack in children 1121 return obj.IsDeprecated(), nil 1122 }) 1123 if err != nil { 1124 ec.Error(ctx, err) 1125 return graphql.Null 1126 } 1127 if resTmp == nil { 1128 if !graphql.HasFieldError(ctx, fc) { 1129 ec.Errorf(ctx, "must not be null") 1130 } 1131 return graphql.Null 1132 } 1133 res := resTmp.(bool) 1134 fc.Result = res 1135 return ec.marshalNBoolean2bool(ctx, field.Selections, res) 1136 } 1137 1138 func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { 1139 defer func() { 1140 if r := recover(); r != nil { 1141 ec.Error(ctx, ec.Recover(ctx, r)) 1142 ret = graphql.Null 1143 } 1144 }() 1145 fc := &graphql.FieldContext{ 1146 Object: "__Field", 1147 Field: field, 1148 Args: nil, 1149 IsMethod: true, 1150 } 1151 1152 ctx = graphql.WithFieldContext(ctx, fc) 1153 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1154 ctx = rctx // use context from middleware stack in children 1155 return obj.DeprecationReason(), nil 1156 }) 1157 if err != nil { 1158 ec.Error(ctx, err) 1159 return graphql.Null 1160 } 1161 if resTmp == nil { 1162 return graphql.Null 1163 } 1164 res := resTmp.(*string) 1165 fc.Result = res 1166 return ec.marshalOString2ᚖstring(ctx, field.Selections, res) 1167 } 1168 1169 func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { 1170 defer func() { 1171 if r := recover(); r != nil { 1172 ec.Error(ctx, ec.Recover(ctx, r)) 1173 ret = graphql.Null 1174 } 1175 }() 1176 fc := &graphql.FieldContext{ 1177 Object: "__InputValue", 1178 Field: field, 1179 Args: nil, 1180 IsMethod: false, 1181 } 1182 1183 ctx = graphql.WithFieldContext(ctx, fc) 1184 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1185 ctx = rctx // use context from middleware stack in children 1186 return obj.Name, nil 1187 }) 1188 if err != nil { 1189 ec.Error(ctx, err) 1190 return graphql.Null 1191 } 1192 if resTmp == nil { 1193 if !graphql.HasFieldError(ctx, fc) { 1194 ec.Errorf(ctx, "must not be null") 1195 } 1196 return graphql.Null 1197 } 1198 res := resTmp.(string) 1199 fc.Result = res 1200 return ec.marshalNString2string(ctx, field.Selections, res) 1201 } 1202 1203 func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { 1204 defer func() { 1205 if r := recover(); r != nil { 1206 ec.Error(ctx, ec.Recover(ctx, r)) 1207 ret = graphql.Null 1208 } 1209 }() 1210 fc := &graphql.FieldContext{ 1211 Object: "__InputValue", 1212 Field: field, 1213 Args: nil, 1214 IsMethod: false, 1215 } 1216 1217 ctx = graphql.WithFieldContext(ctx, fc) 1218 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1219 ctx = rctx // use context from middleware stack in children 1220 return obj.Description, nil 1221 }) 1222 if err != nil { 1223 ec.Error(ctx, err) 1224 return graphql.Null 1225 } 1226 if resTmp == nil { 1227 return graphql.Null 1228 } 1229 res := resTmp.(string) 1230 fc.Result = res 1231 return ec.marshalOString2string(ctx, field.Selections, res) 1232 } 1233 1234 func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { 1235 defer func() { 1236 if r := recover(); r != nil { 1237 ec.Error(ctx, ec.Recover(ctx, r)) 1238 ret = graphql.Null 1239 } 1240 }() 1241 fc := &graphql.FieldContext{ 1242 Object: "__InputValue", 1243 Field: field, 1244 Args: nil, 1245 IsMethod: false, 1246 } 1247 1248 ctx = graphql.WithFieldContext(ctx, fc) 1249 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1250 ctx = rctx // use context from middleware stack in children 1251 return obj.Type, nil 1252 }) 1253 if err != nil { 1254 ec.Error(ctx, err) 1255 return graphql.Null 1256 } 1257 if resTmp == nil { 1258 if !graphql.HasFieldError(ctx, fc) { 1259 ec.Errorf(ctx, "must not be null") 1260 } 1261 return graphql.Null 1262 } 1263 res := resTmp.(*introspection.Type) 1264 fc.Result = res 1265 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res) 1266 } 1267 1268 func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { 1269 defer func() { 1270 if r := recover(); r != nil { 1271 ec.Error(ctx, ec.Recover(ctx, r)) 1272 ret = graphql.Null 1273 } 1274 }() 1275 fc := &graphql.FieldContext{ 1276 Object: "__InputValue", 1277 Field: field, 1278 Args: nil, 1279 IsMethod: false, 1280 } 1281 1282 ctx = graphql.WithFieldContext(ctx, fc) 1283 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1284 ctx = rctx // use context from middleware stack in children 1285 return obj.DefaultValue, nil 1286 }) 1287 if err != nil { 1288 ec.Error(ctx, err) 1289 return graphql.Null 1290 } 1291 if resTmp == nil { 1292 return graphql.Null 1293 } 1294 res := resTmp.(*string) 1295 fc.Result = res 1296 return ec.marshalOString2ᚖstring(ctx, field.Selections, res) 1297 } 1298 1299 func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { 1300 defer func() { 1301 if r := recover(); r != nil { 1302 ec.Error(ctx, ec.Recover(ctx, r)) 1303 ret = graphql.Null 1304 } 1305 }() 1306 fc := &graphql.FieldContext{ 1307 Object: "__Schema", 1308 Field: field, 1309 Args: nil, 1310 IsMethod: true, 1311 } 1312 1313 ctx = graphql.WithFieldContext(ctx, fc) 1314 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1315 ctx = rctx // use context from middleware stack in children 1316 return obj.Types(), nil 1317 }) 1318 if err != nil { 1319 ec.Error(ctx, err) 1320 return graphql.Null 1321 } 1322 if resTmp == nil { 1323 if !graphql.HasFieldError(ctx, fc) { 1324 ec.Errorf(ctx, "must not be null") 1325 } 1326 return graphql.Null 1327 } 1328 res := resTmp.([]introspection.Type) 1329 fc.Result = res 1330 return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res) 1331 } 1332 1333 func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { 1334 defer func() { 1335 if r := recover(); r != nil { 1336 ec.Error(ctx, ec.Recover(ctx, r)) 1337 ret = graphql.Null 1338 } 1339 }() 1340 fc := &graphql.FieldContext{ 1341 Object: "__Schema", 1342 Field: field, 1343 Args: nil, 1344 IsMethod: true, 1345 } 1346 1347 ctx = graphql.WithFieldContext(ctx, fc) 1348 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1349 ctx = rctx // use context from middleware stack in children 1350 return obj.QueryType(), nil 1351 }) 1352 if err != nil { 1353 ec.Error(ctx, err) 1354 return graphql.Null 1355 } 1356 if resTmp == nil { 1357 if !graphql.HasFieldError(ctx, fc) { 1358 ec.Errorf(ctx, "must not be null") 1359 } 1360 return graphql.Null 1361 } 1362 res := resTmp.(*introspection.Type) 1363 fc.Result = res 1364 return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res) 1365 } 1366 1367 func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { 1368 defer func() { 1369 if r := recover(); r != nil { 1370 ec.Error(ctx, ec.Recover(ctx, r)) 1371 ret = graphql.Null 1372 } 1373 }() 1374 fc := &graphql.FieldContext{ 1375 Object: "__Schema", 1376 Field: field, 1377 Args: nil, 1378 IsMethod: true, 1379 } 1380 1381 ctx = graphql.WithFieldContext(ctx, fc) 1382 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1383 ctx = rctx // use context from middleware stack in children 1384 return obj.MutationType(), nil 1385 }) 1386 if err != nil { 1387 ec.Error(ctx, err) 1388 return graphql.Null 1389 } 1390 if resTmp == nil { 1391 return graphql.Null 1392 } 1393 res := resTmp.(*introspection.Type) 1394 fc.Result = res 1395 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res) 1396 } 1397 1398 func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { 1399 defer func() { 1400 if r := recover(); r != nil { 1401 ec.Error(ctx, ec.Recover(ctx, r)) 1402 ret = graphql.Null 1403 } 1404 }() 1405 fc := &graphql.FieldContext{ 1406 Object: "__Schema", 1407 Field: field, 1408 Args: nil, 1409 IsMethod: true, 1410 } 1411 1412 ctx = graphql.WithFieldContext(ctx, fc) 1413 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1414 ctx = rctx // use context from middleware stack in children 1415 return obj.SubscriptionType(), nil 1416 }) 1417 if err != nil { 1418 ec.Error(ctx, err) 1419 return graphql.Null 1420 } 1421 if resTmp == nil { 1422 return graphql.Null 1423 } 1424 res := resTmp.(*introspection.Type) 1425 fc.Result = res 1426 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res) 1427 } 1428 1429 func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { 1430 defer func() { 1431 if r := recover(); r != nil { 1432 ec.Error(ctx, ec.Recover(ctx, r)) 1433 ret = graphql.Null 1434 } 1435 }() 1436 fc := &graphql.FieldContext{ 1437 Object: "__Schema", 1438 Field: field, 1439 Args: nil, 1440 IsMethod: true, 1441 } 1442 1443 ctx = graphql.WithFieldContext(ctx, fc) 1444 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1445 ctx = rctx // use context from middleware stack in children 1446 return obj.Directives(), nil 1447 }) 1448 if err != nil { 1449 ec.Error(ctx, err) 1450 return graphql.Null 1451 } 1452 if resTmp == nil { 1453 if !graphql.HasFieldError(ctx, fc) { 1454 ec.Errorf(ctx, "must not be null") 1455 } 1456 return graphql.Null 1457 } 1458 res := resTmp.([]introspection.Directive) 1459 fc.Result = res 1460 return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res) 1461 } 1462 1463 func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { 1464 defer func() { 1465 if r := recover(); r != nil { 1466 ec.Error(ctx, ec.Recover(ctx, r)) 1467 ret = graphql.Null 1468 } 1469 }() 1470 fc := &graphql.FieldContext{ 1471 Object: "__Type", 1472 Field: field, 1473 Args: nil, 1474 IsMethod: true, 1475 } 1476 1477 ctx = graphql.WithFieldContext(ctx, fc) 1478 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1479 ctx = rctx // use context from middleware stack in children 1480 return obj.Kind(), nil 1481 }) 1482 if err != nil { 1483 ec.Error(ctx, err) 1484 return graphql.Null 1485 } 1486 if resTmp == nil { 1487 if !graphql.HasFieldError(ctx, fc) { 1488 ec.Errorf(ctx, "must not be null") 1489 } 1490 return graphql.Null 1491 } 1492 res := resTmp.(string) 1493 fc.Result = res 1494 return ec.marshalN__TypeKind2string(ctx, field.Selections, res) 1495 } 1496 1497 func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { 1498 defer func() { 1499 if r := recover(); r != nil { 1500 ec.Error(ctx, ec.Recover(ctx, r)) 1501 ret = graphql.Null 1502 } 1503 }() 1504 fc := &graphql.FieldContext{ 1505 Object: "__Type", 1506 Field: field, 1507 Args: nil, 1508 IsMethod: true, 1509 } 1510 1511 ctx = graphql.WithFieldContext(ctx, fc) 1512 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1513 ctx = rctx // use context from middleware stack in children 1514 return obj.Name(), nil 1515 }) 1516 if err != nil { 1517 ec.Error(ctx, err) 1518 return graphql.Null 1519 } 1520 if resTmp == nil { 1521 return graphql.Null 1522 } 1523 res := resTmp.(*string) 1524 fc.Result = res 1525 return ec.marshalOString2ᚖstring(ctx, field.Selections, res) 1526 } 1527 1528 func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { 1529 defer func() { 1530 if r := recover(); r != nil { 1531 ec.Error(ctx, ec.Recover(ctx, r)) 1532 ret = graphql.Null 1533 } 1534 }() 1535 fc := &graphql.FieldContext{ 1536 Object: "__Type", 1537 Field: field, 1538 Args: nil, 1539 IsMethod: true, 1540 } 1541 1542 ctx = graphql.WithFieldContext(ctx, fc) 1543 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1544 ctx = rctx // use context from middleware stack in children 1545 return obj.Description(), nil 1546 }) 1547 if err != nil { 1548 ec.Error(ctx, err) 1549 return graphql.Null 1550 } 1551 if resTmp == nil { 1552 return graphql.Null 1553 } 1554 res := resTmp.(string) 1555 fc.Result = res 1556 return ec.marshalOString2string(ctx, field.Selections, res) 1557 } 1558 1559 func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { 1560 defer func() { 1561 if r := recover(); r != nil { 1562 ec.Error(ctx, ec.Recover(ctx, r)) 1563 ret = graphql.Null 1564 } 1565 }() 1566 fc := &graphql.FieldContext{ 1567 Object: "__Type", 1568 Field: field, 1569 Args: nil, 1570 IsMethod: true, 1571 } 1572 1573 ctx = graphql.WithFieldContext(ctx, fc) 1574 rawArgs := field.ArgumentMap(ec.Variables) 1575 args, err := ec.field___Type_fields_args(ctx, rawArgs) 1576 if err != nil { 1577 ec.Error(ctx, err) 1578 return graphql.Null 1579 } 1580 fc.Args = args 1581 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1582 ctx = rctx // use context from middleware stack in children 1583 return obj.Fields(args["includeDeprecated"].(bool)), nil 1584 }) 1585 if err != nil { 1586 ec.Error(ctx, err) 1587 return graphql.Null 1588 } 1589 if resTmp == nil { 1590 return graphql.Null 1591 } 1592 res := resTmp.([]introspection.Field) 1593 fc.Result = res 1594 return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res) 1595 } 1596 1597 func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { 1598 defer func() { 1599 if r := recover(); r != nil { 1600 ec.Error(ctx, ec.Recover(ctx, r)) 1601 ret = graphql.Null 1602 } 1603 }() 1604 fc := &graphql.FieldContext{ 1605 Object: "__Type", 1606 Field: field, 1607 Args: nil, 1608 IsMethod: true, 1609 } 1610 1611 ctx = graphql.WithFieldContext(ctx, fc) 1612 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1613 ctx = rctx // use context from middleware stack in children 1614 return obj.Interfaces(), nil 1615 }) 1616 if err != nil { 1617 ec.Error(ctx, err) 1618 return graphql.Null 1619 } 1620 if resTmp == nil { 1621 return graphql.Null 1622 } 1623 res := resTmp.([]introspection.Type) 1624 fc.Result = res 1625 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res) 1626 } 1627 1628 func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { 1629 defer func() { 1630 if r := recover(); r != nil { 1631 ec.Error(ctx, ec.Recover(ctx, r)) 1632 ret = graphql.Null 1633 } 1634 }() 1635 fc := &graphql.FieldContext{ 1636 Object: "__Type", 1637 Field: field, 1638 Args: nil, 1639 IsMethod: true, 1640 } 1641 1642 ctx = graphql.WithFieldContext(ctx, fc) 1643 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1644 ctx = rctx // use context from middleware stack in children 1645 return obj.PossibleTypes(), nil 1646 }) 1647 if err != nil { 1648 ec.Error(ctx, err) 1649 return graphql.Null 1650 } 1651 if resTmp == nil { 1652 return graphql.Null 1653 } 1654 res := resTmp.([]introspection.Type) 1655 fc.Result = res 1656 return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res) 1657 } 1658 1659 func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { 1660 defer func() { 1661 if r := recover(); r != nil { 1662 ec.Error(ctx, ec.Recover(ctx, r)) 1663 ret = graphql.Null 1664 } 1665 }() 1666 fc := &graphql.FieldContext{ 1667 Object: "__Type", 1668 Field: field, 1669 Args: nil, 1670 IsMethod: true, 1671 } 1672 1673 ctx = graphql.WithFieldContext(ctx, fc) 1674 rawArgs := field.ArgumentMap(ec.Variables) 1675 args, err := ec.field___Type_enumValues_args(ctx, rawArgs) 1676 if err != nil { 1677 ec.Error(ctx, err) 1678 return graphql.Null 1679 } 1680 fc.Args = args 1681 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1682 ctx = rctx // use context from middleware stack in children 1683 return obj.EnumValues(args["includeDeprecated"].(bool)), nil 1684 }) 1685 if err != nil { 1686 ec.Error(ctx, err) 1687 return graphql.Null 1688 } 1689 if resTmp == nil { 1690 return graphql.Null 1691 } 1692 res := resTmp.([]introspection.EnumValue) 1693 fc.Result = res 1694 return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res) 1695 } 1696 1697 func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { 1698 defer func() { 1699 if r := recover(); r != nil { 1700 ec.Error(ctx, ec.Recover(ctx, r)) 1701 ret = graphql.Null 1702 } 1703 }() 1704 fc := &graphql.FieldContext{ 1705 Object: "__Type", 1706 Field: field, 1707 Args: nil, 1708 IsMethod: true, 1709 } 1710 1711 ctx = graphql.WithFieldContext(ctx, fc) 1712 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1713 ctx = rctx // use context from middleware stack in children 1714 return obj.InputFields(), nil 1715 }) 1716 if err != nil { 1717 ec.Error(ctx, err) 1718 return graphql.Null 1719 } 1720 if resTmp == nil { 1721 return graphql.Null 1722 } 1723 res := resTmp.([]introspection.InputValue) 1724 fc.Result = res 1725 return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res) 1726 } 1727 1728 func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { 1729 defer func() { 1730 if r := recover(); r != nil { 1731 ec.Error(ctx, ec.Recover(ctx, r)) 1732 ret = graphql.Null 1733 } 1734 }() 1735 fc := &graphql.FieldContext{ 1736 Object: "__Type", 1737 Field: field, 1738 Args: nil, 1739 IsMethod: true, 1740 } 1741 1742 ctx = graphql.WithFieldContext(ctx, fc) 1743 resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { 1744 ctx = rctx // use context from middleware stack in children 1745 return obj.OfType(), nil 1746 }) 1747 if err != nil { 1748 ec.Error(ctx, err) 1749 return graphql.Null 1750 } 1751 if resTmp == nil { 1752 return graphql.Null 1753 } 1754 res := resTmp.(*introspection.Type) 1755 fc.Result = res 1756 return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res) 1757 } 1758 1759 // endregion **************************** field.gotpl ***************************** 1760 1761 // region **************************** input.gotpl ***************************** 1762 1763 func (ec *executionContext) unmarshalInputNewTodo(ctx context.Context, obj interface{}) (NewTodo, error) { 1764 var it NewTodo 1765 var asMap = obj.(map[string]interface{}) 1766 1767 for k, v := range asMap { 1768 switch k { 1769 case "text": 1770 var err error 1771 it.Text, err = ec.unmarshalNString2string(ctx, v) 1772 if err != nil { 1773 return it, err 1774 } 1775 case "userId": 1776 var err error 1777 it.UserID, err = ec.unmarshalNString2string(ctx, v) 1778 if err != nil { 1779 return it, err 1780 } 1781 } 1782 } 1783 1784 return it, nil 1785 } 1786 1787 // endregion **************************** input.gotpl ***************************** 1788 1789 // region ************************** interface.gotpl *************************** 1790 1791 // endregion ************************** interface.gotpl *************************** 1792 1793 // region **************************** object.gotpl **************************** 1794 1795 var mutationImplementors = []string{"Mutation"} 1796 1797 func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler { 1798 fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors) 1799 1800 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ 1801 Object: "Mutation", 1802 }) 1803 1804 out := graphql.NewFieldSet(fields) 1805 var invalids uint32 1806 for i, field := range fields { 1807 switch field.Name { 1808 case "__typename": 1809 out.Values[i] = graphql.MarshalString("Mutation") 1810 case "createTodo": 1811 out.Values[i] = ec._Mutation_createTodo(ctx, field) 1812 if out.Values[i] == graphql.Null { 1813 invalids++ 1814 } 1815 default: 1816 panic("unknown field " + strconv.Quote(field.Name)) 1817 } 1818 } 1819 out.Dispatch() 1820 if invalids > 0 { 1821 return graphql.Null 1822 } 1823 return out 1824 } 1825 1826 var queryImplementors = []string{"Query"} 1827 1828 func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler { 1829 fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors) 1830 1831 ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{ 1832 Object: "Query", 1833 }) 1834 1835 out := graphql.NewFieldSet(fields) 1836 var invalids uint32 1837 for i, field := range fields { 1838 switch field.Name { 1839 case "__typename": 1840 out.Values[i] = graphql.MarshalString("Query") 1841 case "todos": 1842 field := field 1843 out.Concurrently(i, func() (res graphql.Marshaler) { 1844 defer func() { 1845 if r := recover(); r != nil { 1846 ec.Error(ctx, ec.Recover(ctx, r)) 1847 } 1848 }() 1849 res = ec._Query_todos(ctx, field) 1850 if res == graphql.Null { 1851 atomic.AddUint32(&invalids, 1) 1852 } 1853 return res 1854 }) 1855 case "__type": 1856 out.Values[i] = ec._Query___type(ctx, field) 1857 case "__schema": 1858 out.Values[i] = ec._Query___schema(ctx, field) 1859 default: 1860 panic("unknown field " + strconv.Quote(field.Name)) 1861 } 1862 } 1863 out.Dispatch() 1864 if invalids > 0 { 1865 return graphql.Null 1866 } 1867 return out 1868 } 1869 1870 var todoImplementors = []string{"Todo"} 1871 1872 func (ec *executionContext) _Todo(ctx context.Context, sel ast.SelectionSet, obj *Todo) graphql.Marshaler { 1873 fields := graphql.CollectFields(ec.OperationContext, sel, todoImplementors) 1874 1875 out := graphql.NewFieldSet(fields) 1876 var invalids uint32 1877 for i, field := range fields { 1878 switch field.Name { 1879 case "__typename": 1880 out.Values[i] = graphql.MarshalString("Todo") 1881 case "id": 1882 field := field 1883 out.Concurrently(i, func() (res graphql.Marshaler) { 1884 defer func() { 1885 if r := recover(); r != nil { 1886 ec.Error(ctx, ec.Recover(ctx, r)) 1887 } 1888 }() 1889 res = ec._Todo_id(ctx, field, obj) 1890 if res == graphql.Null { 1891 atomic.AddUint32(&invalids, 1) 1892 } 1893 return res 1894 }) 1895 case "databaseId": 1896 out.Values[i] = ec._Todo_databaseId(ctx, field, obj) 1897 if out.Values[i] == graphql.Null { 1898 atomic.AddUint32(&invalids, 1) 1899 } 1900 case "text": 1901 out.Values[i] = ec._Todo_text(ctx, field, obj) 1902 if out.Values[i] == graphql.Null { 1903 atomic.AddUint32(&invalids, 1) 1904 } 1905 case "done": 1906 out.Values[i] = ec._Todo_done(ctx, field, obj) 1907 if out.Values[i] == graphql.Null { 1908 atomic.AddUint32(&invalids, 1) 1909 } 1910 case "user": 1911 out.Values[i] = ec._Todo_user(ctx, field, obj) 1912 if out.Values[i] == graphql.Null { 1913 atomic.AddUint32(&invalids, 1) 1914 } 1915 default: 1916 panic("unknown field " + strconv.Quote(field.Name)) 1917 } 1918 } 1919 out.Dispatch() 1920 if invalids > 0 { 1921 return graphql.Null 1922 } 1923 return out 1924 } 1925 1926 var userImplementors = []string{"User"} 1927 1928 func (ec *executionContext) _User(ctx context.Context, sel ast.SelectionSet, obj *User) graphql.Marshaler { 1929 fields := graphql.CollectFields(ec.OperationContext, sel, userImplementors) 1930 1931 out := graphql.NewFieldSet(fields) 1932 var invalids uint32 1933 for i, field := range fields { 1934 switch field.Name { 1935 case "__typename": 1936 out.Values[i] = graphql.MarshalString("User") 1937 case "id": 1938 out.Values[i] = ec._User_id(ctx, field, obj) 1939 if out.Values[i] == graphql.Null { 1940 invalids++ 1941 } 1942 case "name": 1943 out.Values[i] = ec._User_name(ctx, field, obj) 1944 if out.Values[i] == graphql.Null { 1945 invalids++ 1946 } 1947 default: 1948 panic("unknown field " + strconv.Quote(field.Name)) 1949 } 1950 } 1951 out.Dispatch() 1952 if invalids > 0 { 1953 return graphql.Null 1954 } 1955 return out 1956 } 1957 1958 var __DirectiveImplementors = []string{"__Directive"} 1959 1960 func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler { 1961 fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors) 1962 1963 out := graphql.NewFieldSet(fields) 1964 var invalids uint32 1965 for i, field := range fields { 1966 switch field.Name { 1967 case "__typename": 1968 out.Values[i] = graphql.MarshalString("__Directive") 1969 case "name": 1970 out.Values[i] = ec.___Directive_name(ctx, field, obj) 1971 if out.Values[i] == graphql.Null { 1972 invalids++ 1973 } 1974 case "description": 1975 out.Values[i] = ec.___Directive_description(ctx, field, obj) 1976 case "locations": 1977 out.Values[i] = ec.___Directive_locations(ctx, field, obj) 1978 if out.Values[i] == graphql.Null { 1979 invalids++ 1980 } 1981 case "args": 1982 out.Values[i] = ec.___Directive_args(ctx, field, obj) 1983 if out.Values[i] == graphql.Null { 1984 invalids++ 1985 } 1986 default: 1987 panic("unknown field " + strconv.Quote(field.Name)) 1988 } 1989 } 1990 out.Dispatch() 1991 if invalids > 0 { 1992 return graphql.Null 1993 } 1994 return out 1995 } 1996 1997 var __EnumValueImplementors = []string{"__EnumValue"} 1998 1999 func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler { 2000 fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors) 2001 2002 out := graphql.NewFieldSet(fields) 2003 var invalids uint32 2004 for i, field := range fields { 2005 switch field.Name { 2006 case "__typename": 2007 out.Values[i] = graphql.MarshalString("__EnumValue") 2008 case "name": 2009 out.Values[i] = ec.___EnumValue_name(ctx, field, obj) 2010 if out.Values[i] == graphql.Null { 2011 invalids++ 2012 } 2013 case "description": 2014 out.Values[i] = ec.___EnumValue_description(ctx, field, obj) 2015 case "isDeprecated": 2016 out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj) 2017 if out.Values[i] == graphql.Null { 2018 invalids++ 2019 } 2020 case "deprecationReason": 2021 out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj) 2022 default: 2023 panic("unknown field " + strconv.Quote(field.Name)) 2024 } 2025 } 2026 out.Dispatch() 2027 if invalids > 0 { 2028 return graphql.Null 2029 } 2030 return out 2031 } 2032 2033 var __FieldImplementors = []string{"__Field"} 2034 2035 func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler { 2036 fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors) 2037 2038 out := graphql.NewFieldSet(fields) 2039 var invalids uint32 2040 for i, field := range fields { 2041 switch field.Name { 2042 case "__typename": 2043 out.Values[i] = graphql.MarshalString("__Field") 2044 case "name": 2045 out.Values[i] = ec.___Field_name(ctx, field, obj) 2046 if out.Values[i] == graphql.Null { 2047 invalids++ 2048 } 2049 case "description": 2050 out.Values[i] = ec.___Field_description(ctx, field, obj) 2051 case "args": 2052 out.Values[i] = ec.___Field_args(ctx, field, obj) 2053 if out.Values[i] == graphql.Null { 2054 invalids++ 2055 } 2056 case "type": 2057 out.Values[i] = ec.___Field_type(ctx, field, obj) 2058 if out.Values[i] == graphql.Null { 2059 invalids++ 2060 } 2061 case "isDeprecated": 2062 out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj) 2063 if out.Values[i] == graphql.Null { 2064 invalids++ 2065 } 2066 case "deprecationReason": 2067 out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj) 2068 default: 2069 panic("unknown field " + strconv.Quote(field.Name)) 2070 } 2071 } 2072 out.Dispatch() 2073 if invalids > 0 { 2074 return graphql.Null 2075 } 2076 return out 2077 } 2078 2079 var __InputValueImplementors = []string{"__InputValue"} 2080 2081 func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler { 2082 fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors) 2083 2084 out := graphql.NewFieldSet(fields) 2085 var invalids uint32 2086 for i, field := range fields { 2087 switch field.Name { 2088 case "__typename": 2089 out.Values[i] = graphql.MarshalString("__InputValue") 2090 case "name": 2091 out.Values[i] = ec.___InputValue_name(ctx, field, obj) 2092 if out.Values[i] == graphql.Null { 2093 invalids++ 2094 } 2095 case "description": 2096 out.Values[i] = ec.___InputValue_description(ctx, field, obj) 2097 case "type": 2098 out.Values[i] = ec.___InputValue_type(ctx, field, obj) 2099 if out.Values[i] == graphql.Null { 2100 invalids++ 2101 } 2102 case "defaultValue": 2103 out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj) 2104 default: 2105 panic("unknown field " + strconv.Quote(field.Name)) 2106 } 2107 } 2108 out.Dispatch() 2109 if invalids > 0 { 2110 return graphql.Null 2111 } 2112 return out 2113 } 2114 2115 var __SchemaImplementors = []string{"__Schema"} 2116 2117 func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler { 2118 fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors) 2119 2120 out := graphql.NewFieldSet(fields) 2121 var invalids uint32 2122 for i, field := range fields { 2123 switch field.Name { 2124 case "__typename": 2125 out.Values[i] = graphql.MarshalString("__Schema") 2126 case "types": 2127 out.Values[i] = ec.___Schema_types(ctx, field, obj) 2128 if out.Values[i] == graphql.Null { 2129 invalids++ 2130 } 2131 case "queryType": 2132 out.Values[i] = ec.___Schema_queryType(ctx, field, obj) 2133 if out.Values[i] == graphql.Null { 2134 invalids++ 2135 } 2136 case "mutationType": 2137 out.Values[i] = ec.___Schema_mutationType(ctx, field, obj) 2138 case "subscriptionType": 2139 out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj) 2140 case "directives": 2141 out.Values[i] = ec.___Schema_directives(ctx, field, obj) 2142 if out.Values[i] == graphql.Null { 2143 invalids++ 2144 } 2145 default: 2146 panic("unknown field " + strconv.Quote(field.Name)) 2147 } 2148 } 2149 out.Dispatch() 2150 if invalids > 0 { 2151 return graphql.Null 2152 } 2153 return out 2154 } 2155 2156 var __TypeImplementors = []string{"__Type"} 2157 2158 func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler { 2159 fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors) 2160 2161 out := graphql.NewFieldSet(fields) 2162 var invalids uint32 2163 for i, field := range fields { 2164 switch field.Name { 2165 case "__typename": 2166 out.Values[i] = graphql.MarshalString("__Type") 2167 case "kind": 2168 out.Values[i] = ec.___Type_kind(ctx, field, obj) 2169 if out.Values[i] == graphql.Null { 2170 invalids++ 2171 } 2172 case "name": 2173 out.Values[i] = ec.___Type_name(ctx, field, obj) 2174 case "description": 2175 out.Values[i] = ec.___Type_description(ctx, field, obj) 2176 case "fields": 2177 out.Values[i] = ec.___Type_fields(ctx, field, obj) 2178 case "interfaces": 2179 out.Values[i] = ec.___Type_interfaces(ctx, field, obj) 2180 case "possibleTypes": 2181 out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj) 2182 case "enumValues": 2183 out.Values[i] = ec.___Type_enumValues(ctx, field, obj) 2184 case "inputFields": 2185 out.Values[i] = ec.___Type_inputFields(ctx, field, obj) 2186 case "ofType": 2187 out.Values[i] = ec.___Type_ofType(ctx, field, obj) 2188 default: 2189 panic("unknown field " + strconv.Quote(field.Name)) 2190 } 2191 } 2192 out.Dispatch() 2193 if invalids > 0 { 2194 return graphql.Null 2195 } 2196 return out 2197 } 2198 2199 // endregion **************************** object.gotpl **************************** 2200 2201 // region ***************************** type.gotpl ***************************** 2202 2203 func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) { 2204 return graphql.UnmarshalBoolean(v) 2205 } 2206 2207 func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler { 2208 res := graphql.MarshalBoolean(v) 2209 if res == graphql.Null { 2210 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 2211 ec.Errorf(ctx, "must not be null") 2212 } 2213 } 2214 return res 2215 } 2216 2217 func (ec *executionContext) unmarshalNID2string(ctx context.Context, v interface{}) (string, error) { 2218 return graphql.UnmarshalID(v) 2219 } 2220 2221 func (ec *executionContext) marshalNID2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler { 2222 res := graphql.MarshalID(v) 2223 if res == graphql.Null { 2224 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 2225 ec.Errorf(ctx, "must not be null") 2226 } 2227 } 2228 return res 2229 } 2230 2231 func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) { 2232 return graphql.UnmarshalInt(v) 2233 } 2234 2235 func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler { 2236 res := graphql.MarshalInt(v) 2237 if res == graphql.Null { 2238 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 2239 ec.Errorf(ctx, "must not be null") 2240 } 2241 } 2242 return res 2243 } 2244 2245 func (ec *executionContext) unmarshalNNewTodo2githubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐNewTodo(ctx context.Context, v interface{}) (NewTodo, error) { 2246 return ec.unmarshalInputNewTodo(ctx, v) 2247 } 2248 2249 func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) { 2250 return graphql.UnmarshalString(v) 2251 } 2252 2253 func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler { 2254 res := graphql.MarshalString(v) 2255 if res == graphql.Null { 2256 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 2257 ec.Errorf(ctx, "must not be null") 2258 } 2259 } 2260 return res 2261 } 2262 2263 func (ec *executionContext) marshalNTodo2githubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐTodo(ctx context.Context, sel ast.SelectionSet, v Todo) graphql.Marshaler { 2264 return ec._Todo(ctx, sel, &v) 2265 } 2266 2267 func (ec *executionContext) marshalNTodo2ᚕᚖgithubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐTodoᚄ(ctx context.Context, sel ast.SelectionSet, v []*Todo) graphql.Marshaler { 2268 ret := make(graphql.Array, len(v)) 2269 var wg sync.WaitGroup 2270 isLen1 := len(v) == 1 2271 if !isLen1 { 2272 wg.Add(len(v)) 2273 } 2274 for i := range v { 2275 i := i 2276 fc := &graphql.FieldContext{ 2277 Index: &i, 2278 Result: &v[i], 2279 } 2280 ctx := graphql.WithFieldContext(ctx, fc) 2281 f := func(i int) { 2282 defer func() { 2283 if r := recover(); r != nil { 2284 ec.Error(ctx, ec.Recover(ctx, r)) 2285 ret = nil 2286 } 2287 }() 2288 if !isLen1 { 2289 defer wg.Done() 2290 } 2291 ret[i] = ec.marshalNTodo2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐTodo(ctx, sel, v[i]) 2292 } 2293 if isLen1 { 2294 f(i) 2295 } else { 2296 go f(i) 2297 } 2298 2299 } 2300 wg.Wait() 2301 return ret 2302 } 2303 2304 func (ec *executionContext) marshalNTodo2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐTodo(ctx context.Context, sel ast.SelectionSet, v *Todo) graphql.Marshaler { 2305 if v == nil { 2306 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 2307 ec.Errorf(ctx, "must not be null") 2308 } 2309 return graphql.Null 2310 } 2311 return ec._Todo(ctx, sel, v) 2312 } 2313 2314 func (ec *executionContext) marshalNUser2githubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐUser(ctx context.Context, sel ast.SelectionSet, v User) graphql.Marshaler { 2315 return ec._User(ctx, sel, &v) 2316 } 2317 2318 func (ec *executionContext) marshalNUser2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋexampleᚋconfigᚐUser(ctx context.Context, sel ast.SelectionSet, v *User) graphql.Marshaler { 2319 if v == nil { 2320 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 2321 ec.Errorf(ctx, "must not be null") 2322 } 2323 return graphql.Null 2324 } 2325 return ec._User(ctx, sel, v) 2326 } 2327 2328 func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler { 2329 return ec.___Directive(ctx, sel, &v) 2330 } 2331 2332 func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler { 2333 ret := make(graphql.Array, len(v)) 2334 var wg sync.WaitGroup 2335 isLen1 := len(v) == 1 2336 if !isLen1 { 2337 wg.Add(len(v)) 2338 } 2339 for i := range v { 2340 i := i 2341 fc := &graphql.FieldContext{ 2342 Index: &i, 2343 Result: &v[i], 2344 } 2345 ctx := graphql.WithFieldContext(ctx, fc) 2346 f := func(i int) { 2347 defer func() { 2348 if r := recover(); r != nil { 2349 ec.Error(ctx, ec.Recover(ctx, r)) 2350 ret = nil 2351 } 2352 }() 2353 if !isLen1 { 2354 defer wg.Done() 2355 } 2356 ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i]) 2357 } 2358 if isLen1 { 2359 f(i) 2360 } else { 2361 go f(i) 2362 } 2363 2364 } 2365 wg.Wait() 2366 return ret 2367 } 2368 2369 func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) { 2370 return graphql.UnmarshalString(v) 2371 } 2372 2373 func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler { 2374 res := graphql.MarshalString(v) 2375 if res == graphql.Null { 2376 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 2377 ec.Errorf(ctx, "must not be null") 2378 } 2379 } 2380 return res 2381 } 2382 2383 func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) { 2384 var vSlice []interface{} 2385 if v != nil { 2386 if tmp1, ok := v.([]interface{}); ok { 2387 vSlice = tmp1 2388 } else { 2389 vSlice = []interface{}{v} 2390 } 2391 } 2392 var err error 2393 res := make([]string, len(vSlice)) 2394 for i := range vSlice { 2395 res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i]) 2396 if err != nil { 2397 return nil, err 2398 } 2399 } 2400 return res, nil 2401 } 2402 2403 func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler { 2404 ret := make(graphql.Array, len(v)) 2405 var wg sync.WaitGroup 2406 isLen1 := len(v) == 1 2407 if !isLen1 { 2408 wg.Add(len(v)) 2409 } 2410 for i := range v { 2411 i := i 2412 fc := &graphql.FieldContext{ 2413 Index: &i, 2414 Result: &v[i], 2415 } 2416 ctx := graphql.WithFieldContext(ctx, fc) 2417 f := func(i int) { 2418 defer func() { 2419 if r := recover(); r != nil { 2420 ec.Error(ctx, ec.Recover(ctx, r)) 2421 ret = nil 2422 } 2423 }() 2424 if !isLen1 { 2425 defer wg.Done() 2426 } 2427 ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i]) 2428 } 2429 if isLen1 { 2430 f(i) 2431 } else { 2432 go f(i) 2433 } 2434 2435 } 2436 wg.Wait() 2437 return ret 2438 } 2439 2440 func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler { 2441 return ec.___EnumValue(ctx, sel, &v) 2442 } 2443 2444 func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler { 2445 return ec.___Field(ctx, sel, &v) 2446 } 2447 2448 func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler { 2449 return ec.___InputValue(ctx, sel, &v) 2450 } 2451 2452 func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler { 2453 ret := make(graphql.Array, len(v)) 2454 var wg sync.WaitGroup 2455 isLen1 := len(v) == 1 2456 if !isLen1 { 2457 wg.Add(len(v)) 2458 } 2459 for i := range v { 2460 i := i 2461 fc := &graphql.FieldContext{ 2462 Index: &i, 2463 Result: &v[i], 2464 } 2465 ctx := graphql.WithFieldContext(ctx, fc) 2466 f := func(i int) { 2467 defer func() { 2468 if r := recover(); r != nil { 2469 ec.Error(ctx, ec.Recover(ctx, r)) 2470 ret = nil 2471 } 2472 }() 2473 if !isLen1 { 2474 defer wg.Done() 2475 } 2476 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i]) 2477 } 2478 if isLen1 { 2479 f(i) 2480 } else { 2481 go f(i) 2482 } 2483 2484 } 2485 wg.Wait() 2486 return ret 2487 } 2488 2489 func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler { 2490 return ec.___Type(ctx, sel, &v) 2491 } 2492 2493 func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler { 2494 ret := make(graphql.Array, len(v)) 2495 var wg sync.WaitGroup 2496 isLen1 := len(v) == 1 2497 if !isLen1 { 2498 wg.Add(len(v)) 2499 } 2500 for i := range v { 2501 i := i 2502 fc := &graphql.FieldContext{ 2503 Index: &i, 2504 Result: &v[i], 2505 } 2506 ctx := graphql.WithFieldContext(ctx, fc) 2507 f := func(i int) { 2508 defer func() { 2509 if r := recover(); r != nil { 2510 ec.Error(ctx, ec.Recover(ctx, r)) 2511 ret = nil 2512 } 2513 }() 2514 if !isLen1 { 2515 defer wg.Done() 2516 } 2517 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i]) 2518 } 2519 if isLen1 { 2520 f(i) 2521 } else { 2522 go f(i) 2523 } 2524 2525 } 2526 wg.Wait() 2527 return ret 2528 } 2529 2530 func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler { 2531 if v == nil { 2532 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 2533 ec.Errorf(ctx, "must not be null") 2534 } 2535 return graphql.Null 2536 } 2537 return ec.___Type(ctx, sel, v) 2538 } 2539 2540 func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) { 2541 return graphql.UnmarshalString(v) 2542 } 2543 2544 func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler { 2545 res := graphql.MarshalString(v) 2546 if res == graphql.Null { 2547 if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { 2548 ec.Errorf(ctx, "must not be null") 2549 } 2550 } 2551 return res 2552 } 2553 2554 func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) { 2555 return graphql.UnmarshalBoolean(v) 2556 } 2557 2558 func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler { 2559 return graphql.MarshalBoolean(v) 2560 } 2561 2562 func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) { 2563 if v == nil { 2564 return nil, nil 2565 } 2566 res, err := ec.unmarshalOBoolean2bool(ctx, v) 2567 return &res, err 2568 } 2569 2570 func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler { 2571 if v == nil { 2572 return graphql.Null 2573 } 2574 return ec.marshalOBoolean2bool(ctx, sel, *v) 2575 } 2576 2577 func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) { 2578 return graphql.UnmarshalString(v) 2579 } 2580 2581 func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler { 2582 return graphql.MarshalString(v) 2583 } 2584 2585 func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) { 2586 var vSlice []interface{} 2587 if v != nil { 2588 if tmp1, ok := v.([]interface{}); ok { 2589 vSlice = tmp1 2590 } else { 2591 vSlice = []interface{}{v} 2592 } 2593 } 2594 var err error 2595 res := make([]string, len(vSlice)) 2596 for i := range vSlice { 2597 res[i], err = ec.unmarshalNString2string(ctx, vSlice[i]) 2598 if err != nil { 2599 return nil, err 2600 } 2601 } 2602 return res, nil 2603 } 2604 2605 func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler { 2606 if v == nil { 2607 return graphql.Null 2608 } 2609 ret := make(graphql.Array, len(v)) 2610 for i := range v { 2611 ret[i] = ec.marshalNString2string(ctx, sel, v[i]) 2612 } 2613 2614 return ret 2615 } 2616 2617 func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) { 2618 if v == nil { 2619 return nil, nil 2620 } 2621 res, err := ec.unmarshalOString2string(ctx, v) 2622 return &res, err 2623 } 2624 2625 func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler { 2626 if v == nil { 2627 return graphql.Null 2628 } 2629 return ec.marshalOString2string(ctx, sel, *v) 2630 } 2631 2632 func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler { 2633 if v == nil { 2634 return graphql.Null 2635 } 2636 ret := make(graphql.Array, len(v)) 2637 var wg sync.WaitGroup 2638 isLen1 := len(v) == 1 2639 if !isLen1 { 2640 wg.Add(len(v)) 2641 } 2642 for i := range v { 2643 i := i 2644 fc := &graphql.FieldContext{ 2645 Index: &i, 2646 Result: &v[i], 2647 } 2648 ctx := graphql.WithFieldContext(ctx, fc) 2649 f := func(i int) { 2650 defer func() { 2651 if r := recover(); r != nil { 2652 ec.Error(ctx, ec.Recover(ctx, r)) 2653 ret = nil 2654 } 2655 }() 2656 if !isLen1 { 2657 defer wg.Done() 2658 } 2659 ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i]) 2660 } 2661 if isLen1 { 2662 f(i) 2663 } else { 2664 go f(i) 2665 } 2666 2667 } 2668 wg.Wait() 2669 return ret 2670 } 2671 2672 func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler { 2673 if v == nil { 2674 return graphql.Null 2675 } 2676 ret := make(graphql.Array, len(v)) 2677 var wg sync.WaitGroup 2678 isLen1 := len(v) == 1 2679 if !isLen1 { 2680 wg.Add(len(v)) 2681 } 2682 for i := range v { 2683 i := i 2684 fc := &graphql.FieldContext{ 2685 Index: &i, 2686 Result: &v[i], 2687 } 2688 ctx := graphql.WithFieldContext(ctx, fc) 2689 f := func(i int) { 2690 defer func() { 2691 if r := recover(); r != nil { 2692 ec.Error(ctx, ec.Recover(ctx, r)) 2693 ret = nil 2694 } 2695 }() 2696 if !isLen1 { 2697 defer wg.Done() 2698 } 2699 ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i]) 2700 } 2701 if isLen1 { 2702 f(i) 2703 } else { 2704 go f(i) 2705 } 2706 2707 } 2708 wg.Wait() 2709 return ret 2710 } 2711 2712 func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler { 2713 if v == nil { 2714 return graphql.Null 2715 } 2716 ret := make(graphql.Array, len(v)) 2717 var wg sync.WaitGroup 2718 isLen1 := len(v) == 1 2719 if !isLen1 { 2720 wg.Add(len(v)) 2721 } 2722 for i := range v { 2723 i := i 2724 fc := &graphql.FieldContext{ 2725 Index: &i, 2726 Result: &v[i], 2727 } 2728 ctx := graphql.WithFieldContext(ctx, fc) 2729 f := func(i int) { 2730 defer func() { 2731 if r := recover(); r != nil { 2732 ec.Error(ctx, ec.Recover(ctx, r)) 2733 ret = nil 2734 } 2735 }() 2736 if !isLen1 { 2737 defer wg.Done() 2738 } 2739 ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i]) 2740 } 2741 if isLen1 { 2742 f(i) 2743 } else { 2744 go f(i) 2745 } 2746 2747 } 2748 wg.Wait() 2749 return ret 2750 } 2751 2752 func (ec *executionContext) marshalO__Schema2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler { 2753 return ec.___Schema(ctx, sel, &v) 2754 } 2755 2756 func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler { 2757 if v == nil { 2758 return graphql.Null 2759 } 2760 return ec.___Schema(ctx, sel, v) 2761 } 2762 2763 func (ec *executionContext) marshalO__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler { 2764 return ec.___Type(ctx, sel, &v) 2765 } 2766 2767 func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler { 2768 if v == nil { 2769 return graphql.Null 2770 } 2771 ret := make(graphql.Array, len(v)) 2772 var wg sync.WaitGroup 2773 isLen1 := len(v) == 1 2774 if !isLen1 { 2775 wg.Add(len(v)) 2776 } 2777 for i := range v { 2778 i := i 2779 fc := &graphql.FieldContext{ 2780 Index: &i, 2781 Result: &v[i], 2782 } 2783 ctx := graphql.WithFieldContext(ctx, fc) 2784 f := func(i int) { 2785 defer func() { 2786 if r := recover(); r != nil { 2787 ec.Error(ctx, ec.Recover(ctx, r)) 2788 ret = nil 2789 } 2790 }() 2791 if !isLen1 { 2792 defer wg.Done() 2793 } 2794 ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i]) 2795 } 2796 if isLen1 { 2797 f(i) 2798 } else { 2799 go f(i) 2800 } 2801 2802 } 2803 wg.Wait() 2804 return ret 2805 } 2806 2807 func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler { 2808 if v == nil { 2809 return graphql.Null 2810 } 2811 return ec.___Type(ctx, sel, v) 2812 } 2813 2814 // endregion ***************************** type.gotpl *****************************