1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
   2
   3package graph
   4
   5import (
   6	"bytes"
   7	"context"
   8	"errors"
   9	"fmt"
  10	"strconv"
  11	"sync"
  12	"time"
  13
  14	"github.com/99designs/gqlgen/graphql"
  15	"github.com/99designs/gqlgen/graphql/introspection"
  16	"github.com/MichaelMure/git-bug/bug"
  17	"github.com/MichaelMure/git-bug/graphql/models"
  18	"github.com/MichaelMure/git-bug/identity"
  19	"github.com/MichaelMure/git-bug/util/git"
  20	"github.com/vektah/gqlparser"
  21	"github.com/vektah/gqlparser/ast"
  22)
  23
  24// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
  25func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
  26	return &executableSchema{
  27		resolvers:  cfg.Resolvers,
  28		directives: cfg.Directives,
  29		complexity: cfg.Complexity,
  30	}
  31}
  32
  33type Config struct {
  34	Resolvers  ResolverRoot
  35	Directives DirectiveRoot
  36	Complexity ComplexityRoot
  37}
  38
  39type ResolverRoot interface {
  40	AddCommentOperation() AddCommentOperationResolver
  41	AddCommentTimelineItem() AddCommentTimelineItemResolver
  42	Bug() BugResolver
  43	CommentHistoryStep() CommentHistoryStepResolver
  44	CreateOperation() CreateOperationResolver
  45	CreateTimelineItem() CreateTimelineItemResolver
  46	EditCommentOperation() EditCommentOperationResolver
  47	Identity() IdentityResolver
  48	LabelChangeOperation() LabelChangeOperationResolver
  49	LabelChangeTimelineItem() LabelChangeTimelineItemResolver
  50	Mutation() MutationResolver
  51	Query() QueryResolver
  52	Repository() RepositoryResolver
  53	SetStatusOperation() SetStatusOperationResolver
  54	SetStatusTimelineItem() SetStatusTimelineItemResolver
  55	SetTitleOperation() SetTitleOperationResolver
  56	SetTitleTimelineItem() SetTitleTimelineItemResolver
  57}
  58
  59type DirectiveRoot struct {
  60}
  61
  62type ComplexityRoot struct {
  63	AddCommentOperation struct {
  64		Hash    func(childComplexity int) int
  65		Author  func(childComplexity int) int
  66		Date    func(childComplexity int) int
  67		Message func(childComplexity int) int
  68		Files   func(childComplexity int) int
  69	}
  70
  71	AddCommentTimelineItem struct {
  72		Hash           func(childComplexity int) int
  73		Author         func(childComplexity int) int
  74		Message        func(childComplexity int) int
  75		MessageIsEmpty func(childComplexity int) int
  76		Files          func(childComplexity int) int
  77		CreatedAt      func(childComplexity int) int
  78		LastEdit       func(childComplexity int) int
  79		Edited         func(childComplexity int) int
  80		History        func(childComplexity int) int
  81	}
  82
  83	Bug struct {
  84		Id         func(childComplexity int) int
  85		HumanId    func(childComplexity int) int
  86		Status     func(childComplexity int) int
  87		Title      func(childComplexity int) int
  88		Labels     func(childComplexity int) int
  89		Author     func(childComplexity int) int
  90		CreatedAt  func(childComplexity int) int
  91		LastEdit   func(childComplexity int) int
  92		Comments   func(childComplexity int, after *string, before *string, first *int, last *int) int
  93		Timeline   func(childComplexity int, after *string, before *string, first *int, last *int) int
  94		Operations func(childComplexity int, after *string, before *string, first *int, last *int) int
  95	}
  96
  97	BugConnection struct {
  98		Edges      func(childComplexity int) int
  99		Nodes      func(childComplexity int) int
 100		PageInfo   func(childComplexity int) int
 101		TotalCount func(childComplexity int) int
 102	}
 103
 104	BugEdge struct {
 105		Cursor func(childComplexity int) int
 106		Node   func(childComplexity int) int
 107	}
 108
 109	Comment struct {
 110		Author  func(childComplexity int) int
 111		Message func(childComplexity int) int
 112		Files   func(childComplexity int) int
 113	}
 114
 115	CommentConnection struct {
 116		Edges      func(childComplexity int) int
 117		Nodes      func(childComplexity int) int
 118		PageInfo   func(childComplexity int) int
 119		TotalCount func(childComplexity int) int
 120	}
 121
 122	CommentEdge struct {
 123		Cursor func(childComplexity int) int
 124		Node   func(childComplexity int) int
 125	}
 126
 127	CommentHistoryStep struct {
 128		Message func(childComplexity int) int
 129		Date    func(childComplexity int) int
 130	}
 131
 132	CreateOperation struct {
 133		Hash    func(childComplexity int) int
 134		Author  func(childComplexity int) int
 135		Date    func(childComplexity int) int
 136		Title   func(childComplexity int) int
 137		Message func(childComplexity int) int
 138		Files   func(childComplexity int) int
 139	}
 140
 141	CreateTimelineItem struct {
 142		Hash           func(childComplexity int) int
 143		Author         func(childComplexity int) int
 144		Message        func(childComplexity int) int
 145		MessageIsEmpty func(childComplexity int) int
 146		Files          func(childComplexity int) int
 147		CreatedAt      func(childComplexity int) int
 148		LastEdit       func(childComplexity int) int
 149		Edited         func(childComplexity int) int
 150		History        func(childComplexity int) int
 151	}
 152
 153	EditCommentOperation struct {
 154		Hash    func(childComplexity int) int
 155		Author  func(childComplexity int) int
 156		Date    func(childComplexity int) int
 157		Target  func(childComplexity int) int
 158		Message func(childComplexity int) int
 159		Files   func(childComplexity int) int
 160	}
 161
 162	Identity struct {
 163		Id          func(childComplexity int) int
 164		HumanId     func(childComplexity int) int
 165		Name        func(childComplexity int) int
 166		Email       func(childComplexity int) int
 167		Login       func(childComplexity int) int
 168		DisplayName func(childComplexity int) int
 169		AvatarUrl   func(childComplexity int) int
 170		IsProtected func(childComplexity int) int
 171	}
 172
 173	IdentityConnection struct {
 174		Edges      func(childComplexity int) int
 175		Nodes      func(childComplexity int) int
 176		PageInfo   func(childComplexity int) int
 177		TotalCount func(childComplexity int) int
 178	}
 179
 180	IdentityEdge struct {
 181		Cursor func(childComplexity int) int
 182		Node   func(childComplexity int) int
 183	}
 184
 185	LabelChangeOperation struct {
 186		Hash    func(childComplexity int) int
 187		Author  func(childComplexity int) int
 188		Date    func(childComplexity int) int
 189		Added   func(childComplexity int) int
 190		Removed func(childComplexity int) int
 191	}
 192
 193	LabelChangeTimelineItem struct {
 194		Hash    func(childComplexity int) int
 195		Author  func(childComplexity int) int
 196		Date    func(childComplexity int) int
 197		Added   func(childComplexity int) int
 198		Removed func(childComplexity int) int
 199	}
 200
 201	Mutation struct {
 202		NewBug       func(childComplexity int, repoRef *string, title string, message string, files []git.Hash) int
 203		AddComment   func(childComplexity int, repoRef *string, prefix string, message string, files []git.Hash) int
 204		ChangeLabels func(childComplexity int, repoRef *string, prefix string, added []string, removed []string) int
 205		Open         func(childComplexity int, repoRef *string, prefix string) int
 206		Close        func(childComplexity int, repoRef *string, prefix string) int
 207		SetTitle     func(childComplexity int, repoRef *string, prefix string, title string) int
 208		Commit       func(childComplexity int, repoRef *string, prefix string) int
 209	}
 210
 211	OperationConnection struct {
 212		Edges      func(childComplexity int) int
 213		Nodes      func(childComplexity int) int
 214		PageInfo   func(childComplexity int) int
 215		TotalCount func(childComplexity int) int
 216	}
 217
 218	OperationEdge struct {
 219		Cursor func(childComplexity int) int
 220		Node   func(childComplexity int) int
 221	}
 222
 223	PageInfo struct {
 224		HasNextPage     func(childComplexity int) int
 225		HasPreviousPage func(childComplexity int) int
 226		StartCursor     func(childComplexity int) int
 227		EndCursor       func(childComplexity int) int
 228	}
 229
 230	Query struct {
 231		DefaultRepository func(childComplexity int) int
 232		Repository        func(childComplexity int, id string) int
 233	}
 234
 235	Repository struct {
 236		AllBugs       func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
 237		Bug           func(childComplexity int, prefix string) int
 238		AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
 239		Identity      func(childComplexity int, prefix string) int
 240		UserIdentity  func(childComplexity int) int
 241	}
 242
 243	SetStatusOperation struct {
 244		Hash   func(childComplexity int) int
 245		Author func(childComplexity int) int
 246		Date   func(childComplexity int) int
 247		Status func(childComplexity int) int
 248	}
 249
 250	SetStatusTimelineItem struct {
 251		Hash   func(childComplexity int) int
 252		Author func(childComplexity int) int
 253		Date   func(childComplexity int) int
 254		Status func(childComplexity int) int
 255	}
 256
 257	SetTitleOperation struct {
 258		Hash   func(childComplexity int) int
 259		Author func(childComplexity int) int
 260		Date   func(childComplexity int) int
 261		Title  func(childComplexity int) int
 262		Was    func(childComplexity int) int
 263	}
 264
 265	SetTitleTimelineItem struct {
 266		Hash   func(childComplexity int) int
 267		Author func(childComplexity int) int
 268		Date   func(childComplexity int) int
 269		Title  func(childComplexity int) int
 270		Was    func(childComplexity int) int
 271	}
 272
 273	TimelineItemConnection struct {
 274		Edges      func(childComplexity int) int
 275		Nodes      func(childComplexity int) int
 276		PageInfo   func(childComplexity int) int
 277		TotalCount func(childComplexity int) int
 278	}
 279
 280	TimelineItemEdge struct {
 281		Cursor func(childComplexity int) int
 282		Node   func(childComplexity int) int
 283	}
 284}
 285
 286type AddCommentOperationResolver interface {
 287	Date(ctx context.Context, obj *bug.AddCommentOperation) (time.Time, error)
 288}
 289type AddCommentTimelineItemResolver interface {
 290	CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (time.Time, error)
 291	LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (time.Time, error)
 292}
 293type BugResolver interface {
 294	Status(ctx context.Context, obj *bug.Snapshot) (models.Status, error)
 295
 296	LastEdit(ctx context.Context, obj *bug.Snapshot) (time.Time, error)
 297	Comments(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.CommentConnection, error)
 298	Timeline(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.TimelineItemConnection, error)
 299	Operations(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.OperationConnection, error)
 300}
 301type CommentHistoryStepResolver interface {
 302	Date(ctx context.Context, obj *bug.CommentHistoryStep) (time.Time, error)
 303}
 304type CreateOperationResolver interface {
 305	Date(ctx context.Context, obj *bug.CreateOperation) (time.Time, error)
 306}
 307type CreateTimelineItemResolver interface {
 308	CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (time.Time, error)
 309	LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (time.Time, error)
 310}
 311type EditCommentOperationResolver interface {
 312	Date(ctx context.Context, obj *bug.EditCommentOperation) (time.Time, error)
 313}
 314type IdentityResolver interface {
 315	ID(ctx context.Context, obj *identity.Interface) (string, error)
 316	HumanID(ctx context.Context, obj *identity.Interface) (string, error)
 317	Name(ctx context.Context, obj *identity.Interface) (*string, error)
 318	Email(ctx context.Context, obj *identity.Interface) (*string, error)
 319	Login(ctx context.Context, obj *identity.Interface) (*string, error)
 320	DisplayName(ctx context.Context, obj *identity.Interface) (string, error)
 321	AvatarURL(ctx context.Context, obj *identity.Interface) (*string, error)
 322	IsProtected(ctx context.Context, obj *identity.Interface) (bool, error)
 323}
 324type LabelChangeOperationResolver interface {
 325	Date(ctx context.Context, obj *bug.LabelChangeOperation) (time.Time, error)
 326}
 327type LabelChangeTimelineItemResolver interface {
 328	Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (time.Time, error)
 329}
 330type MutationResolver interface {
 331	NewBug(ctx context.Context, repoRef *string, title string, message string, files []git.Hash) (bug.Snapshot, error)
 332	AddComment(ctx context.Context, repoRef *string, prefix string, message string, files []git.Hash) (bug.Snapshot, error)
 333	ChangeLabels(ctx context.Context, repoRef *string, prefix string, added []string, removed []string) (bug.Snapshot, error)
 334	Open(ctx context.Context, repoRef *string, prefix string) (bug.Snapshot, error)
 335	Close(ctx context.Context, repoRef *string, prefix string) (bug.Snapshot, error)
 336	SetTitle(ctx context.Context, repoRef *string, prefix string, title string) (bug.Snapshot, error)
 337	Commit(ctx context.Context, repoRef *string, prefix string) (bug.Snapshot, error)
 338}
 339type QueryResolver interface {
 340	DefaultRepository(ctx context.Context) (*models.Repository, error)
 341	Repository(ctx context.Context, id string) (*models.Repository, error)
 342}
 343type RepositoryResolver interface {
 344	AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (models.BugConnection, error)
 345	Bug(ctx context.Context, obj *models.Repository, prefix string) (*bug.Snapshot, error)
 346	AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (models.IdentityConnection, error)
 347	Identity(ctx context.Context, obj *models.Repository, prefix string) (*identity.Interface, error)
 348	UserIdentity(ctx context.Context, obj *models.Repository) (*identity.Interface, error)
 349}
 350type SetStatusOperationResolver interface {
 351	Date(ctx context.Context, obj *bug.SetStatusOperation) (time.Time, error)
 352	Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
 353}
 354type SetStatusTimelineItemResolver interface {
 355	Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (time.Time, error)
 356	Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
 357}
 358type SetTitleOperationResolver interface {
 359	Date(ctx context.Context, obj *bug.SetTitleOperation) (time.Time, error)
 360}
 361type SetTitleTimelineItemResolver interface {
 362	Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (time.Time, error)
 363}
 364
 365func field_Bug_comments_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 366	args := map[string]interface{}{}
 367	var arg0 *string
 368	if tmp, ok := rawArgs["after"]; ok {
 369		var err error
 370		var ptr1 string
 371		if tmp != nil {
 372			ptr1, err = graphql.UnmarshalString(tmp)
 373			arg0 = &ptr1
 374		}
 375
 376		if err != nil {
 377			return nil, err
 378		}
 379	}
 380	args["after"] = arg0
 381	var arg1 *string
 382	if tmp, ok := rawArgs["before"]; ok {
 383		var err error
 384		var ptr1 string
 385		if tmp != nil {
 386			ptr1, err = graphql.UnmarshalString(tmp)
 387			arg1 = &ptr1
 388		}
 389
 390		if err != nil {
 391			return nil, err
 392		}
 393	}
 394	args["before"] = arg1
 395	var arg2 *int
 396	if tmp, ok := rawArgs["first"]; ok {
 397		var err error
 398		var ptr1 int
 399		if tmp != nil {
 400			ptr1, err = graphql.UnmarshalInt(tmp)
 401			arg2 = &ptr1
 402		}
 403
 404		if err != nil {
 405			return nil, err
 406		}
 407	}
 408	args["first"] = arg2
 409	var arg3 *int
 410	if tmp, ok := rawArgs["last"]; ok {
 411		var err error
 412		var ptr1 int
 413		if tmp != nil {
 414			ptr1, err = graphql.UnmarshalInt(tmp)
 415			arg3 = &ptr1
 416		}
 417
 418		if err != nil {
 419			return nil, err
 420		}
 421	}
 422	args["last"] = arg3
 423	return args, nil
 424
 425}
 426
 427func field_Bug_timeline_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 428	args := map[string]interface{}{}
 429	var arg0 *string
 430	if tmp, ok := rawArgs["after"]; ok {
 431		var err error
 432		var ptr1 string
 433		if tmp != nil {
 434			ptr1, err = graphql.UnmarshalString(tmp)
 435			arg0 = &ptr1
 436		}
 437
 438		if err != nil {
 439			return nil, err
 440		}
 441	}
 442	args["after"] = arg0
 443	var arg1 *string
 444	if tmp, ok := rawArgs["before"]; ok {
 445		var err error
 446		var ptr1 string
 447		if tmp != nil {
 448			ptr1, err = graphql.UnmarshalString(tmp)
 449			arg1 = &ptr1
 450		}
 451
 452		if err != nil {
 453			return nil, err
 454		}
 455	}
 456	args["before"] = arg1
 457	var arg2 *int
 458	if tmp, ok := rawArgs["first"]; ok {
 459		var err error
 460		var ptr1 int
 461		if tmp != nil {
 462			ptr1, err = graphql.UnmarshalInt(tmp)
 463			arg2 = &ptr1
 464		}
 465
 466		if err != nil {
 467			return nil, err
 468		}
 469	}
 470	args["first"] = arg2
 471	var arg3 *int
 472	if tmp, ok := rawArgs["last"]; ok {
 473		var err error
 474		var ptr1 int
 475		if tmp != nil {
 476			ptr1, err = graphql.UnmarshalInt(tmp)
 477			arg3 = &ptr1
 478		}
 479
 480		if err != nil {
 481			return nil, err
 482		}
 483	}
 484	args["last"] = arg3
 485	return args, nil
 486
 487}
 488
 489func field_Bug_operations_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 490	args := map[string]interface{}{}
 491	var arg0 *string
 492	if tmp, ok := rawArgs["after"]; ok {
 493		var err error
 494		var ptr1 string
 495		if tmp != nil {
 496			ptr1, err = graphql.UnmarshalString(tmp)
 497			arg0 = &ptr1
 498		}
 499
 500		if err != nil {
 501			return nil, err
 502		}
 503	}
 504	args["after"] = arg0
 505	var arg1 *string
 506	if tmp, ok := rawArgs["before"]; ok {
 507		var err error
 508		var ptr1 string
 509		if tmp != nil {
 510			ptr1, err = graphql.UnmarshalString(tmp)
 511			arg1 = &ptr1
 512		}
 513
 514		if err != nil {
 515			return nil, err
 516		}
 517	}
 518	args["before"] = arg1
 519	var arg2 *int
 520	if tmp, ok := rawArgs["first"]; ok {
 521		var err error
 522		var ptr1 int
 523		if tmp != nil {
 524			ptr1, err = graphql.UnmarshalInt(tmp)
 525			arg2 = &ptr1
 526		}
 527
 528		if err != nil {
 529			return nil, err
 530		}
 531	}
 532	args["first"] = arg2
 533	var arg3 *int
 534	if tmp, ok := rawArgs["last"]; ok {
 535		var err error
 536		var ptr1 int
 537		if tmp != nil {
 538			ptr1, err = graphql.UnmarshalInt(tmp)
 539			arg3 = &ptr1
 540		}
 541
 542		if err != nil {
 543			return nil, err
 544		}
 545	}
 546	args["last"] = arg3
 547	return args, nil
 548
 549}
 550
 551func field_Mutation_newBug_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 552	args := map[string]interface{}{}
 553	var arg0 *string
 554	if tmp, ok := rawArgs["repoRef"]; ok {
 555		var err error
 556		var ptr1 string
 557		if tmp != nil {
 558			ptr1, err = graphql.UnmarshalString(tmp)
 559			arg0 = &ptr1
 560		}
 561
 562		if err != nil {
 563			return nil, err
 564		}
 565	}
 566	args["repoRef"] = arg0
 567	var arg1 string
 568	if tmp, ok := rawArgs["title"]; ok {
 569		var err error
 570		arg1, err = graphql.UnmarshalString(tmp)
 571		if err != nil {
 572			return nil, err
 573		}
 574	}
 575	args["title"] = arg1
 576	var arg2 string
 577	if tmp, ok := rawArgs["message"]; ok {
 578		var err error
 579		arg2, err = graphql.UnmarshalString(tmp)
 580		if err != nil {
 581			return nil, err
 582		}
 583	}
 584	args["message"] = arg2
 585	var arg3 []git.Hash
 586	if tmp, ok := rawArgs["files"]; ok {
 587		var err error
 588		var rawIf1 []interface{}
 589		if tmp != nil {
 590			if tmp1, ok := tmp.([]interface{}); ok {
 591				rawIf1 = tmp1
 592			} else {
 593				rawIf1 = []interface{}{tmp}
 594			}
 595		}
 596		arg3 = make([]git.Hash, len(rawIf1))
 597		for idx1 := range rawIf1 {
 598			err = (&arg3[idx1]).UnmarshalGQL(rawIf1[idx1])
 599		}
 600		if err != nil {
 601			return nil, err
 602		}
 603	}
 604	args["files"] = arg3
 605	return args, nil
 606
 607}
 608
 609func field_Mutation_addComment_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 610	args := map[string]interface{}{}
 611	var arg0 *string
 612	if tmp, ok := rawArgs["repoRef"]; ok {
 613		var err error
 614		var ptr1 string
 615		if tmp != nil {
 616			ptr1, err = graphql.UnmarshalString(tmp)
 617			arg0 = &ptr1
 618		}
 619
 620		if err != nil {
 621			return nil, err
 622		}
 623	}
 624	args["repoRef"] = arg0
 625	var arg1 string
 626	if tmp, ok := rawArgs["prefix"]; ok {
 627		var err error
 628		arg1, err = graphql.UnmarshalString(tmp)
 629		if err != nil {
 630			return nil, err
 631		}
 632	}
 633	args["prefix"] = arg1
 634	var arg2 string
 635	if tmp, ok := rawArgs["message"]; ok {
 636		var err error
 637		arg2, err = graphql.UnmarshalString(tmp)
 638		if err != nil {
 639			return nil, err
 640		}
 641	}
 642	args["message"] = arg2
 643	var arg3 []git.Hash
 644	if tmp, ok := rawArgs["files"]; ok {
 645		var err error
 646		var rawIf1 []interface{}
 647		if tmp != nil {
 648			if tmp1, ok := tmp.([]interface{}); ok {
 649				rawIf1 = tmp1
 650			} else {
 651				rawIf1 = []interface{}{tmp}
 652			}
 653		}
 654		arg3 = make([]git.Hash, len(rawIf1))
 655		for idx1 := range rawIf1 {
 656			err = (&arg3[idx1]).UnmarshalGQL(rawIf1[idx1])
 657		}
 658		if err != nil {
 659			return nil, err
 660		}
 661	}
 662	args["files"] = arg3
 663	return args, nil
 664
 665}
 666
 667func field_Mutation_changeLabels_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 668	args := map[string]interface{}{}
 669	var arg0 *string
 670	if tmp, ok := rawArgs["repoRef"]; ok {
 671		var err error
 672		var ptr1 string
 673		if tmp != nil {
 674			ptr1, err = graphql.UnmarshalString(tmp)
 675			arg0 = &ptr1
 676		}
 677
 678		if err != nil {
 679			return nil, err
 680		}
 681	}
 682	args["repoRef"] = arg0
 683	var arg1 string
 684	if tmp, ok := rawArgs["prefix"]; ok {
 685		var err error
 686		arg1, err = graphql.UnmarshalString(tmp)
 687		if err != nil {
 688			return nil, err
 689		}
 690	}
 691	args["prefix"] = arg1
 692	var arg2 []string
 693	if tmp, ok := rawArgs["added"]; ok {
 694		var err error
 695		var rawIf1 []interface{}
 696		if tmp != nil {
 697			if tmp1, ok := tmp.([]interface{}); ok {
 698				rawIf1 = tmp1
 699			} else {
 700				rawIf1 = []interface{}{tmp}
 701			}
 702		}
 703		arg2 = make([]string, len(rawIf1))
 704		for idx1 := range rawIf1 {
 705			arg2[idx1], err = graphql.UnmarshalString(rawIf1[idx1])
 706		}
 707		if err != nil {
 708			return nil, err
 709		}
 710	}
 711	args["added"] = arg2
 712	var arg3 []string
 713	if tmp, ok := rawArgs["removed"]; ok {
 714		var err error
 715		var rawIf1 []interface{}
 716		if tmp != nil {
 717			if tmp1, ok := tmp.([]interface{}); ok {
 718				rawIf1 = tmp1
 719			} else {
 720				rawIf1 = []interface{}{tmp}
 721			}
 722		}
 723		arg3 = make([]string, len(rawIf1))
 724		for idx1 := range rawIf1 {
 725			arg3[idx1], err = graphql.UnmarshalString(rawIf1[idx1])
 726		}
 727		if err != nil {
 728			return nil, err
 729		}
 730	}
 731	args["removed"] = arg3
 732	return args, nil
 733
 734}
 735
 736func field_Mutation_open_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 737	args := map[string]interface{}{}
 738	var arg0 *string
 739	if tmp, ok := rawArgs["repoRef"]; ok {
 740		var err error
 741		var ptr1 string
 742		if tmp != nil {
 743			ptr1, err = graphql.UnmarshalString(tmp)
 744			arg0 = &ptr1
 745		}
 746
 747		if err != nil {
 748			return nil, err
 749		}
 750	}
 751	args["repoRef"] = arg0
 752	var arg1 string
 753	if tmp, ok := rawArgs["prefix"]; ok {
 754		var err error
 755		arg1, err = graphql.UnmarshalString(tmp)
 756		if err != nil {
 757			return nil, err
 758		}
 759	}
 760	args["prefix"] = arg1
 761	return args, nil
 762
 763}
 764
 765func field_Mutation_close_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 766	args := map[string]interface{}{}
 767	var arg0 *string
 768	if tmp, ok := rawArgs["repoRef"]; ok {
 769		var err error
 770		var ptr1 string
 771		if tmp != nil {
 772			ptr1, err = graphql.UnmarshalString(tmp)
 773			arg0 = &ptr1
 774		}
 775
 776		if err != nil {
 777			return nil, err
 778		}
 779	}
 780	args["repoRef"] = arg0
 781	var arg1 string
 782	if tmp, ok := rawArgs["prefix"]; ok {
 783		var err error
 784		arg1, err = graphql.UnmarshalString(tmp)
 785		if err != nil {
 786			return nil, err
 787		}
 788	}
 789	args["prefix"] = arg1
 790	return args, nil
 791
 792}
 793
 794func field_Mutation_setTitle_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 795	args := map[string]interface{}{}
 796	var arg0 *string
 797	if tmp, ok := rawArgs["repoRef"]; ok {
 798		var err error
 799		var ptr1 string
 800		if tmp != nil {
 801			ptr1, err = graphql.UnmarshalString(tmp)
 802			arg0 = &ptr1
 803		}
 804
 805		if err != nil {
 806			return nil, err
 807		}
 808	}
 809	args["repoRef"] = arg0
 810	var arg1 string
 811	if tmp, ok := rawArgs["prefix"]; ok {
 812		var err error
 813		arg1, err = graphql.UnmarshalString(tmp)
 814		if err != nil {
 815			return nil, err
 816		}
 817	}
 818	args["prefix"] = arg1
 819	var arg2 string
 820	if tmp, ok := rawArgs["title"]; ok {
 821		var err error
 822		arg2, err = graphql.UnmarshalString(tmp)
 823		if err != nil {
 824			return nil, err
 825		}
 826	}
 827	args["title"] = arg2
 828	return args, nil
 829
 830}
 831
 832func field_Mutation_commit_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 833	args := map[string]interface{}{}
 834	var arg0 *string
 835	if tmp, ok := rawArgs["repoRef"]; ok {
 836		var err error
 837		var ptr1 string
 838		if tmp != nil {
 839			ptr1, err = graphql.UnmarshalString(tmp)
 840			arg0 = &ptr1
 841		}
 842
 843		if err != nil {
 844			return nil, err
 845		}
 846	}
 847	args["repoRef"] = arg0
 848	var arg1 string
 849	if tmp, ok := rawArgs["prefix"]; ok {
 850		var err error
 851		arg1, err = graphql.UnmarshalString(tmp)
 852		if err != nil {
 853			return nil, err
 854		}
 855	}
 856	args["prefix"] = arg1
 857	return args, nil
 858
 859}
 860
 861func field_Query_repository_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 862	args := map[string]interface{}{}
 863	var arg0 string
 864	if tmp, ok := rawArgs["id"]; ok {
 865		var err error
 866		arg0, err = graphql.UnmarshalString(tmp)
 867		if err != nil {
 868			return nil, err
 869		}
 870	}
 871	args["id"] = arg0
 872	return args, nil
 873
 874}
 875
 876func field_Query___type_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 877	args := map[string]interface{}{}
 878	var arg0 string
 879	if tmp, ok := rawArgs["name"]; ok {
 880		var err error
 881		arg0, err = graphql.UnmarshalString(tmp)
 882		if err != nil {
 883			return nil, err
 884		}
 885	}
 886	args["name"] = arg0
 887	return args, nil
 888
 889}
 890
 891func field_Repository_allBugs_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 892	args := map[string]interface{}{}
 893	var arg0 *string
 894	if tmp, ok := rawArgs["after"]; ok {
 895		var err error
 896		var ptr1 string
 897		if tmp != nil {
 898			ptr1, err = graphql.UnmarshalString(tmp)
 899			arg0 = &ptr1
 900		}
 901
 902		if err != nil {
 903			return nil, err
 904		}
 905	}
 906	args["after"] = arg0
 907	var arg1 *string
 908	if tmp, ok := rawArgs["before"]; ok {
 909		var err error
 910		var ptr1 string
 911		if tmp != nil {
 912			ptr1, err = graphql.UnmarshalString(tmp)
 913			arg1 = &ptr1
 914		}
 915
 916		if err != nil {
 917			return nil, err
 918		}
 919	}
 920	args["before"] = arg1
 921	var arg2 *int
 922	if tmp, ok := rawArgs["first"]; ok {
 923		var err error
 924		var ptr1 int
 925		if tmp != nil {
 926			ptr1, err = graphql.UnmarshalInt(tmp)
 927			arg2 = &ptr1
 928		}
 929
 930		if err != nil {
 931			return nil, err
 932		}
 933	}
 934	args["first"] = arg2
 935	var arg3 *int
 936	if tmp, ok := rawArgs["last"]; ok {
 937		var err error
 938		var ptr1 int
 939		if tmp != nil {
 940			ptr1, err = graphql.UnmarshalInt(tmp)
 941			arg3 = &ptr1
 942		}
 943
 944		if err != nil {
 945			return nil, err
 946		}
 947	}
 948	args["last"] = arg3
 949	var arg4 *string
 950	if tmp, ok := rawArgs["query"]; ok {
 951		var err error
 952		var ptr1 string
 953		if tmp != nil {
 954			ptr1, err = graphql.UnmarshalString(tmp)
 955			arg4 = &ptr1
 956		}
 957
 958		if err != nil {
 959			return nil, err
 960		}
 961	}
 962	args["query"] = arg4
 963	return args, nil
 964
 965}
 966
 967func field_Repository_bug_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 968	args := map[string]interface{}{}
 969	var arg0 string
 970	if tmp, ok := rawArgs["prefix"]; ok {
 971		var err error
 972		arg0, err = graphql.UnmarshalString(tmp)
 973		if err != nil {
 974			return nil, err
 975		}
 976	}
 977	args["prefix"] = arg0
 978	return args, nil
 979
 980}
 981
 982func field_Repository_allIdentities_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 983	args := map[string]interface{}{}
 984	var arg0 *string
 985	if tmp, ok := rawArgs["after"]; ok {
 986		var err error
 987		var ptr1 string
 988		if tmp != nil {
 989			ptr1, err = graphql.UnmarshalString(tmp)
 990			arg0 = &ptr1
 991		}
 992
 993		if err != nil {
 994			return nil, err
 995		}
 996	}
 997	args["after"] = arg0
 998	var arg1 *string
 999	if tmp, ok := rawArgs["before"]; ok {
1000		var err error
1001		var ptr1 string
1002		if tmp != nil {
1003			ptr1, err = graphql.UnmarshalString(tmp)
1004			arg1 = &ptr1
1005		}
1006
1007		if err != nil {
1008			return nil, err
1009		}
1010	}
1011	args["before"] = arg1
1012	var arg2 *int
1013	if tmp, ok := rawArgs["first"]; ok {
1014		var err error
1015		var ptr1 int
1016		if tmp != nil {
1017			ptr1, err = graphql.UnmarshalInt(tmp)
1018			arg2 = &ptr1
1019		}
1020
1021		if err != nil {
1022			return nil, err
1023		}
1024	}
1025	args["first"] = arg2
1026	var arg3 *int
1027	if tmp, ok := rawArgs["last"]; ok {
1028		var err error
1029		var ptr1 int
1030		if tmp != nil {
1031			ptr1, err = graphql.UnmarshalInt(tmp)
1032			arg3 = &ptr1
1033		}
1034
1035		if err != nil {
1036			return nil, err
1037		}
1038	}
1039	args["last"] = arg3
1040	return args, nil
1041
1042}
1043
1044func field_Repository_identity_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
1045	args := map[string]interface{}{}
1046	var arg0 string
1047	if tmp, ok := rawArgs["prefix"]; ok {
1048		var err error
1049		arg0, err = graphql.UnmarshalString(tmp)
1050		if err != nil {
1051			return nil, err
1052		}
1053	}
1054	args["prefix"] = arg0
1055	return args, nil
1056
1057}
1058
1059func field___Type_fields_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
1060	args := map[string]interface{}{}
1061	var arg0 bool
1062	if tmp, ok := rawArgs["includeDeprecated"]; ok {
1063		var err error
1064		arg0, err = graphql.UnmarshalBoolean(tmp)
1065		if err != nil {
1066			return nil, err
1067		}
1068	}
1069	args["includeDeprecated"] = arg0
1070	return args, nil
1071
1072}
1073
1074func field___Type_enumValues_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
1075	args := map[string]interface{}{}
1076	var arg0 bool
1077	if tmp, ok := rawArgs["includeDeprecated"]; ok {
1078		var err error
1079		arg0, err = graphql.UnmarshalBoolean(tmp)
1080		if err != nil {
1081			return nil, err
1082		}
1083	}
1084	args["includeDeprecated"] = arg0
1085	return args, nil
1086
1087}
1088
1089type executableSchema struct {
1090	resolvers  ResolverRoot
1091	directives DirectiveRoot
1092	complexity ComplexityRoot
1093}
1094
1095func (e *executableSchema) Schema() *ast.Schema {
1096	return parsedSchema
1097}
1098
1099func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
1100	switch typeName + "." + field {
1101
1102	case "AddCommentOperation.hash":
1103		if e.complexity.AddCommentOperation.Hash == nil {
1104			break
1105		}
1106
1107		return e.complexity.AddCommentOperation.Hash(childComplexity), true
1108
1109	case "AddCommentOperation.author":
1110		if e.complexity.AddCommentOperation.Author == nil {
1111			break
1112		}
1113
1114		return e.complexity.AddCommentOperation.Author(childComplexity), true
1115
1116	case "AddCommentOperation.date":
1117		if e.complexity.AddCommentOperation.Date == nil {
1118			break
1119		}
1120
1121		return e.complexity.AddCommentOperation.Date(childComplexity), true
1122
1123	case "AddCommentOperation.message":
1124		if e.complexity.AddCommentOperation.Message == nil {
1125			break
1126		}
1127
1128		return e.complexity.AddCommentOperation.Message(childComplexity), true
1129
1130	case "AddCommentOperation.files":
1131		if e.complexity.AddCommentOperation.Files == nil {
1132			break
1133		}
1134
1135		return e.complexity.AddCommentOperation.Files(childComplexity), true
1136
1137	case "AddCommentTimelineItem.hash":
1138		if e.complexity.AddCommentTimelineItem.Hash == nil {
1139			break
1140		}
1141
1142		return e.complexity.AddCommentTimelineItem.Hash(childComplexity), true
1143
1144	case "AddCommentTimelineItem.author":
1145		if e.complexity.AddCommentTimelineItem.Author == nil {
1146			break
1147		}
1148
1149		return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
1150
1151	case "AddCommentTimelineItem.message":
1152		if e.complexity.AddCommentTimelineItem.Message == nil {
1153			break
1154		}
1155
1156		return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
1157
1158	case "AddCommentTimelineItem.messageIsEmpty":
1159		if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
1160			break
1161		}
1162
1163		return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
1164
1165	case "AddCommentTimelineItem.files":
1166		if e.complexity.AddCommentTimelineItem.Files == nil {
1167			break
1168		}
1169
1170		return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
1171
1172	case "AddCommentTimelineItem.createdAt":
1173		if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
1174			break
1175		}
1176
1177		return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
1178
1179	case "AddCommentTimelineItem.lastEdit":
1180		if e.complexity.AddCommentTimelineItem.LastEdit == nil {
1181			break
1182		}
1183
1184		return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
1185
1186	case "AddCommentTimelineItem.edited":
1187		if e.complexity.AddCommentTimelineItem.Edited == nil {
1188			break
1189		}
1190
1191		return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
1192
1193	case "AddCommentTimelineItem.history":
1194		if e.complexity.AddCommentTimelineItem.History == nil {
1195			break
1196		}
1197
1198		return e.complexity.AddCommentTimelineItem.History(childComplexity), true
1199
1200	case "Bug.id":
1201		if e.complexity.Bug.Id == nil {
1202			break
1203		}
1204
1205		return e.complexity.Bug.Id(childComplexity), true
1206
1207	case "Bug.humanId":
1208		if e.complexity.Bug.HumanId == nil {
1209			break
1210		}
1211
1212		return e.complexity.Bug.HumanId(childComplexity), true
1213
1214	case "Bug.status":
1215		if e.complexity.Bug.Status == nil {
1216			break
1217		}
1218
1219		return e.complexity.Bug.Status(childComplexity), true
1220
1221	case "Bug.title":
1222		if e.complexity.Bug.Title == nil {
1223			break
1224		}
1225
1226		return e.complexity.Bug.Title(childComplexity), true
1227
1228	case "Bug.labels":
1229		if e.complexity.Bug.Labels == nil {
1230			break
1231		}
1232
1233		return e.complexity.Bug.Labels(childComplexity), true
1234
1235	case "Bug.author":
1236		if e.complexity.Bug.Author == nil {
1237			break
1238		}
1239
1240		return e.complexity.Bug.Author(childComplexity), true
1241
1242	case "Bug.createdAt":
1243		if e.complexity.Bug.CreatedAt == nil {
1244			break
1245		}
1246
1247		return e.complexity.Bug.CreatedAt(childComplexity), true
1248
1249	case "Bug.lastEdit":
1250		if e.complexity.Bug.LastEdit == nil {
1251			break
1252		}
1253
1254		return e.complexity.Bug.LastEdit(childComplexity), true
1255
1256	case "Bug.comments":
1257		if e.complexity.Bug.Comments == nil {
1258			break
1259		}
1260
1261		args, err := field_Bug_comments_args(rawArgs)
1262		if err != nil {
1263			return 0, false
1264		}
1265
1266		return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1267
1268	case "Bug.timeline":
1269		if e.complexity.Bug.Timeline == nil {
1270			break
1271		}
1272
1273		args, err := field_Bug_timeline_args(rawArgs)
1274		if err != nil {
1275			return 0, false
1276		}
1277
1278		return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1279
1280	case "Bug.operations":
1281		if e.complexity.Bug.Operations == nil {
1282			break
1283		}
1284
1285		args, err := field_Bug_operations_args(rawArgs)
1286		if err != nil {
1287			return 0, false
1288		}
1289
1290		return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1291
1292	case "BugConnection.edges":
1293		if e.complexity.BugConnection.Edges == nil {
1294			break
1295		}
1296
1297		return e.complexity.BugConnection.Edges(childComplexity), true
1298
1299	case "BugConnection.nodes":
1300		if e.complexity.BugConnection.Nodes == nil {
1301			break
1302		}
1303
1304		return e.complexity.BugConnection.Nodes(childComplexity), true
1305
1306	case "BugConnection.pageInfo":
1307		if e.complexity.BugConnection.PageInfo == nil {
1308			break
1309		}
1310
1311		return e.complexity.BugConnection.PageInfo(childComplexity), true
1312
1313	case "BugConnection.totalCount":
1314		if e.complexity.BugConnection.TotalCount == nil {
1315			break
1316		}
1317
1318		return e.complexity.BugConnection.TotalCount(childComplexity), true
1319
1320	case "BugEdge.cursor":
1321		if e.complexity.BugEdge.Cursor == nil {
1322			break
1323		}
1324
1325		return e.complexity.BugEdge.Cursor(childComplexity), true
1326
1327	case "BugEdge.node":
1328		if e.complexity.BugEdge.Node == nil {
1329			break
1330		}
1331
1332		return e.complexity.BugEdge.Node(childComplexity), true
1333
1334	case "Comment.author":
1335		if e.complexity.Comment.Author == nil {
1336			break
1337		}
1338
1339		return e.complexity.Comment.Author(childComplexity), true
1340
1341	case "Comment.message":
1342		if e.complexity.Comment.Message == nil {
1343			break
1344		}
1345
1346		return e.complexity.Comment.Message(childComplexity), true
1347
1348	case "Comment.files":
1349		if e.complexity.Comment.Files == nil {
1350			break
1351		}
1352
1353		return e.complexity.Comment.Files(childComplexity), true
1354
1355	case "CommentConnection.edges":
1356		if e.complexity.CommentConnection.Edges == nil {
1357			break
1358		}
1359
1360		return e.complexity.CommentConnection.Edges(childComplexity), true
1361
1362	case "CommentConnection.nodes":
1363		if e.complexity.CommentConnection.Nodes == nil {
1364			break
1365		}
1366
1367		return e.complexity.CommentConnection.Nodes(childComplexity), true
1368
1369	case "CommentConnection.pageInfo":
1370		if e.complexity.CommentConnection.PageInfo == nil {
1371			break
1372		}
1373
1374		return e.complexity.CommentConnection.PageInfo(childComplexity), true
1375
1376	case "CommentConnection.totalCount":
1377		if e.complexity.CommentConnection.TotalCount == nil {
1378			break
1379		}
1380
1381		return e.complexity.CommentConnection.TotalCount(childComplexity), true
1382
1383	case "CommentEdge.cursor":
1384		if e.complexity.CommentEdge.Cursor == nil {
1385			break
1386		}
1387
1388		return e.complexity.CommentEdge.Cursor(childComplexity), true
1389
1390	case "CommentEdge.node":
1391		if e.complexity.CommentEdge.Node == nil {
1392			break
1393		}
1394
1395		return e.complexity.CommentEdge.Node(childComplexity), true
1396
1397	case "CommentHistoryStep.message":
1398		if e.complexity.CommentHistoryStep.Message == nil {
1399			break
1400		}
1401
1402		return e.complexity.CommentHistoryStep.Message(childComplexity), true
1403
1404	case "CommentHistoryStep.date":
1405		if e.complexity.CommentHistoryStep.Date == nil {
1406			break
1407		}
1408
1409		return e.complexity.CommentHistoryStep.Date(childComplexity), true
1410
1411	case "CreateOperation.hash":
1412		if e.complexity.CreateOperation.Hash == nil {
1413			break
1414		}
1415
1416		return e.complexity.CreateOperation.Hash(childComplexity), true
1417
1418	case "CreateOperation.author":
1419		if e.complexity.CreateOperation.Author == nil {
1420			break
1421		}
1422
1423		return e.complexity.CreateOperation.Author(childComplexity), true
1424
1425	case "CreateOperation.date":
1426		if e.complexity.CreateOperation.Date == nil {
1427			break
1428		}
1429
1430		return e.complexity.CreateOperation.Date(childComplexity), true
1431
1432	case "CreateOperation.title":
1433		if e.complexity.CreateOperation.Title == nil {
1434			break
1435		}
1436
1437		return e.complexity.CreateOperation.Title(childComplexity), true
1438
1439	case "CreateOperation.message":
1440		if e.complexity.CreateOperation.Message == nil {
1441			break
1442		}
1443
1444		return e.complexity.CreateOperation.Message(childComplexity), true
1445
1446	case "CreateOperation.files":
1447		if e.complexity.CreateOperation.Files == nil {
1448			break
1449		}
1450
1451		return e.complexity.CreateOperation.Files(childComplexity), true
1452
1453	case "CreateTimelineItem.hash":
1454		if e.complexity.CreateTimelineItem.Hash == nil {
1455			break
1456		}
1457
1458		return e.complexity.CreateTimelineItem.Hash(childComplexity), true
1459
1460	case "CreateTimelineItem.author":
1461		if e.complexity.CreateTimelineItem.Author == nil {
1462			break
1463		}
1464
1465		return e.complexity.CreateTimelineItem.Author(childComplexity), true
1466
1467	case "CreateTimelineItem.message":
1468		if e.complexity.CreateTimelineItem.Message == nil {
1469			break
1470		}
1471
1472		return e.complexity.CreateTimelineItem.Message(childComplexity), true
1473
1474	case "CreateTimelineItem.messageIsEmpty":
1475		if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
1476			break
1477		}
1478
1479		return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
1480
1481	case "CreateTimelineItem.files":
1482		if e.complexity.CreateTimelineItem.Files == nil {
1483			break
1484		}
1485
1486		return e.complexity.CreateTimelineItem.Files(childComplexity), true
1487
1488	case "CreateTimelineItem.createdAt":
1489		if e.complexity.CreateTimelineItem.CreatedAt == nil {
1490			break
1491		}
1492
1493		return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
1494
1495	case "CreateTimelineItem.lastEdit":
1496		if e.complexity.CreateTimelineItem.LastEdit == nil {
1497			break
1498		}
1499
1500		return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
1501
1502	case "CreateTimelineItem.edited":
1503		if e.complexity.CreateTimelineItem.Edited == nil {
1504			break
1505		}
1506
1507		return e.complexity.CreateTimelineItem.Edited(childComplexity), true
1508
1509	case "CreateTimelineItem.history":
1510		if e.complexity.CreateTimelineItem.History == nil {
1511			break
1512		}
1513
1514		return e.complexity.CreateTimelineItem.History(childComplexity), true
1515
1516	case "EditCommentOperation.hash":
1517		if e.complexity.EditCommentOperation.Hash == nil {
1518			break
1519		}
1520
1521		return e.complexity.EditCommentOperation.Hash(childComplexity), true
1522
1523	case "EditCommentOperation.author":
1524		if e.complexity.EditCommentOperation.Author == nil {
1525			break
1526		}
1527
1528		return e.complexity.EditCommentOperation.Author(childComplexity), true
1529
1530	case "EditCommentOperation.date":
1531		if e.complexity.EditCommentOperation.Date == nil {
1532			break
1533		}
1534
1535		return e.complexity.EditCommentOperation.Date(childComplexity), true
1536
1537	case "EditCommentOperation.target":
1538		if e.complexity.EditCommentOperation.Target == nil {
1539			break
1540		}
1541
1542		return e.complexity.EditCommentOperation.Target(childComplexity), true
1543
1544	case "EditCommentOperation.message":
1545		if e.complexity.EditCommentOperation.Message == nil {
1546			break
1547		}
1548
1549		return e.complexity.EditCommentOperation.Message(childComplexity), true
1550
1551	case "EditCommentOperation.files":
1552		if e.complexity.EditCommentOperation.Files == nil {
1553			break
1554		}
1555
1556		return e.complexity.EditCommentOperation.Files(childComplexity), true
1557
1558	case "Identity.id":
1559		if e.complexity.Identity.Id == nil {
1560			break
1561		}
1562
1563		return e.complexity.Identity.Id(childComplexity), true
1564
1565	case "Identity.humanId":
1566		if e.complexity.Identity.HumanId == nil {
1567			break
1568		}
1569
1570		return e.complexity.Identity.HumanId(childComplexity), true
1571
1572	case "Identity.name":
1573		if e.complexity.Identity.Name == nil {
1574			break
1575		}
1576
1577		return e.complexity.Identity.Name(childComplexity), true
1578
1579	case "Identity.email":
1580		if e.complexity.Identity.Email == nil {
1581			break
1582		}
1583
1584		return e.complexity.Identity.Email(childComplexity), true
1585
1586	case "Identity.login":
1587		if e.complexity.Identity.Login == nil {
1588			break
1589		}
1590
1591		return e.complexity.Identity.Login(childComplexity), true
1592
1593	case "Identity.displayName":
1594		if e.complexity.Identity.DisplayName == nil {
1595			break
1596		}
1597
1598		return e.complexity.Identity.DisplayName(childComplexity), true
1599
1600	case "Identity.avatarUrl":
1601		if e.complexity.Identity.AvatarUrl == nil {
1602			break
1603		}
1604
1605		return e.complexity.Identity.AvatarUrl(childComplexity), true
1606
1607	case "Identity.isProtected":
1608		if e.complexity.Identity.IsProtected == nil {
1609			break
1610		}
1611
1612		return e.complexity.Identity.IsProtected(childComplexity), true
1613
1614	case "IdentityConnection.edges":
1615		if e.complexity.IdentityConnection.Edges == nil {
1616			break
1617		}
1618
1619		return e.complexity.IdentityConnection.Edges(childComplexity), true
1620
1621	case "IdentityConnection.nodes":
1622		if e.complexity.IdentityConnection.Nodes == nil {
1623			break
1624		}
1625
1626		return e.complexity.IdentityConnection.Nodes(childComplexity), true
1627
1628	case "IdentityConnection.pageInfo":
1629		if e.complexity.IdentityConnection.PageInfo == nil {
1630			break
1631		}
1632
1633		return e.complexity.IdentityConnection.PageInfo(childComplexity), true
1634
1635	case "IdentityConnection.totalCount":
1636		if e.complexity.IdentityConnection.TotalCount == nil {
1637			break
1638		}
1639
1640		return e.complexity.IdentityConnection.TotalCount(childComplexity), true
1641
1642	case "IdentityEdge.cursor":
1643		if e.complexity.IdentityEdge.Cursor == nil {
1644			break
1645		}
1646
1647		return e.complexity.IdentityEdge.Cursor(childComplexity), true
1648
1649	case "IdentityEdge.node":
1650		if e.complexity.IdentityEdge.Node == nil {
1651			break
1652		}
1653
1654		return e.complexity.IdentityEdge.Node(childComplexity), true
1655
1656	case "LabelChangeOperation.hash":
1657		if e.complexity.LabelChangeOperation.Hash == nil {
1658			break
1659		}
1660
1661		return e.complexity.LabelChangeOperation.Hash(childComplexity), true
1662
1663	case "LabelChangeOperation.author":
1664		if e.complexity.LabelChangeOperation.Author == nil {
1665			break
1666		}
1667
1668		return e.complexity.LabelChangeOperation.Author(childComplexity), true
1669
1670	case "LabelChangeOperation.date":
1671		if e.complexity.LabelChangeOperation.Date == nil {
1672			break
1673		}
1674
1675		return e.complexity.LabelChangeOperation.Date(childComplexity), true
1676
1677	case "LabelChangeOperation.added":
1678		if e.complexity.LabelChangeOperation.Added == nil {
1679			break
1680		}
1681
1682		return e.complexity.LabelChangeOperation.Added(childComplexity), true
1683
1684	case "LabelChangeOperation.removed":
1685		if e.complexity.LabelChangeOperation.Removed == nil {
1686			break
1687		}
1688
1689		return e.complexity.LabelChangeOperation.Removed(childComplexity), true
1690
1691	case "LabelChangeTimelineItem.hash":
1692		if e.complexity.LabelChangeTimelineItem.Hash == nil {
1693			break
1694		}
1695
1696		return e.complexity.LabelChangeTimelineItem.Hash(childComplexity), true
1697
1698	case "LabelChangeTimelineItem.author":
1699		if e.complexity.LabelChangeTimelineItem.Author == nil {
1700			break
1701		}
1702
1703		return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
1704
1705	case "LabelChangeTimelineItem.date":
1706		if e.complexity.LabelChangeTimelineItem.Date == nil {
1707			break
1708		}
1709
1710		return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
1711
1712	case "LabelChangeTimelineItem.added":
1713		if e.complexity.LabelChangeTimelineItem.Added == nil {
1714			break
1715		}
1716
1717		return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
1718
1719	case "LabelChangeTimelineItem.removed":
1720		if e.complexity.LabelChangeTimelineItem.Removed == nil {
1721			break
1722		}
1723
1724		return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
1725
1726	case "Mutation.newBug":
1727		if e.complexity.Mutation.NewBug == nil {
1728			break
1729		}
1730
1731		args, err := field_Mutation_newBug_args(rawArgs)
1732		if err != nil {
1733			return 0, false
1734		}
1735
1736		return e.complexity.Mutation.NewBug(childComplexity, args["repoRef"].(*string), args["title"].(string), args["message"].(string), args["files"].([]git.Hash)), true
1737
1738	case "Mutation.addComment":
1739		if e.complexity.Mutation.AddComment == nil {
1740			break
1741		}
1742
1743		args, err := field_Mutation_addComment_args(rawArgs)
1744		if err != nil {
1745			return 0, false
1746		}
1747
1748		return e.complexity.Mutation.AddComment(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["message"].(string), args["files"].([]git.Hash)), true
1749
1750	case "Mutation.changeLabels":
1751		if e.complexity.Mutation.ChangeLabels == nil {
1752			break
1753		}
1754
1755		args, err := field_Mutation_changeLabels_args(rawArgs)
1756		if err != nil {
1757			return 0, false
1758		}
1759
1760		return e.complexity.Mutation.ChangeLabels(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["added"].([]string), args["removed"].([]string)), true
1761
1762	case "Mutation.open":
1763		if e.complexity.Mutation.Open == nil {
1764			break
1765		}
1766
1767		args, err := field_Mutation_open_args(rawArgs)
1768		if err != nil {
1769			return 0, false
1770		}
1771
1772		return e.complexity.Mutation.Open(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
1773
1774	case "Mutation.close":
1775		if e.complexity.Mutation.Close == nil {
1776			break
1777		}
1778
1779		args, err := field_Mutation_close_args(rawArgs)
1780		if err != nil {
1781			return 0, false
1782		}
1783
1784		return e.complexity.Mutation.Close(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
1785
1786	case "Mutation.setTitle":
1787		if e.complexity.Mutation.SetTitle == nil {
1788			break
1789		}
1790
1791		args, err := field_Mutation_setTitle_args(rawArgs)
1792		if err != nil {
1793			return 0, false
1794		}
1795
1796		return e.complexity.Mutation.SetTitle(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["title"].(string)), true
1797
1798	case "Mutation.commit":
1799		if e.complexity.Mutation.Commit == nil {
1800			break
1801		}
1802
1803		args, err := field_Mutation_commit_args(rawArgs)
1804		if err != nil {
1805			return 0, false
1806		}
1807
1808		return e.complexity.Mutation.Commit(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
1809
1810	case "OperationConnection.edges":
1811		if e.complexity.OperationConnection.Edges == nil {
1812			break
1813		}
1814
1815		return e.complexity.OperationConnection.Edges(childComplexity), true
1816
1817	case "OperationConnection.nodes":
1818		if e.complexity.OperationConnection.Nodes == nil {
1819			break
1820		}
1821
1822		return e.complexity.OperationConnection.Nodes(childComplexity), true
1823
1824	case "OperationConnection.pageInfo":
1825		if e.complexity.OperationConnection.PageInfo == nil {
1826			break
1827		}
1828
1829		return e.complexity.OperationConnection.PageInfo(childComplexity), true
1830
1831	case "OperationConnection.totalCount":
1832		if e.complexity.OperationConnection.TotalCount == nil {
1833			break
1834		}
1835
1836		return e.complexity.OperationConnection.TotalCount(childComplexity), true
1837
1838	case "OperationEdge.cursor":
1839		if e.complexity.OperationEdge.Cursor == nil {
1840			break
1841		}
1842
1843		return e.complexity.OperationEdge.Cursor(childComplexity), true
1844
1845	case "OperationEdge.node":
1846		if e.complexity.OperationEdge.Node == nil {
1847			break
1848		}
1849
1850		return e.complexity.OperationEdge.Node(childComplexity), true
1851
1852	case "PageInfo.hasNextPage":
1853		if e.complexity.PageInfo.HasNextPage == nil {
1854			break
1855		}
1856
1857		return e.complexity.PageInfo.HasNextPage(childComplexity), true
1858
1859	case "PageInfo.hasPreviousPage":
1860		if e.complexity.PageInfo.HasPreviousPage == nil {
1861			break
1862		}
1863
1864		return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
1865
1866	case "PageInfo.startCursor":
1867		if e.complexity.PageInfo.StartCursor == nil {
1868			break
1869		}
1870
1871		return e.complexity.PageInfo.StartCursor(childComplexity), true
1872
1873	case "PageInfo.endCursor":
1874		if e.complexity.PageInfo.EndCursor == nil {
1875			break
1876		}
1877
1878		return e.complexity.PageInfo.EndCursor(childComplexity), true
1879
1880	case "Query.defaultRepository":
1881		if e.complexity.Query.DefaultRepository == nil {
1882			break
1883		}
1884
1885		return e.complexity.Query.DefaultRepository(childComplexity), true
1886
1887	case "Query.repository":
1888		if e.complexity.Query.Repository == nil {
1889			break
1890		}
1891
1892		args, err := field_Query_repository_args(rawArgs)
1893		if err != nil {
1894			return 0, false
1895		}
1896
1897		return e.complexity.Query.Repository(childComplexity, args["id"].(string)), true
1898
1899	case "Repository.allBugs":
1900		if e.complexity.Repository.AllBugs == nil {
1901			break
1902		}
1903
1904		args, err := field_Repository_allBugs_args(rawArgs)
1905		if err != nil {
1906			return 0, false
1907		}
1908
1909		return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
1910
1911	case "Repository.bug":
1912		if e.complexity.Repository.Bug == nil {
1913			break
1914		}
1915
1916		args, err := field_Repository_bug_args(rawArgs)
1917		if err != nil {
1918			return 0, false
1919		}
1920
1921		return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
1922
1923	case "Repository.allIdentities":
1924		if e.complexity.Repository.AllIdentities == nil {
1925			break
1926		}
1927
1928		args, err := field_Repository_allIdentities_args(rawArgs)
1929		if err != nil {
1930			return 0, false
1931		}
1932
1933		return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1934
1935	case "Repository.identity":
1936		if e.complexity.Repository.Identity == nil {
1937			break
1938		}
1939
1940		args, err := field_Repository_identity_args(rawArgs)
1941		if err != nil {
1942			return 0, false
1943		}
1944
1945		return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
1946
1947	case "Repository.userIdentity":
1948		if e.complexity.Repository.UserIdentity == nil {
1949			break
1950		}
1951
1952		return e.complexity.Repository.UserIdentity(childComplexity), true
1953
1954	case "SetStatusOperation.hash":
1955		if e.complexity.SetStatusOperation.Hash == nil {
1956			break
1957		}
1958
1959		return e.complexity.SetStatusOperation.Hash(childComplexity), true
1960
1961	case "SetStatusOperation.author":
1962		if e.complexity.SetStatusOperation.Author == nil {
1963			break
1964		}
1965
1966		return e.complexity.SetStatusOperation.Author(childComplexity), true
1967
1968	case "SetStatusOperation.date":
1969		if e.complexity.SetStatusOperation.Date == nil {
1970			break
1971		}
1972
1973		return e.complexity.SetStatusOperation.Date(childComplexity), true
1974
1975	case "SetStatusOperation.status":
1976		if e.complexity.SetStatusOperation.Status == nil {
1977			break
1978		}
1979
1980		return e.complexity.SetStatusOperation.Status(childComplexity), true
1981
1982	case "SetStatusTimelineItem.hash":
1983		if e.complexity.SetStatusTimelineItem.Hash == nil {
1984			break
1985		}
1986
1987		return e.complexity.SetStatusTimelineItem.Hash(childComplexity), true
1988
1989	case "SetStatusTimelineItem.author":
1990		if e.complexity.SetStatusTimelineItem.Author == nil {
1991			break
1992		}
1993
1994		return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
1995
1996	case "SetStatusTimelineItem.date":
1997		if e.complexity.SetStatusTimelineItem.Date == nil {
1998			break
1999		}
2000
2001		return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
2002
2003	case "SetStatusTimelineItem.status":
2004		if e.complexity.SetStatusTimelineItem.Status == nil {
2005			break
2006		}
2007
2008		return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
2009
2010	case "SetTitleOperation.hash":
2011		if e.complexity.SetTitleOperation.Hash == nil {
2012			break
2013		}
2014
2015		return e.complexity.SetTitleOperation.Hash(childComplexity), true
2016
2017	case "SetTitleOperation.author":
2018		if e.complexity.SetTitleOperation.Author == nil {
2019			break
2020		}
2021
2022		return e.complexity.SetTitleOperation.Author(childComplexity), true
2023
2024	case "SetTitleOperation.date":
2025		if e.complexity.SetTitleOperation.Date == nil {
2026			break
2027		}
2028
2029		return e.complexity.SetTitleOperation.Date(childComplexity), true
2030
2031	case "SetTitleOperation.title":
2032		if e.complexity.SetTitleOperation.Title == nil {
2033			break
2034		}
2035
2036		return e.complexity.SetTitleOperation.Title(childComplexity), true
2037
2038	case "SetTitleOperation.was":
2039		if e.complexity.SetTitleOperation.Was == nil {
2040			break
2041		}
2042
2043		return e.complexity.SetTitleOperation.Was(childComplexity), true
2044
2045	case "SetTitleTimelineItem.hash":
2046		if e.complexity.SetTitleTimelineItem.Hash == nil {
2047			break
2048		}
2049
2050		return e.complexity.SetTitleTimelineItem.Hash(childComplexity), true
2051
2052	case "SetTitleTimelineItem.author":
2053		if e.complexity.SetTitleTimelineItem.Author == nil {
2054			break
2055		}
2056
2057		return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
2058
2059	case "SetTitleTimelineItem.date":
2060		if e.complexity.SetTitleTimelineItem.Date == nil {
2061			break
2062		}
2063
2064		return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
2065
2066	case "SetTitleTimelineItem.title":
2067		if e.complexity.SetTitleTimelineItem.Title == nil {
2068			break
2069		}
2070
2071		return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
2072
2073	case "SetTitleTimelineItem.was":
2074		if e.complexity.SetTitleTimelineItem.Was == nil {
2075			break
2076		}
2077
2078		return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
2079
2080	case "TimelineItemConnection.edges":
2081		if e.complexity.TimelineItemConnection.Edges == nil {
2082			break
2083		}
2084
2085		return e.complexity.TimelineItemConnection.Edges(childComplexity), true
2086
2087	case "TimelineItemConnection.nodes":
2088		if e.complexity.TimelineItemConnection.Nodes == nil {
2089			break
2090		}
2091
2092		return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
2093
2094	case "TimelineItemConnection.pageInfo":
2095		if e.complexity.TimelineItemConnection.PageInfo == nil {
2096			break
2097		}
2098
2099		return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
2100
2101	case "TimelineItemConnection.totalCount":
2102		if e.complexity.TimelineItemConnection.TotalCount == nil {
2103			break
2104		}
2105
2106		return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
2107
2108	case "TimelineItemEdge.cursor":
2109		if e.complexity.TimelineItemEdge.Cursor == nil {
2110			break
2111		}
2112
2113		return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
2114
2115	case "TimelineItemEdge.node":
2116		if e.complexity.TimelineItemEdge.Node == nil {
2117			break
2118		}
2119
2120		return e.complexity.TimelineItemEdge.Node(childComplexity), true
2121
2122	}
2123	return 0, false
2124}
2125
2126func (e *executableSchema) Query(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
2127	ec := executionContext{graphql.GetRequestContext(ctx), e}
2128
2129	buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
2130		data := ec._Query(ctx, op.SelectionSet)
2131		var buf bytes.Buffer
2132		data.MarshalGQL(&buf)
2133		return buf.Bytes()
2134	})
2135
2136	return &graphql.Response{
2137		Data:       buf,
2138		Errors:     ec.Errors,
2139		Extensions: ec.Extensions}
2140}
2141
2142func (e *executableSchema) Mutation(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
2143	ec := executionContext{graphql.GetRequestContext(ctx), e}
2144
2145	buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
2146		data := ec._Mutation(ctx, op.SelectionSet)
2147		var buf bytes.Buffer
2148		data.MarshalGQL(&buf)
2149		return buf.Bytes()
2150	})
2151
2152	return &graphql.Response{
2153		Data:       buf,
2154		Errors:     ec.Errors,
2155		Extensions: ec.Extensions,
2156	}
2157}
2158
2159func (e *executableSchema) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response {
2160	return graphql.OneShot(graphql.ErrorResponse(ctx, "subscriptions are not supported"))
2161}
2162
2163type executionContext struct {
2164	*graphql.RequestContext
2165	*executableSchema
2166}
2167
2168var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
2169
2170// nolint: gocyclo, errcheck, gas, goconst
2171func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
2172	fields := graphql.CollectFields(ctx, sel, addCommentOperationImplementors)
2173
2174	var wg sync.WaitGroup
2175	out := graphql.NewOrderedMap(len(fields))
2176	invalid := false
2177	for i, field := range fields {
2178		out.Keys[i] = field.Alias
2179
2180		switch field.Name {
2181		case "__typename":
2182			out.Values[i] = graphql.MarshalString("AddCommentOperation")
2183		case "hash":
2184			out.Values[i] = ec._AddCommentOperation_hash(ctx, field, obj)
2185			if out.Values[i] == graphql.Null {
2186				invalid = true
2187			}
2188		case "author":
2189			out.Values[i] = ec._AddCommentOperation_author(ctx, field, obj)
2190			if out.Values[i] == graphql.Null {
2191				invalid = true
2192			}
2193		case "date":
2194			wg.Add(1)
2195			go func(i int, field graphql.CollectedField) {
2196				out.Values[i] = ec._AddCommentOperation_date(ctx, field, obj)
2197				if out.Values[i] == graphql.Null {
2198					invalid = true
2199				}
2200				wg.Done()
2201			}(i, field)
2202		case "message":
2203			out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
2204			if out.Values[i] == graphql.Null {
2205				invalid = true
2206			}
2207		case "files":
2208			out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
2209			if out.Values[i] == graphql.Null {
2210				invalid = true
2211			}
2212		default:
2213			panic("unknown field " + strconv.Quote(field.Name))
2214		}
2215	}
2216	wg.Wait()
2217	if invalid {
2218		return graphql.Null
2219	}
2220	return out
2221}
2222
2223// nolint: vetshadow
2224func (ec *executionContext) _AddCommentOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
2225	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2226	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2227	rctx := &graphql.ResolverContext{
2228		Object: "AddCommentOperation",
2229		Args:   nil,
2230		Field:  field,
2231	}
2232	ctx = graphql.WithResolverContext(ctx, rctx)
2233	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2234	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2235		ctx = rctx // use context from middleware stack in children
2236		return obj.Hash()
2237	})
2238	if resTmp == nil {
2239		if !ec.HasError(rctx) {
2240			ec.Errorf(ctx, "must not be null")
2241		}
2242		return graphql.Null
2243	}
2244	res := resTmp.(git.Hash)
2245	rctx.Result = res
2246	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2247	return res
2248}
2249
2250// nolint: vetshadow
2251func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
2252	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2253	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2254	rctx := &graphql.ResolverContext{
2255		Object: "AddCommentOperation",
2256		Args:   nil,
2257		Field:  field,
2258	}
2259	ctx = graphql.WithResolverContext(ctx, rctx)
2260	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2261	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2262		ctx = rctx // use context from middleware stack in children
2263		return obj.Author, nil
2264	})
2265	if resTmp == nil {
2266		if !ec.HasError(rctx) {
2267			ec.Errorf(ctx, "must not be null")
2268		}
2269		return graphql.Null
2270	}
2271	res := resTmp.(identity.Interface)
2272	rctx.Result = res
2273	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2274
2275	return ec._Identity(ctx, field.Selections, &res)
2276}
2277
2278// nolint: vetshadow
2279func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
2280	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2281	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2282	rctx := &graphql.ResolverContext{
2283		Object: "AddCommentOperation",
2284		Args:   nil,
2285		Field:  field,
2286	}
2287	ctx = graphql.WithResolverContext(ctx, rctx)
2288	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2289	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2290		ctx = rctx // use context from middleware stack in children
2291		return ec.resolvers.AddCommentOperation().Date(rctx, obj)
2292	})
2293	if resTmp == nil {
2294		if !ec.HasError(rctx) {
2295			ec.Errorf(ctx, "must not be null")
2296		}
2297		return graphql.Null
2298	}
2299	res := resTmp.(time.Time)
2300	rctx.Result = res
2301	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2302	return graphql.MarshalTime(res)
2303}
2304
2305// nolint: vetshadow
2306func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
2307	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2308	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2309	rctx := &graphql.ResolverContext{
2310		Object: "AddCommentOperation",
2311		Args:   nil,
2312		Field:  field,
2313	}
2314	ctx = graphql.WithResolverContext(ctx, rctx)
2315	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2316	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2317		ctx = rctx // use context from middleware stack in children
2318		return obj.Message, nil
2319	})
2320	if resTmp == nil {
2321		if !ec.HasError(rctx) {
2322			ec.Errorf(ctx, "must not be null")
2323		}
2324		return graphql.Null
2325	}
2326	res := resTmp.(string)
2327	rctx.Result = res
2328	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2329	return graphql.MarshalString(res)
2330}
2331
2332// nolint: vetshadow
2333func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
2334	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2335	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2336	rctx := &graphql.ResolverContext{
2337		Object: "AddCommentOperation",
2338		Args:   nil,
2339		Field:  field,
2340	}
2341	ctx = graphql.WithResolverContext(ctx, rctx)
2342	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2343	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2344		ctx = rctx // use context from middleware stack in children
2345		return obj.Files, nil
2346	})
2347	if resTmp == nil {
2348		if !ec.HasError(rctx) {
2349			ec.Errorf(ctx, "must not be null")
2350		}
2351		return graphql.Null
2352	}
2353	res := resTmp.([]git.Hash)
2354	rctx.Result = res
2355	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2356
2357	arr1 := make(graphql.Array, len(res))
2358
2359	for idx1 := range res {
2360		arr1[idx1] = func() graphql.Marshaler {
2361			return res[idx1]
2362		}()
2363	}
2364
2365	return arr1
2366}
2367
2368var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem"}
2369
2370// nolint: gocyclo, errcheck, gas, goconst
2371func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2372	fields := graphql.CollectFields(ctx, sel, addCommentTimelineItemImplementors)
2373
2374	var wg sync.WaitGroup
2375	out := graphql.NewOrderedMap(len(fields))
2376	invalid := false
2377	for i, field := range fields {
2378		out.Keys[i] = field.Alias
2379
2380		switch field.Name {
2381		case "__typename":
2382			out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
2383		case "hash":
2384			out.Values[i] = ec._AddCommentTimelineItem_hash(ctx, field, obj)
2385			if out.Values[i] == graphql.Null {
2386				invalid = true
2387			}
2388		case "author":
2389			out.Values[i] = ec._AddCommentTimelineItem_author(ctx, field, obj)
2390			if out.Values[i] == graphql.Null {
2391				invalid = true
2392			}
2393		case "message":
2394			out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
2395			if out.Values[i] == graphql.Null {
2396				invalid = true
2397			}
2398		case "messageIsEmpty":
2399			out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
2400			if out.Values[i] == graphql.Null {
2401				invalid = true
2402			}
2403		case "files":
2404			out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
2405			if out.Values[i] == graphql.Null {
2406				invalid = true
2407			}
2408		case "createdAt":
2409			wg.Add(1)
2410			go func(i int, field graphql.CollectedField) {
2411				out.Values[i] = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
2412				if out.Values[i] == graphql.Null {
2413					invalid = true
2414				}
2415				wg.Done()
2416			}(i, field)
2417		case "lastEdit":
2418			wg.Add(1)
2419			go func(i int, field graphql.CollectedField) {
2420				out.Values[i] = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
2421				if out.Values[i] == graphql.Null {
2422					invalid = true
2423				}
2424				wg.Done()
2425			}(i, field)
2426		case "edited":
2427			out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
2428			if out.Values[i] == graphql.Null {
2429				invalid = true
2430			}
2431		case "history":
2432			out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
2433			if out.Values[i] == graphql.Null {
2434				invalid = true
2435			}
2436		default:
2437			panic("unknown field " + strconv.Quote(field.Name))
2438		}
2439	}
2440	wg.Wait()
2441	if invalid {
2442		return graphql.Null
2443	}
2444	return out
2445}
2446
2447// nolint: vetshadow
2448func (ec *executionContext) _AddCommentTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2449	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2450	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2451	rctx := &graphql.ResolverContext{
2452		Object: "AddCommentTimelineItem",
2453		Args:   nil,
2454		Field:  field,
2455	}
2456	ctx = graphql.WithResolverContext(ctx, rctx)
2457	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2458	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2459		ctx = rctx // use context from middleware stack in children
2460		return obj.Hash(), nil
2461	})
2462	if resTmp == nil {
2463		if !ec.HasError(rctx) {
2464			ec.Errorf(ctx, "must not be null")
2465		}
2466		return graphql.Null
2467	}
2468	res := resTmp.(git.Hash)
2469	rctx.Result = res
2470	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2471	return res
2472}
2473
2474// nolint: vetshadow
2475func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2476	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2477	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2478	rctx := &graphql.ResolverContext{
2479		Object: "AddCommentTimelineItem",
2480		Args:   nil,
2481		Field:  field,
2482	}
2483	ctx = graphql.WithResolverContext(ctx, rctx)
2484	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2485	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2486		ctx = rctx // use context from middleware stack in children
2487		return obj.Author, nil
2488	})
2489	if resTmp == nil {
2490		if !ec.HasError(rctx) {
2491			ec.Errorf(ctx, "must not be null")
2492		}
2493		return graphql.Null
2494	}
2495	res := resTmp.(identity.Interface)
2496	rctx.Result = res
2497	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2498
2499	return ec._Identity(ctx, field.Selections, &res)
2500}
2501
2502// nolint: vetshadow
2503func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2504	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2505	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2506	rctx := &graphql.ResolverContext{
2507		Object: "AddCommentTimelineItem",
2508		Args:   nil,
2509		Field:  field,
2510	}
2511	ctx = graphql.WithResolverContext(ctx, rctx)
2512	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2513	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2514		ctx = rctx // use context from middleware stack in children
2515		return obj.Message, nil
2516	})
2517	if resTmp == nil {
2518		if !ec.HasError(rctx) {
2519			ec.Errorf(ctx, "must not be null")
2520		}
2521		return graphql.Null
2522	}
2523	res := resTmp.(string)
2524	rctx.Result = res
2525	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2526	return graphql.MarshalString(res)
2527}
2528
2529// nolint: vetshadow
2530func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2531	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2532	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2533	rctx := &graphql.ResolverContext{
2534		Object: "AddCommentTimelineItem",
2535		Args:   nil,
2536		Field:  field,
2537	}
2538	ctx = graphql.WithResolverContext(ctx, rctx)
2539	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2540	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2541		ctx = rctx // use context from middleware stack in children
2542		return obj.MessageIsEmpty(), nil
2543	})
2544	if resTmp == nil {
2545		if !ec.HasError(rctx) {
2546			ec.Errorf(ctx, "must not be null")
2547		}
2548		return graphql.Null
2549	}
2550	res := resTmp.(bool)
2551	rctx.Result = res
2552	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2553	return graphql.MarshalBoolean(res)
2554}
2555
2556// nolint: vetshadow
2557func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2558	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2559	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2560	rctx := &graphql.ResolverContext{
2561		Object: "AddCommentTimelineItem",
2562		Args:   nil,
2563		Field:  field,
2564	}
2565	ctx = graphql.WithResolverContext(ctx, rctx)
2566	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2567	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2568		ctx = rctx // use context from middleware stack in children
2569		return obj.Files, nil
2570	})
2571	if resTmp == nil {
2572		if !ec.HasError(rctx) {
2573			ec.Errorf(ctx, "must not be null")
2574		}
2575		return graphql.Null
2576	}
2577	res := resTmp.([]git.Hash)
2578	rctx.Result = res
2579	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2580
2581	arr1 := make(graphql.Array, len(res))
2582
2583	for idx1 := range res {
2584		arr1[idx1] = func() graphql.Marshaler {
2585			return res[idx1]
2586		}()
2587	}
2588
2589	return arr1
2590}
2591
2592// nolint: vetshadow
2593func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2594	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2595	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2596	rctx := &graphql.ResolverContext{
2597		Object: "AddCommentTimelineItem",
2598		Args:   nil,
2599		Field:  field,
2600	}
2601	ctx = graphql.WithResolverContext(ctx, rctx)
2602	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2603	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2604		ctx = rctx // use context from middleware stack in children
2605		return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
2606	})
2607	if resTmp == nil {
2608		if !ec.HasError(rctx) {
2609			ec.Errorf(ctx, "must not be null")
2610		}
2611		return graphql.Null
2612	}
2613	res := resTmp.(time.Time)
2614	rctx.Result = res
2615	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2616	return graphql.MarshalTime(res)
2617}
2618
2619// nolint: vetshadow
2620func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2621	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2622	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2623	rctx := &graphql.ResolverContext{
2624		Object: "AddCommentTimelineItem",
2625		Args:   nil,
2626		Field:  field,
2627	}
2628	ctx = graphql.WithResolverContext(ctx, rctx)
2629	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2630	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2631		ctx = rctx // use context from middleware stack in children
2632		return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
2633	})
2634	if resTmp == nil {
2635		if !ec.HasError(rctx) {
2636			ec.Errorf(ctx, "must not be null")
2637		}
2638		return graphql.Null
2639	}
2640	res := resTmp.(time.Time)
2641	rctx.Result = res
2642	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2643	return graphql.MarshalTime(res)
2644}
2645
2646// nolint: vetshadow
2647func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2648	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2649	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2650	rctx := &graphql.ResolverContext{
2651		Object: "AddCommentTimelineItem",
2652		Args:   nil,
2653		Field:  field,
2654	}
2655	ctx = graphql.WithResolverContext(ctx, rctx)
2656	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2657	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2658		ctx = rctx // use context from middleware stack in children
2659		return obj.Edited(), nil
2660	})
2661	if resTmp == nil {
2662		if !ec.HasError(rctx) {
2663			ec.Errorf(ctx, "must not be null")
2664		}
2665		return graphql.Null
2666	}
2667	res := resTmp.(bool)
2668	rctx.Result = res
2669	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2670	return graphql.MarshalBoolean(res)
2671}
2672
2673// nolint: vetshadow
2674func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2675	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2676	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2677	rctx := &graphql.ResolverContext{
2678		Object: "AddCommentTimelineItem",
2679		Args:   nil,
2680		Field:  field,
2681	}
2682	ctx = graphql.WithResolverContext(ctx, rctx)
2683	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2684	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2685		ctx = rctx // use context from middleware stack in children
2686		return obj.History, nil
2687	})
2688	if resTmp == nil {
2689		if !ec.HasError(rctx) {
2690			ec.Errorf(ctx, "must not be null")
2691		}
2692		return graphql.Null
2693	}
2694	res := resTmp.([]bug.CommentHistoryStep)
2695	rctx.Result = res
2696	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2697
2698	arr1 := make(graphql.Array, len(res))
2699	var wg sync.WaitGroup
2700
2701	isLen1 := len(res) == 1
2702	if !isLen1 {
2703		wg.Add(len(res))
2704	}
2705
2706	for idx1 := range res {
2707		idx1 := idx1
2708		rctx := &graphql.ResolverContext{
2709			Index:  &idx1,
2710			Result: &res[idx1],
2711		}
2712		ctx := graphql.WithResolverContext(ctx, rctx)
2713		f := func(idx1 int) {
2714			if !isLen1 {
2715				defer wg.Done()
2716			}
2717			arr1[idx1] = func() graphql.Marshaler {
2718
2719				return ec._CommentHistoryStep(ctx, field.Selections, &res[idx1])
2720			}()
2721		}
2722		if isLen1 {
2723			f(idx1)
2724		} else {
2725			go f(idx1)
2726		}
2727
2728	}
2729	wg.Wait()
2730	return arr1
2731}
2732
2733var bugImplementors = []string{"Bug"}
2734
2735// nolint: gocyclo, errcheck, gas, goconst
2736func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj *bug.Snapshot) graphql.Marshaler {
2737	fields := graphql.CollectFields(ctx, sel, bugImplementors)
2738
2739	var wg sync.WaitGroup
2740	out := graphql.NewOrderedMap(len(fields))
2741	invalid := false
2742	for i, field := range fields {
2743		out.Keys[i] = field.Alias
2744
2745		switch field.Name {
2746		case "__typename":
2747			out.Values[i] = graphql.MarshalString("Bug")
2748		case "id":
2749			out.Values[i] = ec._Bug_id(ctx, field, obj)
2750			if out.Values[i] == graphql.Null {
2751				invalid = true
2752			}
2753		case "humanId":
2754			out.Values[i] = ec._Bug_humanId(ctx, field, obj)
2755			if out.Values[i] == graphql.Null {
2756				invalid = true
2757			}
2758		case "status":
2759			wg.Add(1)
2760			go func(i int, field graphql.CollectedField) {
2761				out.Values[i] = ec._Bug_status(ctx, field, obj)
2762				if out.Values[i] == graphql.Null {
2763					invalid = true
2764				}
2765				wg.Done()
2766			}(i, field)
2767		case "title":
2768			out.Values[i] = ec._Bug_title(ctx, field, obj)
2769			if out.Values[i] == graphql.Null {
2770				invalid = true
2771			}
2772		case "labels":
2773			out.Values[i] = ec._Bug_labels(ctx, field, obj)
2774			if out.Values[i] == graphql.Null {
2775				invalid = true
2776			}
2777		case "author":
2778			out.Values[i] = ec._Bug_author(ctx, field, obj)
2779			if out.Values[i] == graphql.Null {
2780				invalid = true
2781			}
2782		case "createdAt":
2783			out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
2784			if out.Values[i] == graphql.Null {
2785				invalid = true
2786			}
2787		case "lastEdit":
2788			wg.Add(1)
2789			go func(i int, field graphql.CollectedField) {
2790				out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
2791				if out.Values[i] == graphql.Null {
2792					invalid = true
2793				}
2794				wg.Done()
2795			}(i, field)
2796		case "comments":
2797			wg.Add(1)
2798			go func(i int, field graphql.CollectedField) {
2799				out.Values[i] = ec._Bug_comments(ctx, field, obj)
2800				if out.Values[i] == graphql.Null {
2801					invalid = true
2802				}
2803				wg.Done()
2804			}(i, field)
2805		case "timeline":
2806			wg.Add(1)
2807			go func(i int, field graphql.CollectedField) {
2808				out.Values[i] = ec._Bug_timeline(ctx, field, obj)
2809				if out.Values[i] == graphql.Null {
2810					invalid = true
2811				}
2812				wg.Done()
2813			}(i, field)
2814		case "operations":
2815			wg.Add(1)
2816			go func(i int, field graphql.CollectedField) {
2817				out.Values[i] = ec._Bug_operations(ctx, field, obj)
2818				if out.Values[i] == graphql.Null {
2819					invalid = true
2820				}
2821				wg.Done()
2822			}(i, field)
2823		default:
2824			panic("unknown field " + strconv.Quote(field.Name))
2825		}
2826	}
2827	wg.Wait()
2828	if invalid {
2829		return graphql.Null
2830	}
2831	return out
2832}
2833
2834// nolint: vetshadow
2835func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2836	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2837	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2838	rctx := &graphql.ResolverContext{
2839		Object: "Bug",
2840		Args:   nil,
2841		Field:  field,
2842	}
2843	ctx = graphql.WithResolverContext(ctx, rctx)
2844	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2845	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2846		ctx = rctx // use context from middleware stack in children
2847		return obj.Id(), nil
2848	})
2849	if resTmp == nil {
2850		if !ec.HasError(rctx) {
2851			ec.Errorf(ctx, "must not be null")
2852		}
2853		return graphql.Null
2854	}
2855	res := resTmp.(string)
2856	rctx.Result = res
2857	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2858	return graphql.MarshalString(res)
2859}
2860
2861// nolint: vetshadow
2862func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2863	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2864	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2865	rctx := &graphql.ResolverContext{
2866		Object: "Bug",
2867		Args:   nil,
2868		Field:  field,
2869	}
2870	ctx = graphql.WithResolverContext(ctx, rctx)
2871	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2872	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2873		ctx = rctx // use context from middleware stack in children
2874		return obj.HumanId(), nil
2875	})
2876	if resTmp == nil {
2877		if !ec.HasError(rctx) {
2878			ec.Errorf(ctx, "must not be null")
2879		}
2880		return graphql.Null
2881	}
2882	res := resTmp.(string)
2883	rctx.Result = res
2884	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2885	return graphql.MarshalString(res)
2886}
2887
2888// nolint: vetshadow
2889func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2890	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2891	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2892	rctx := &graphql.ResolverContext{
2893		Object: "Bug",
2894		Args:   nil,
2895		Field:  field,
2896	}
2897	ctx = graphql.WithResolverContext(ctx, rctx)
2898	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2899	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2900		ctx = rctx // use context from middleware stack in children
2901		return ec.resolvers.Bug().Status(rctx, obj)
2902	})
2903	if resTmp == nil {
2904		if !ec.HasError(rctx) {
2905			ec.Errorf(ctx, "must not be null")
2906		}
2907		return graphql.Null
2908	}
2909	res := resTmp.(models.Status)
2910	rctx.Result = res
2911	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2912	return res
2913}
2914
2915// nolint: vetshadow
2916func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2917	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2918	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2919	rctx := &graphql.ResolverContext{
2920		Object: "Bug",
2921		Args:   nil,
2922		Field:  field,
2923	}
2924	ctx = graphql.WithResolverContext(ctx, rctx)
2925	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2926	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2927		ctx = rctx // use context from middleware stack in children
2928		return obj.Title, nil
2929	})
2930	if resTmp == nil {
2931		if !ec.HasError(rctx) {
2932			ec.Errorf(ctx, "must not be null")
2933		}
2934		return graphql.Null
2935	}
2936	res := resTmp.(string)
2937	rctx.Result = res
2938	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2939	return graphql.MarshalString(res)
2940}
2941
2942// nolint: vetshadow
2943func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2944	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2945	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2946	rctx := &graphql.ResolverContext{
2947		Object: "Bug",
2948		Args:   nil,
2949		Field:  field,
2950	}
2951	ctx = graphql.WithResolverContext(ctx, rctx)
2952	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2953	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2954		ctx = rctx // use context from middleware stack in children
2955		return obj.Labels, nil
2956	})
2957	if resTmp == nil {
2958		if !ec.HasError(rctx) {
2959			ec.Errorf(ctx, "must not be null")
2960		}
2961		return graphql.Null
2962	}
2963	res := resTmp.([]bug.Label)
2964	rctx.Result = res
2965	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2966
2967	arr1 := make(graphql.Array, len(res))
2968
2969	for idx1 := range res {
2970		arr1[idx1] = func() graphql.Marshaler {
2971			return res[idx1]
2972		}()
2973	}
2974
2975	return arr1
2976}
2977
2978// nolint: vetshadow
2979func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2980	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2981	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2982	rctx := &graphql.ResolverContext{
2983		Object: "Bug",
2984		Args:   nil,
2985		Field:  field,
2986	}
2987	ctx = graphql.WithResolverContext(ctx, rctx)
2988	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2989	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2990		ctx = rctx // use context from middleware stack in children
2991		return obj.Author, nil
2992	})
2993	if resTmp == nil {
2994		if !ec.HasError(rctx) {
2995			ec.Errorf(ctx, "must not be null")
2996		}
2997		return graphql.Null
2998	}
2999	res := resTmp.(identity.Interface)
3000	rctx.Result = res
3001	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3002
3003	return ec._Identity(ctx, field.Selections, &res)
3004}
3005
3006// nolint: vetshadow
3007func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
3008	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3009	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3010	rctx := &graphql.ResolverContext{
3011		Object: "Bug",
3012		Args:   nil,
3013		Field:  field,
3014	}
3015	ctx = graphql.WithResolverContext(ctx, rctx)
3016	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3017	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3018		ctx = rctx // use context from middleware stack in children
3019		return obj.CreatedAt, nil
3020	})
3021	if resTmp == nil {
3022		if !ec.HasError(rctx) {
3023			ec.Errorf(ctx, "must not be null")
3024		}
3025		return graphql.Null
3026	}
3027	res := resTmp.(time.Time)
3028	rctx.Result = res
3029	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3030	return graphql.MarshalTime(res)
3031}
3032
3033// nolint: vetshadow
3034func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
3035	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3036	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3037	rctx := &graphql.ResolverContext{
3038		Object: "Bug",
3039		Args:   nil,
3040		Field:  field,
3041	}
3042	ctx = graphql.WithResolverContext(ctx, rctx)
3043	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3044	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3045		ctx = rctx // use context from middleware stack in children
3046		return ec.resolvers.Bug().LastEdit(rctx, obj)
3047	})
3048	if resTmp == nil {
3049		if !ec.HasError(rctx) {
3050			ec.Errorf(ctx, "must not be null")
3051		}
3052		return graphql.Null
3053	}
3054	res := resTmp.(time.Time)
3055	rctx.Result = res
3056	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3057	return graphql.MarshalTime(res)
3058}
3059
3060// nolint: vetshadow
3061func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
3062	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3063	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3064	rawArgs := field.ArgumentMap(ec.Variables)
3065	args, err := field_Bug_comments_args(rawArgs)
3066	if err != nil {
3067		ec.Error(ctx, err)
3068		return graphql.Null
3069	}
3070	rctx := &graphql.ResolverContext{
3071		Object: "Bug",
3072		Args:   args,
3073		Field:  field,
3074	}
3075	ctx = graphql.WithResolverContext(ctx, rctx)
3076	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3077	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3078		ctx = rctx // use context from middleware stack in children
3079		return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
3080	})
3081	if resTmp == nil {
3082		if !ec.HasError(rctx) {
3083			ec.Errorf(ctx, "must not be null")
3084		}
3085		return graphql.Null
3086	}
3087	res := resTmp.(models.CommentConnection)
3088	rctx.Result = res
3089	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3090
3091	return ec._CommentConnection(ctx, field.Selections, &res)
3092}
3093
3094// nolint: vetshadow
3095func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
3096	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3097	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3098	rawArgs := field.ArgumentMap(ec.Variables)
3099	args, err := field_Bug_timeline_args(rawArgs)
3100	if err != nil {
3101		ec.Error(ctx, err)
3102		return graphql.Null
3103	}
3104	rctx := &graphql.ResolverContext{
3105		Object: "Bug",
3106		Args:   args,
3107		Field:  field,
3108	}
3109	ctx = graphql.WithResolverContext(ctx, rctx)
3110	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3111	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3112		ctx = rctx // use context from middleware stack in children
3113		return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
3114	})
3115	if resTmp == nil {
3116		if !ec.HasError(rctx) {
3117			ec.Errorf(ctx, "must not be null")
3118		}
3119		return graphql.Null
3120	}
3121	res := resTmp.(models.TimelineItemConnection)
3122	rctx.Result = res
3123	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3124
3125	return ec._TimelineItemConnection(ctx, field.Selections, &res)
3126}
3127
3128// nolint: vetshadow
3129func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
3130	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3131	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3132	rawArgs := field.ArgumentMap(ec.Variables)
3133	args, err := field_Bug_operations_args(rawArgs)
3134	if err != nil {
3135		ec.Error(ctx, err)
3136		return graphql.Null
3137	}
3138	rctx := &graphql.ResolverContext{
3139		Object: "Bug",
3140		Args:   args,
3141		Field:  field,
3142	}
3143	ctx = graphql.WithResolverContext(ctx, rctx)
3144	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3145	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3146		ctx = rctx // use context from middleware stack in children
3147		return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
3148	})
3149	if resTmp == nil {
3150		if !ec.HasError(rctx) {
3151			ec.Errorf(ctx, "must not be null")
3152		}
3153		return graphql.Null
3154	}
3155	res := resTmp.(models.OperationConnection)
3156	rctx.Result = res
3157	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3158
3159	return ec._OperationConnection(ctx, field.Selections, &res)
3160}
3161
3162var bugConnectionImplementors = []string{"BugConnection"}
3163
3164// nolint: gocyclo, errcheck, gas, goconst
3165func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
3166	fields := graphql.CollectFields(ctx, sel, bugConnectionImplementors)
3167
3168	out := graphql.NewOrderedMap(len(fields))
3169	invalid := false
3170	for i, field := range fields {
3171		out.Keys[i] = field.Alias
3172
3173		switch field.Name {
3174		case "__typename":
3175			out.Values[i] = graphql.MarshalString("BugConnection")
3176		case "edges":
3177			out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
3178			if out.Values[i] == graphql.Null {
3179				invalid = true
3180			}
3181		case "nodes":
3182			out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
3183			if out.Values[i] == graphql.Null {
3184				invalid = true
3185			}
3186		case "pageInfo":
3187			out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
3188			if out.Values[i] == graphql.Null {
3189				invalid = true
3190			}
3191		case "totalCount":
3192			out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
3193			if out.Values[i] == graphql.Null {
3194				invalid = true
3195			}
3196		default:
3197			panic("unknown field " + strconv.Quote(field.Name))
3198		}
3199	}
3200
3201	if invalid {
3202		return graphql.Null
3203	}
3204	return out
3205}
3206
3207// nolint: vetshadow
3208func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
3209	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3210	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3211	rctx := &graphql.ResolverContext{
3212		Object: "BugConnection",
3213		Args:   nil,
3214		Field:  field,
3215	}
3216	ctx = graphql.WithResolverContext(ctx, rctx)
3217	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3218	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3219		ctx = rctx // use context from middleware stack in children
3220		return obj.Edges, nil
3221	})
3222	if resTmp == nil {
3223		if !ec.HasError(rctx) {
3224			ec.Errorf(ctx, "must not be null")
3225		}
3226		return graphql.Null
3227	}
3228	res := resTmp.([]models.BugEdge)
3229	rctx.Result = res
3230	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3231
3232	arr1 := make(graphql.Array, len(res))
3233	var wg sync.WaitGroup
3234
3235	isLen1 := len(res) == 1
3236	if !isLen1 {
3237		wg.Add(len(res))
3238	}
3239
3240	for idx1 := range res {
3241		idx1 := idx1
3242		rctx := &graphql.ResolverContext{
3243			Index:  &idx1,
3244			Result: &res[idx1],
3245		}
3246		ctx := graphql.WithResolverContext(ctx, rctx)
3247		f := func(idx1 int) {
3248			if !isLen1 {
3249				defer wg.Done()
3250			}
3251			arr1[idx1] = func() graphql.Marshaler {
3252
3253				return ec._BugEdge(ctx, field.Selections, &res[idx1])
3254			}()
3255		}
3256		if isLen1 {
3257			f(idx1)
3258		} else {
3259			go f(idx1)
3260		}
3261
3262	}
3263	wg.Wait()
3264	return arr1
3265}
3266
3267// nolint: vetshadow
3268func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
3269	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3270	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3271	rctx := &graphql.ResolverContext{
3272		Object: "BugConnection",
3273		Args:   nil,
3274		Field:  field,
3275	}
3276	ctx = graphql.WithResolverContext(ctx, rctx)
3277	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3278	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3279		ctx = rctx // use context from middleware stack in children
3280		return obj.Nodes, nil
3281	})
3282	if resTmp == nil {
3283		if !ec.HasError(rctx) {
3284			ec.Errorf(ctx, "must not be null")
3285		}
3286		return graphql.Null
3287	}
3288	res := resTmp.([]bug.Snapshot)
3289	rctx.Result = res
3290	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3291
3292	arr1 := make(graphql.Array, len(res))
3293	var wg sync.WaitGroup
3294
3295	isLen1 := len(res) == 1
3296	if !isLen1 {
3297		wg.Add(len(res))
3298	}
3299
3300	for idx1 := range res {
3301		idx1 := idx1
3302		rctx := &graphql.ResolverContext{
3303			Index:  &idx1,
3304			Result: &res[idx1],
3305		}
3306		ctx := graphql.WithResolverContext(ctx, rctx)
3307		f := func(idx1 int) {
3308			if !isLen1 {
3309				defer wg.Done()
3310			}
3311			arr1[idx1] = func() graphql.Marshaler {
3312
3313				return ec._Bug(ctx, field.Selections, &res[idx1])
3314			}()
3315		}
3316		if isLen1 {
3317			f(idx1)
3318		} else {
3319			go f(idx1)
3320		}
3321
3322	}
3323	wg.Wait()
3324	return arr1
3325}
3326
3327// nolint: vetshadow
3328func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
3329	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3330	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3331	rctx := &graphql.ResolverContext{
3332		Object: "BugConnection",
3333		Args:   nil,
3334		Field:  field,
3335	}
3336	ctx = graphql.WithResolverContext(ctx, rctx)
3337	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3338	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3339		ctx = rctx // use context from middleware stack in children
3340		return obj.PageInfo, nil
3341	})
3342	if resTmp == nil {
3343		if !ec.HasError(rctx) {
3344			ec.Errorf(ctx, "must not be null")
3345		}
3346		return graphql.Null
3347	}
3348	res := resTmp.(models.PageInfo)
3349	rctx.Result = res
3350	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3351
3352	return ec._PageInfo(ctx, field.Selections, &res)
3353}
3354
3355// nolint: vetshadow
3356func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
3357	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3358	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3359	rctx := &graphql.ResolverContext{
3360		Object: "BugConnection",
3361		Args:   nil,
3362		Field:  field,
3363	}
3364	ctx = graphql.WithResolverContext(ctx, rctx)
3365	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3366	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3367		ctx = rctx // use context from middleware stack in children
3368		return obj.TotalCount, nil
3369	})
3370	if resTmp == nil {
3371		if !ec.HasError(rctx) {
3372			ec.Errorf(ctx, "must not be null")
3373		}
3374		return graphql.Null
3375	}
3376	res := resTmp.(int)
3377	rctx.Result = res
3378	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3379	return graphql.MarshalInt(res)
3380}
3381
3382var bugEdgeImplementors = []string{"BugEdge"}
3383
3384// nolint: gocyclo, errcheck, gas, goconst
3385func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
3386	fields := graphql.CollectFields(ctx, sel, bugEdgeImplementors)
3387
3388	out := graphql.NewOrderedMap(len(fields))
3389	invalid := false
3390	for i, field := range fields {
3391		out.Keys[i] = field.Alias
3392
3393		switch field.Name {
3394		case "__typename":
3395			out.Values[i] = graphql.MarshalString("BugEdge")
3396		case "cursor":
3397			out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
3398			if out.Values[i] == graphql.Null {
3399				invalid = true
3400			}
3401		case "node":
3402			out.Values[i] = ec._BugEdge_node(ctx, field, obj)
3403			if out.Values[i] == graphql.Null {
3404				invalid = true
3405			}
3406		default:
3407			panic("unknown field " + strconv.Quote(field.Name))
3408		}
3409	}
3410
3411	if invalid {
3412		return graphql.Null
3413	}
3414	return out
3415}
3416
3417// nolint: vetshadow
3418func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) graphql.Marshaler {
3419	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3420	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3421	rctx := &graphql.ResolverContext{
3422		Object: "BugEdge",
3423		Args:   nil,
3424		Field:  field,
3425	}
3426	ctx = graphql.WithResolverContext(ctx, rctx)
3427	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3428	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3429		ctx = rctx // use context from middleware stack in children
3430		return obj.Cursor, nil
3431	})
3432	if resTmp == nil {
3433		if !ec.HasError(rctx) {
3434			ec.Errorf(ctx, "must not be null")
3435		}
3436		return graphql.Null
3437	}
3438	res := resTmp.(string)
3439	rctx.Result = res
3440	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3441	return graphql.MarshalString(res)
3442}
3443
3444// nolint: vetshadow
3445func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) graphql.Marshaler {
3446	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3447	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3448	rctx := &graphql.ResolverContext{
3449		Object: "BugEdge",
3450		Args:   nil,
3451		Field:  field,
3452	}
3453	ctx = graphql.WithResolverContext(ctx, rctx)
3454	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3455	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3456		ctx = rctx // use context from middleware stack in children
3457		return obj.Node, nil
3458	})
3459	if resTmp == nil {
3460		if !ec.HasError(rctx) {
3461			ec.Errorf(ctx, "must not be null")
3462		}
3463		return graphql.Null
3464	}
3465	res := resTmp.(bug.Snapshot)
3466	rctx.Result = res
3467	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3468
3469	return ec._Bug(ctx, field.Selections, &res)
3470}
3471
3472var commentImplementors = []string{"Comment", "Authored"}
3473
3474// nolint: gocyclo, errcheck, gas, goconst
3475func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
3476	fields := graphql.CollectFields(ctx, sel, commentImplementors)
3477
3478	out := graphql.NewOrderedMap(len(fields))
3479	invalid := false
3480	for i, field := range fields {
3481		out.Keys[i] = field.Alias
3482
3483		switch field.Name {
3484		case "__typename":
3485			out.Values[i] = graphql.MarshalString("Comment")
3486		case "author":
3487			out.Values[i] = ec._Comment_author(ctx, field, obj)
3488			if out.Values[i] == graphql.Null {
3489				invalid = true
3490			}
3491		case "message":
3492			out.Values[i] = ec._Comment_message(ctx, field, obj)
3493			if out.Values[i] == graphql.Null {
3494				invalid = true
3495			}
3496		case "files":
3497			out.Values[i] = ec._Comment_files(ctx, field, obj)
3498			if out.Values[i] == graphql.Null {
3499				invalid = true
3500			}
3501		default:
3502			panic("unknown field " + strconv.Quote(field.Name))
3503		}
3504	}
3505
3506	if invalid {
3507		return graphql.Null
3508	}
3509	return out
3510}
3511
3512// nolint: vetshadow
3513func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
3514	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3515	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3516	rctx := &graphql.ResolverContext{
3517		Object: "Comment",
3518		Args:   nil,
3519		Field:  field,
3520	}
3521	ctx = graphql.WithResolverContext(ctx, rctx)
3522	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3523	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3524		ctx = rctx // use context from middleware stack in children
3525		return obj.Author, nil
3526	})
3527	if resTmp == nil {
3528		if !ec.HasError(rctx) {
3529			ec.Errorf(ctx, "must not be null")
3530		}
3531		return graphql.Null
3532	}
3533	res := resTmp.(identity.Interface)
3534	rctx.Result = res
3535	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3536
3537	return ec._Identity(ctx, field.Selections, &res)
3538}
3539
3540// nolint: vetshadow
3541func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
3542	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3543	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3544	rctx := &graphql.ResolverContext{
3545		Object: "Comment",
3546		Args:   nil,
3547		Field:  field,
3548	}
3549	ctx = graphql.WithResolverContext(ctx, rctx)
3550	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3551	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3552		ctx = rctx // use context from middleware stack in children
3553		return obj.Message, nil
3554	})
3555	if resTmp == nil {
3556		if !ec.HasError(rctx) {
3557			ec.Errorf(ctx, "must not be null")
3558		}
3559		return graphql.Null
3560	}
3561	res := resTmp.(string)
3562	rctx.Result = res
3563	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3564	return graphql.MarshalString(res)
3565}
3566
3567// nolint: vetshadow
3568func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
3569	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3570	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3571	rctx := &graphql.ResolverContext{
3572		Object: "Comment",
3573		Args:   nil,
3574		Field:  field,
3575	}
3576	ctx = graphql.WithResolverContext(ctx, rctx)
3577	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3578	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3579		ctx = rctx // use context from middleware stack in children
3580		return obj.Files, nil
3581	})
3582	if resTmp == nil {
3583		if !ec.HasError(rctx) {
3584			ec.Errorf(ctx, "must not be null")
3585		}
3586		return graphql.Null
3587	}
3588	res := resTmp.([]git.Hash)
3589	rctx.Result = res
3590	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3591
3592	arr1 := make(graphql.Array, len(res))
3593
3594	for idx1 := range res {
3595		arr1[idx1] = func() graphql.Marshaler {
3596			return res[idx1]
3597		}()
3598	}
3599
3600	return arr1
3601}
3602
3603var commentConnectionImplementors = []string{"CommentConnection"}
3604
3605// nolint: gocyclo, errcheck, gas, goconst
3606func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
3607	fields := graphql.CollectFields(ctx, sel, commentConnectionImplementors)
3608
3609	out := graphql.NewOrderedMap(len(fields))
3610	invalid := false
3611	for i, field := range fields {
3612		out.Keys[i] = field.Alias
3613
3614		switch field.Name {
3615		case "__typename":
3616			out.Values[i] = graphql.MarshalString("CommentConnection")
3617		case "edges":
3618			out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
3619			if out.Values[i] == graphql.Null {
3620				invalid = true
3621			}
3622		case "nodes":
3623			out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
3624			if out.Values[i] == graphql.Null {
3625				invalid = true
3626			}
3627		case "pageInfo":
3628			out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
3629			if out.Values[i] == graphql.Null {
3630				invalid = true
3631			}
3632		case "totalCount":
3633			out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
3634			if out.Values[i] == graphql.Null {
3635				invalid = true
3636			}
3637		default:
3638			panic("unknown field " + strconv.Quote(field.Name))
3639		}
3640	}
3641
3642	if invalid {
3643		return graphql.Null
3644	}
3645	return out
3646}
3647
3648// nolint: vetshadow
3649func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
3650	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3651	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3652	rctx := &graphql.ResolverContext{
3653		Object: "CommentConnection",
3654		Args:   nil,
3655		Field:  field,
3656	}
3657	ctx = graphql.WithResolverContext(ctx, rctx)
3658	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3659	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3660		ctx = rctx // use context from middleware stack in children
3661		return obj.Edges, nil
3662	})
3663	if resTmp == nil {
3664		if !ec.HasError(rctx) {
3665			ec.Errorf(ctx, "must not be null")
3666		}
3667		return graphql.Null
3668	}
3669	res := resTmp.([]models.CommentEdge)
3670	rctx.Result = res
3671	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3672
3673	arr1 := make(graphql.Array, len(res))
3674	var wg sync.WaitGroup
3675
3676	isLen1 := len(res) == 1
3677	if !isLen1 {
3678		wg.Add(len(res))
3679	}
3680
3681	for idx1 := range res {
3682		idx1 := idx1
3683		rctx := &graphql.ResolverContext{
3684			Index:  &idx1,
3685			Result: &res[idx1],
3686		}
3687		ctx := graphql.WithResolverContext(ctx, rctx)
3688		f := func(idx1 int) {
3689			if !isLen1 {
3690				defer wg.Done()
3691			}
3692			arr1[idx1] = func() graphql.Marshaler {
3693
3694				return ec._CommentEdge(ctx, field.Selections, &res[idx1])
3695			}()
3696		}
3697		if isLen1 {
3698			f(idx1)
3699		} else {
3700			go f(idx1)
3701		}
3702
3703	}
3704	wg.Wait()
3705	return arr1
3706}
3707
3708// nolint: vetshadow
3709func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
3710	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3711	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3712	rctx := &graphql.ResolverContext{
3713		Object: "CommentConnection",
3714		Args:   nil,
3715		Field:  field,
3716	}
3717	ctx = graphql.WithResolverContext(ctx, rctx)
3718	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3719	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3720		ctx = rctx // use context from middleware stack in children
3721		return obj.Nodes, nil
3722	})
3723	if resTmp == nil {
3724		if !ec.HasError(rctx) {
3725			ec.Errorf(ctx, "must not be null")
3726		}
3727		return graphql.Null
3728	}
3729	res := resTmp.([]bug.Comment)
3730	rctx.Result = res
3731	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3732
3733	arr1 := make(graphql.Array, len(res))
3734	var wg sync.WaitGroup
3735
3736	isLen1 := len(res) == 1
3737	if !isLen1 {
3738		wg.Add(len(res))
3739	}
3740
3741	for idx1 := range res {
3742		idx1 := idx1
3743		rctx := &graphql.ResolverContext{
3744			Index:  &idx1,
3745			Result: &res[idx1],
3746		}
3747		ctx := graphql.WithResolverContext(ctx, rctx)
3748		f := func(idx1 int) {
3749			if !isLen1 {
3750				defer wg.Done()
3751			}
3752			arr1[idx1] = func() graphql.Marshaler {
3753
3754				return ec._Comment(ctx, field.Selections, &res[idx1])
3755			}()
3756		}
3757		if isLen1 {
3758			f(idx1)
3759		} else {
3760			go f(idx1)
3761		}
3762
3763	}
3764	wg.Wait()
3765	return arr1
3766}
3767
3768// nolint: vetshadow
3769func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
3770	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3771	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3772	rctx := &graphql.ResolverContext{
3773		Object: "CommentConnection",
3774		Args:   nil,
3775		Field:  field,
3776	}
3777	ctx = graphql.WithResolverContext(ctx, rctx)
3778	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3779	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3780		ctx = rctx // use context from middleware stack in children
3781		return obj.PageInfo, nil
3782	})
3783	if resTmp == nil {
3784		if !ec.HasError(rctx) {
3785			ec.Errorf(ctx, "must not be null")
3786		}
3787		return graphql.Null
3788	}
3789	res := resTmp.(models.PageInfo)
3790	rctx.Result = res
3791	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3792
3793	return ec._PageInfo(ctx, field.Selections, &res)
3794}
3795
3796// nolint: vetshadow
3797func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
3798	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3799	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3800	rctx := &graphql.ResolverContext{
3801		Object: "CommentConnection",
3802		Args:   nil,
3803		Field:  field,
3804	}
3805	ctx = graphql.WithResolverContext(ctx, rctx)
3806	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3807	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3808		ctx = rctx // use context from middleware stack in children
3809		return obj.TotalCount, nil
3810	})
3811	if resTmp == nil {
3812		if !ec.HasError(rctx) {
3813			ec.Errorf(ctx, "must not be null")
3814		}
3815		return graphql.Null
3816	}
3817	res := resTmp.(int)
3818	rctx.Result = res
3819	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3820	return graphql.MarshalInt(res)
3821}
3822
3823var commentEdgeImplementors = []string{"CommentEdge"}
3824
3825// nolint: gocyclo, errcheck, gas, goconst
3826func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
3827	fields := graphql.CollectFields(ctx, sel, commentEdgeImplementors)
3828
3829	out := graphql.NewOrderedMap(len(fields))
3830	invalid := false
3831	for i, field := range fields {
3832		out.Keys[i] = field.Alias
3833
3834		switch field.Name {
3835		case "__typename":
3836			out.Values[i] = graphql.MarshalString("CommentEdge")
3837		case "cursor":
3838			out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
3839			if out.Values[i] == graphql.Null {
3840				invalid = true
3841			}
3842		case "node":
3843			out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
3844			if out.Values[i] == graphql.Null {
3845				invalid = true
3846			}
3847		default:
3848			panic("unknown field " + strconv.Quote(field.Name))
3849		}
3850	}
3851
3852	if invalid {
3853		return graphql.Null
3854	}
3855	return out
3856}
3857
3858// nolint: vetshadow
3859func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) graphql.Marshaler {
3860	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3861	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3862	rctx := &graphql.ResolverContext{
3863		Object: "CommentEdge",
3864		Args:   nil,
3865		Field:  field,
3866	}
3867	ctx = graphql.WithResolverContext(ctx, rctx)
3868	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3869	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3870		ctx = rctx // use context from middleware stack in children
3871		return obj.Cursor, nil
3872	})
3873	if resTmp == nil {
3874		if !ec.HasError(rctx) {
3875			ec.Errorf(ctx, "must not be null")
3876		}
3877		return graphql.Null
3878	}
3879	res := resTmp.(string)
3880	rctx.Result = res
3881	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3882	return graphql.MarshalString(res)
3883}
3884
3885// nolint: vetshadow
3886func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) graphql.Marshaler {
3887	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3888	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3889	rctx := &graphql.ResolverContext{
3890		Object: "CommentEdge",
3891		Args:   nil,
3892		Field:  field,
3893	}
3894	ctx = graphql.WithResolverContext(ctx, rctx)
3895	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3896	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3897		ctx = rctx // use context from middleware stack in children
3898		return obj.Node, nil
3899	})
3900	if resTmp == nil {
3901		if !ec.HasError(rctx) {
3902			ec.Errorf(ctx, "must not be null")
3903		}
3904		return graphql.Null
3905	}
3906	res := resTmp.(bug.Comment)
3907	rctx.Result = res
3908	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3909
3910	return ec._Comment(ctx, field.Selections, &res)
3911}
3912
3913var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
3914
3915// nolint: gocyclo, errcheck, gas, goconst
3916func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
3917	fields := graphql.CollectFields(ctx, sel, commentHistoryStepImplementors)
3918
3919	var wg sync.WaitGroup
3920	out := graphql.NewOrderedMap(len(fields))
3921	invalid := false
3922	for i, field := range fields {
3923		out.Keys[i] = field.Alias
3924
3925		switch field.Name {
3926		case "__typename":
3927			out.Values[i] = graphql.MarshalString("CommentHistoryStep")
3928		case "message":
3929			out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
3930			if out.Values[i] == graphql.Null {
3931				invalid = true
3932			}
3933		case "date":
3934			wg.Add(1)
3935			go func(i int, field graphql.CollectedField) {
3936				out.Values[i] = ec._CommentHistoryStep_date(ctx, field, obj)
3937				if out.Values[i] == graphql.Null {
3938					invalid = true
3939				}
3940				wg.Done()
3941			}(i, field)
3942		default:
3943			panic("unknown field " + strconv.Quote(field.Name))
3944		}
3945	}
3946	wg.Wait()
3947	if invalid {
3948		return graphql.Null
3949	}
3950	return out
3951}
3952
3953// nolint: vetshadow
3954func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) graphql.Marshaler {
3955	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3956	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3957	rctx := &graphql.ResolverContext{
3958		Object: "CommentHistoryStep",
3959		Args:   nil,
3960		Field:  field,
3961	}
3962	ctx = graphql.WithResolverContext(ctx, rctx)
3963	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3964	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3965		ctx = rctx // use context from middleware stack in children
3966		return obj.Message, nil
3967	})
3968	if resTmp == nil {
3969		if !ec.HasError(rctx) {
3970			ec.Errorf(ctx, "must not be null")
3971		}
3972		return graphql.Null
3973	}
3974	res := resTmp.(string)
3975	rctx.Result = res
3976	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3977	return graphql.MarshalString(res)
3978}
3979
3980// nolint: vetshadow
3981func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) graphql.Marshaler {
3982	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3983	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3984	rctx := &graphql.ResolverContext{
3985		Object: "CommentHistoryStep",
3986		Args:   nil,
3987		Field:  field,
3988	}
3989	ctx = graphql.WithResolverContext(ctx, rctx)
3990	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3991	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3992		ctx = rctx // use context from middleware stack in children
3993		return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
3994	})
3995	if resTmp == nil {
3996		if !ec.HasError(rctx) {
3997			ec.Errorf(ctx, "must not be null")
3998		}
3999		return graphql.Null
4000	}
4001	res := resTmp.(time.Time)
4002	rctx.Result = res
4003	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4004	return graphql.MarshalTime(res)
4005}
4006
4007var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
4008
4009// nolint: gocyclo, errcheck, gas, goconst
4010func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
4011	fields := graphql.CollectFields(ctx, sel, createOperationImplementors)
4012
4013	var wg sync.WaitGroup
4014	out := graphql.NewOrderedMap(len(fields))
4015	invalid := false
4016	for i, field := range fields {
4017		out.Keys[i] = field.Alias
4018
4019		switch field.Name {
4020		case "__typename":
4021			out.Values[i] = graphql.MarshalString("CreateOperation")
4022		case "hash":
4023			out.Values[i] = ec._CreateOperation_hash(ctx, field, obj)
4024			if out.Values[i] == graphql.Null {
4025				invalid = true
4026			}
4027		case "author":
4028			out.Values[i] = ec._CreateOperation_author(ctx, field, obj)
4029			if out.Values[i] == graphql.Null {
4030				invalid = true
4031			}
4032		case "date":
4033			wg.Add(1)
4034			go func(i int, field graphql.CollectedField) {
4035				out.Values[i] = ec._CreateOperation_date(ctx, field, obj)
4036				if out.Values[i] == graphql.Null {
4037					invalid = true
4038				}
4039				wg.Done()
4040			}(i, field)
4041		case "title":
4042			out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
4043			if out.Values[i] == graphql.Null {
4044				invalid = true
4045			}
4046		case "message":
4047			out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
4048			if out.Values[i] == graphql.Null {
4049				invalid = true
4050			}
4051		case "files":
4052			out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
4053			if out.Values[i] == graphql.Null {
4054				invalid = true
4055			}
4056		default:
4057			panic("unknown field " + strconv.Quote(field.Name))
4058		}
4059	}
4060	wg.Wait()
4061	if invalid {
4062		return graphql.Null
4063	}
4064	return out
4065}
4066
4067// nolint: vetshadow
4068func (ec *executionContext) _CreateOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
4069	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4070	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4071	rctx := &graphql.ResolverContext{
4072		Object: "CreateOperation",
4073		Args:   nil,
4074		Field:  field,
4075	}
4076	ctx = graphql.WithResolverContext(ctx, rctx)
4077	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4078	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4079		ctx = rctx // use context from middleware stack in children
4080		return obj.Hash()
4081	})
4082	if resTmp == nil {
4083		if !ec.HasError(rctx) {
4084			ec.Errorf(ctx, "must not be null")
4085		}
4086		return graphql.Null
4087	}
4088	res := resTmp.(git.Hash)
4089	rctx.Result = res
4090	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4091	return res
4092}
4093
4094// nolint: vetshadow
4095func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
4096	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4097	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4098	rctx := &graphql.ResolverContext{
4099		Object: "CreateOperation",
4100		Args:   nil,
4101		Field:  field,
4102	}
4103	ctx = graphql.WithResolverContext(ctx, rctx)
4104	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4105	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4106		ctx = rctx // use context from middleware stack in children
4107		return obj.Author, nil
4108	})
4109	if resTmp == nil {
4110		if !ec.HasError(rctx) {
4111			ec.Errorf(ctx, "must not be null")
4112		}
4113		return graphql.Null
4114	}
4115	res := resTmp.(identity.Interface)
4116	rctx.Result = res
4117	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4118
4119	return ec._Identity(ctx, field.Selections, &res)
4120}
4121
4122// nolint: vetshadow
4123func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
4124	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4125	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4126	rctx := &graphql.ResolverContext{
4127		Object: "CreateOperation",
4128		Args:   nil,
4129		Field:  field,
4130	}
4131	ctx = graphql.WithResolverContext(ctx, rctx)
4132	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4133	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4134		ctx = rctx // use context from middleware stack in children
4135		return ec.resolvers.CreateOperation().Date(rctx, obj)
4136	})
4137	if resTmp == nil {
4138		if !ec.HasError(rctx) {
4139			ec.Errorf(ctx, "must not be null")
4140		}
4141		return graphql.Null
4142	}
4143	res := resTmp.(time.Time)
4144	rctx.Result = res
4145	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4146	return graphql.MarshalTime(res)
4147}
4148
4149// nolint: vetshadow
4150func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
4151	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4152	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4153	rctx := &graphql.ResolverContext{
4154		Object: "CreateOperation",
4155		Args:   nil,
4156		Field:  field,
4157	}
4158	ctx = graphql.WithResolverContext(ctx, rctx)
4159	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4160	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4161		ctx = rctx // use context from middleware stack in children
4162		return obj.Title, nil
4163	})
4164	if resTmp == nil {
4165		if !ec.HasError(rctx) {
4166			ec.Errorf(ctx, "must not be null")
4167		}
4168		return graphql.Null
4169	}
4170	res := resTmp.(string)
4171	rctx.Result = res
4172	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4173	return graphql.MarshalString(res)
4174}
4175
4176// nolint: vetshadow
4177func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
4178	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4179	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4180	rctx := &graphql.ResolverContext{
4181		Object: "CreateOperation",
4182		Args:   nil,
4183		Field:  field,
4184	}
4185	ctx = graphql.WithResolverContext(ctx, rctx)
4186	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4187	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4188		ctx = rctx // use context from middleware stack in children
4189		return obj.Message, nil
4190	})
4191	if resTmp == nil {
4192		if !ec.HasError(rctx) {
4193			ec.Errorf(ctx, "must not be null")
4194		}
4195		return graphql.Null
4196	}
4197	res := resTmp.(string)
4198	rctx.Result = res
4199	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4200	return graphql.MarshalString(res)
4201}
4202
4203// nolint: vetshadow
4204func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
4205	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4206	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4207	rctx := &graphql.ResolverContext{
4208		Object: "CreateOperation",
4209		Args:   nil,
4210		Field:  field,
4211	}
4212	ctx = graphql.WithResolverContext(ctx, rctx)
4213	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4214	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4215		ctx = rctx // use context from middleware stack in children
4216		return obj.Files, nil
4217	})
4218	if resTmp == nil {
4219		if !ec.HasError(rctx) {
4220			ec.Errorf(ctx, "must not be null")
4221		}
4222		return graphql.Null
4223	}
4224	res := resTmp.([]git.Hash)
4225	rctx.Result = res
4226	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4227
4228	arr1 := make(graphql.Array, len(res))
4229
4230	for idx1 := range res {
4231		arr1[idx1] = func() graphql.Marshaler {
4232			return res[idx1]
4233		}()
4234	}
4235
4236	return arr1
4237}
4238
4239var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem"}
4240
4241// nolint: gocyclo, errcheck, gas, goconst
4242func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
4243	fields := graphql.CollectFields(ctx, sel, createTimelineItemImplementors)
4244
4245	var wg sync.WaitGroup
4246	out := graphql.NewOrderedMap(len(fields))
4247	invalid := false
4248	for i, field := range fields {
4249		out.Keys[i] = field.Alias
4250
4251		switch field.Name {
4252		case "__typename":
4253			out.Values[i] = graphql.MarshalString("CreateTimelineItem")
4254		case "hash":
4255			out.Values[i] = ec._CreateTimelineItem_hash(ctx, field, obj)
4256			if out.Values[i] == graphql.Null {
4257				invalid = true
4258			}
4259		case "author":
4260			out.Values[i] = ec._CreateTimelineItem_author(ctx, field, obj)
4261			if out.Values[i] == graphql.Null {
4262				invalid = true
4263			}
4264		case "message":
4265			out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
4266			if out.Values[i] == graphql.Null {
4267				invalid = true
4268			}
4269		case "messageIsEmpty":
4270			out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
4271			if out.Values[i] == graphql.Null {
4272				invalid = true
4273			}
4274		case "files":
4275			out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
4276			if out.Values[i] == graphql.Null {
4277				invalid = true
4278			}
4279		case "createdAt":
4280			wg.Add(1)
4281			go func(i int, field graphql.CollectedField) {
4282				out.Values[i] = ec._CreateTimelineItem_createdAt(ctx, field, obj)
4283				if out.Values[i] == graphql.Null {
4284					invalid = true
4285				}
4286				wg.Done()
4287			}(i, field)
4288		case "lastEdit":
4289			wg.Add(1)
4290			go func(i int, field graphql.CollectedField) {
4291				out.Values[i] = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
4292				if out.Values[i] == graphql.Null {
4293					invalid = true
4294				}
4295				wg.Done()
4296			}(i, field)
4297		case "edited":
4298			out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
4299			if out.Values[i] == graphql.Null {
4300				invalid = true
4301			}
4302		case "history":
4303			out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
4304			if out.Values[i] == graphql.Null {
4305				invalid = true
4306			}
4307		default:
4308			panic("unknown field " + strconv.Quote(field.Name))
4309		}
4310	}
4311	wg.Wait()
4312	if invalid {
4313		return graphql.Null
4314	}
4315	return out
4316}
4317
4318// nolint: vetshadow
4319func (ec *executionContext) _CreateTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4320	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4321	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4322	rctx := &graphql.ResolverContext{
4323		Object: "CreateTimelineItem",
4324		Args:   nil,
4325		Field:  field,
4326	}
4327	ctx = graphql.WithResolverContext(ctx, rctx)
4328	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4329	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4330		ctx = rctx // use context from middleware stack in children
4331		return obj.Hash(), nil
4332	})
4333	if resTmp == nil {
4334		if !ec.HasError(rctx) {
4335			ec.Errorf(ctx, "must not be null")
4336		}
4337		return graphql.Null
4338	}
4339	res := resTmp.(git.Hash)
4340	rctx.Result = res
4341	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4342	return res
4343}
4344
4345// nolint: vetshadow
4346func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4347	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4348	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4349	rctx := &graphql.ResolverContext{
4350		Object: "CreateTimelineItem",
4351		Args:   nil,
4352		Field:  field,
4353	}
4354	ctx = graphql.WithResolverContext(ctx, rctx)
4355	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4356	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4357		ctx = rctx // use context from middleware stack in children
4358		return obj.Author, nil
4359	})
4360	if resTmp == nil {
4361		if !ec.HasError(rctx) {
4362			ec.Errorf(ctx, "must not be null")
4363		}
4364		return graphql.Null
4365	}
4366	res := resTmp.(identity.Interface)
4367	rctx.Result = res
4368	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4369
4370	return ec._Identity(ctx, field.Selections, &res)
4371}
4372
4373// nolint: vetshadow
4374func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4375	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4376	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4377	rctx := &graphql.ResolverContext{
4378		Object: "CreateTimelineItem",
4379		Args:   nil,
4380		Field:  field,
4381	}
4382	ctx = graphql.WithResolverContext(ctx, rctx)
4383	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4384	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4385		ctx = rctx // use context from middleware stack in children
4386		return obj.Message, nil
4387	})
4388	if resTmp == nil {
4389		if !ec.HasError(rctx) {
4390			ec.Errorf(ctx, "must not be null")
4391		}
4392		return graphql.Null
4393	}
4394	res := resTmp.(string)
4395	rctx.Result = res
4396	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4397	return graphql.MarshalString(res)
4398}
4399
4400// nolint: vetshadow
4401func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4402	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4403	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4404	rctx := &graphql.ResolverContext{
4405		Object: "CreateTimelineItem",
4406		Args:   nil,
4407		Field:  field,
4408	}
4409	ctx = graphql.WithResolverContext(ctx, rctx)
4410	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4411	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4412		ctx = rctx // use context from middleware stack in children
4413		return obj.MessageIsEmpty(), nil
4414	})
4415	if resTmp == nil {
4416		if !ec.HasError(rctx) {
4417			ec.Errorf(ctx, "must not be null")
4418		}
4419		return graphql.Null
4420	}
4421	res := resTmp.(bool)
4422	rctx.Result = res
4423	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4424	return graphql.MarshalBoolean(res)
4425}
4426
4427// nolint: vetshadow
4428func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4429	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4430	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4431	rctx := &graphql.ResolverContext{
4432		Object: "CreateTimelineItem",
4433		Args:   nil,
4434		Field:  field,
4435	}
4436	ctx = graphql.WithResolverContext(ctx, rctx)
4437	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4438	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4439		ctx = rctx // use context from middleware stack in children
4440		return obj.Files, nil
4441	})
4442	if resTmp == nil {
4443		if !ec.HasError(rctx) {
4444			ec.Errorf(ctx, "must not be null")
4445		}
4446		return graphql.Null
4447	}
4448	res := resTmp.([]git.Hash)
4449	rctx.Result = res
4450	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4451
4452	arr1 := make(graphql.Array, len(res))
4453
4454	for idx1 := range res {
4455		arr1[idx1] = func() graphql.Marshaler {
4456			return res[idx1]
4457		}()
4458	}
4459
4460	return arr1
4461}
4462
4463// nolint: vetshadow
4464func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4465	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4466	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4467	rctx := &graphql.ResolverContext{
4468		Object: "CreateTimelineItem",
4469		Args:   nil,
4470		Field:  field,
4471	}
4472	ctx = graphql.WithResolverContext(ctx, rctx)
4473	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4474	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4475		ctx = rctx // use context from middleware stack in children
4476		return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
4477	})
4478	if resTmp == nil {
4479		if !ec.HasError(rctx) {
4480			ec.Errorf(ctx, "must not be null")
4481		}
4482		return graphql.Null
4483	}
4484	res := resTmp.(time.Time)
4485	rctx.Result = res
4486	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4487	return graphql.MarshalTime(res)
4488}
4489
4490// nolint: vetshadow
4491func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4492	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4493	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4494	rctx := &graphql.ResolverContext{
4495		Object: "CreateTimelineItem",
4496		Args:   nil,
4497		Field:  field,
4498	}
4499	ctx = graphql.WithResolverContext(ctx, rctx)
4500	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4501	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4502		ctx = rctx // use context from middleware stack in children
4503		return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
4504	})
4505	if resTmp == nil {
4506		if !ec.HasError(rctx) {
4507			ec.Errorf(ctx, "must not be null")
4508		}
4509		return graphql.Null
4510	}
4511	res := resTmp.(time.Time)
4512	rctx.Result = res
4513	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4514	return graphql.MarshalTime(res)
4515}
4516
4517// nolint: vetshadow
4518func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4519	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4520	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4521	rctx := &graphql.ResolverContext{
4522		Object: "CreateTimelineItem",
4523		Args:   nil,
4524		Field:  field,
4525	}
4526	ctx = graphql.WithResolverContext(ctx, rctx)
4527	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4528	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4529		ctx = rctx // use context from middleware stack in children
4530		return obj.Edited(), nil
4531	})
4532	if resTmp == nil {
4533		if !ec.HasError(rctx) {
4534			ec.Errorf(ctx, "must not be null")
4535		}
4536		return graphql.Null
4537	}
4538	res := resTmp.(bool)
4539	rctx.Result = res
4540	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4541	return graphql.MarshalBoolean(res)
4542}
4543
4544// nolint: vetshadow
4545func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4546	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4547	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4548	rctx := &graphql.ResolverContext{
4549		Object: "CreateTimelineItem",
4550		Args:   nil,
4551		Field:  field,
4552	}
4553	ctx = graphql.WithResolverContext(ctx, rctx)
4554	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4555	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4556		ctx = rctx // use context from middleware stack in children
4557		return obj.History, nil
4558	})
4559	if resTmp == nil {
4560		if !ec.HasError(rctx) {
4561			ec.Errorf(ctx, "must not be null")
4562		}
4563		return graphql.Null
4564	}
4565	res := resTmp.([]bug.CommentHistoryStep)
4566	rctx.Result = res
4567	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4568
4569	arr1 := make(graphql.Array, len(res))
4570	var wg sync.WaitGroup
4571
4572	isLen1 := len(res) == 1
4573	if !isLen1 {
4574		wg.Add(len(res))
4575	}
4576
4577	for idx1 := range res {
4578		idx1 := idx1
4579		rctx := &graphql.ResolverContext{
4580			Index:  &idx1,
4581			Result: &res[idx1],
4582		}
4583		ctx := graphql.WithResolverContext(ctx, rctx)
4584		f := func(idx1 int) {
4585			if !isLen1 {
4586				defer wg.Done()
4587			}
4588			arr1[idx1] = func() graphql.Marshaler {
4589
4590				return ec._CommentHistoryStep(ctx, field.Selections, &res[idx1])
4591			}()
4592		}
4593		if isLen1 {
4594			f(idx1)
4595		} else {
4596			go f(idx1)
4597		}
4598
4599	}
4600	wg.Wait()
4601	return arr1
4602}
4603
4604var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
4605
4606// nolint: gocyclo, errcheck, gas, goconst
4607func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
4608	fields := graphql.CollectFields(ctx, sel, editCommentOperationImplementors)
4609
4610	var wg sync.WaitGroup
4611	out := graphql.NewOrderedMap(len(fields))
4612	invalid := false
4613	for i, field := range fields {
4614		out.Keys[i] = field.Alias
4615
4616		switch field.Name {
4617		case "__typename":
4618			out.Values[i] = graphql.MarshalString("EditCommentOperation")
4619		case "hash":
4620			out.Values[i] = ec._EditCommentOperation_hash(ctx, field, obj)
4621			if out.Values[i] == graphql.Null {
4622				invalid = true
4623			}
4624		case "author":
4625			out.Values[i] = ec._EditCommentOperation_author(ctx, field, obj)
4626			if out.Values[i] == graphql.Null {
4627				invalid = true
4628			}
4629		case "date":
4630			wg.Add(1)
4631			go func(i int, field graphql.CollectedField) {
4632				out.Values[i] = ec._EditCommentOperation_date(ctx, field, obj)
4633				if out.Values[i] == graphql.Null {
4634					invalid = true
4635				}
4636				wg.Done()
4637			}(i, field)
4638		case "target":
4639			out.Values[i] = ec._EditCommentOperation_target(ctx, field, obj)
4640			if out.Values[i] == graphql.Null {
4641				invalid = true
4642			}
4643		case "message":
4644			out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
4645			if out.Values[i] == graphql.Null {
4646				invalid = true
4647			}
4648		case "files":
4649			out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
4650			if out.Values[i] == graphql.Null {
4651				invalid = true
4652			}
4653		default:
4654			panic("unknown field " + strconv.Quote(field.Name))
4655		}
4656	}
4657	wg.Wait()
4658	if invalid {
4659		return graphql.Null
4660	}
4661	return out
4662}
4663
4664// nolint: vetshadow
4665func (ec *executionContext) _EditCommentOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4666	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4667	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4668	rctx := &graphql.ResolverContext{
4669		Object: "EditCommentOperation",
4670		Args:   nil,
4671		Field:  field,
4672	}
4673	ctx = graphql.WithResolverContext(ctx, rctx)
4674	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4675	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4676		ctx = rctx // use context from middleware stack in children
4677		return obj.Hash()
4678	})
4679	if resTmp == nil {
4680		if !ec.HasError(rctx) {
4681			ec.Errorf(ctx, "must not be null")
4682		}
4683		return graphql.Null
4684	}
4685	res := resTmp.(git.Hash)
4686	rctx.Result = res
4687	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4688	return res
4689}
4690
4691// nolint: vetshadow
4692func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4693	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4694	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4695	rctx := &graphql.ResolverContext{
4696		Object: "EditCommentOperation",
4697		Args:   nil,
4698		Field:  field,
4699	}
4700	ctx = graphql.WithResolverContext(ctx, rctx)
4701	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4702	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4703		ctx = rctx // use context from middleware stack in children
4704		return obj.Author, nil
4705	})
4706	if resTmp == nil {
4707		if !ec.HasError(rctx) {
4708			ec.Errorf(ctx, "must not be null")
4709		}
4710		return graphql.Null
4711	}
4712	res := resTmp.(identity.Interface)
4713	rctx.Result = res
4714	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4715
4716	return ec._Identity(ctx, field.Selections, &res)
4717}
4718
4719// nolint: vetshadow
4720func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4721	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4722	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4723	rctx := &graphql.ResolverContext{
4724		Object: "EditCommentOperation",
4725		Args:   nil,
4726		Field:  field,
4727	}
4728	ctx = graphql.WithResolverContext(ctx, rctx)
4729	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4730	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4731		ctx = rctx // use context from middleware stack in children
4732		return ec.resolvers.EditCommentOperation().Date(rctx, obj)
4733	})
4734	if resTmp == nil {
4735		if !ec.HasError(rctx) {
4736			ec.Errorf(ctx, "must not be null")
4737		}
4738		return graphql.Null
4739	}
4740	res := resTmp.(time.Time)
4741	rctx.Result = res
4742	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4743	return graphql.MarshalTime(res)
4744}
4745
4746// nolint: vetshadow
4747func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4748	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4749	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4750	rctx := &graphql.ResolverContext{
4751		Object: "EditCommentOperation",
4752		Args:   nil,
4753		Field:  field,
4754	}
4755	ctx = graphql.WithResolverContext(ctx, rctx)
4756	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4757	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4758		ctx = rctx // use context from middleware stack in children
4759		return obj.Target, nil
4760	})
4761	if resTmp == nil {
4762		if !ec.HasError(rctx) {
4763			ec.Errorf(ctx, "must not be null")
4764		}
4765		return graphql.Null
4766	}
4767	res := resTmp.(git.Hash)
4768	rctx.Result = res
4769	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4770	return res
4771}
4772
4773// nolint: vetshadow
4774func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4775	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4776	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4777	rctx := &graphql.ResolverContext{
4778		Object: "EditCommentOperation",
4779		Args:   nil,
4780		Field:  field,
4781	}
4782	ctx = graphql.WithResolverContext(ctx, rctx)
4783	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4784	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4785		ctx = rctx // use context from middleware stack in children
4786		return obj.Message, nil
4787	})
4788	if resTmp == nil {
4789		if !ec.HasError(rctx) {
4790			ec.Errorf(ctx, "must not be null")
4791		}
4792		return graphql.Null
4793	}
4794	res := resTmp.(string)
4795	rctx.Result = res
4796	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4797	return graphql.MarshalString(res)
4798}
4799
4800// nolint: vetshadow
4801func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4802	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4803	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4804	rctx := &graphql.ResolverContext{
4805		Object: "EditCommentOperation",
4806		Args:   nil,
4807		Field:  field,
4808	}
4809	ctx = graphql.WithResolverContext(ctx, rctx)
4810	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4811	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4812		ctx = rctx // use context from middleware stack in children
4813		return obj.Files, nil
4814	})
4815	if resTmp == nil {
4816		if !ec.HasError(rctx) {
4817			ec.Errorf(ctx, "must not be null")
4818		}
4819		return graphql.Null
4820	}
4821	res := resTmp.([]git.Hash)
4822	rctx.Result = res
4823	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4824
4825	arr1 := make(graphql.Array, len(res))
4826
4827	for idx1 := range res {
4828		arr1[idx1] = func() graphql.Marshaler {
4829			return res[idx1]
4830		}()
4831	}
4832
4833	return arr1
4834}
4835
4836var identityImplementors = []string{"Identity"}
4837
4838// nolint: gocyclo, errcheck, gas, goconst
4839func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj *identity.Interface) graphql.Marshaler {
4840	fields := graphql.CollectFields(ctx, sel, identityImplementors)
4841
4842	var wg sync.WaitGroup
4843	out := graphql.NewOrderedMap(len(fields))
4844	invalid := false
4845	for i, field := range fields {
4846		out.Keys[i] = field.Alias
4847
4848		switch field.Name {
4849		case "__typename":
4850			out.Values[i] = graphql.MarshalString("Identity")
4851		case "id":
4852			wg.Add(1)
4853			go func(i int, field graphql.CollectedField) {
4854				out.Values[i] = ec._Identity_id(ctx, field, obj)
4855				if out.Values[i] == graphql.Null {
4856					invalid = true
4857				}
4858				wg.Done()
4859			}(i, field)
4860		case "humanId":
4861			wg.Add(1)
4862			go func(i int, field graphql.CollectedField) {
4863				out.Values[i] = ec._Identity_humanId(ctx, field, obj)
4864				if out.Values[i] == graphql.Null {
4865					invalid = true
4866				}
4867				wg.Done()
4868			}(i, field)
4869		case "name":
4870			wg.Add(1)
4871			go func(i int, field graphql.CollectedField) {
4872				out.Values[i] = ec._Identity_name(ctx, field, obj)
4873				wg.Done()
4874			}(i, field)
4875		case "email":
4876			wg.Add(1)
4877			go func(i int, field graphql.CollectedField) {
4878				out.Values[i] = ec._Identity_email(ctx, field, obj)
4879				wg.Done()
4880			}(i, field)
4881		case "login":
4882			wg.Add(1)
4883			go func(i int, field graphql.CollectedField) {
4884				out.Values[i] = ec._Identity_login(ctx, field, obj)
4885				wg.Done()
4886			}(i, field)
4887		case "displayName":
4888			wg.Add(1)
4889			go func(i int, field graphql.CollectedField) {
4890				out.Values[i] = ec._Identity_displayName(ctx, field, obj)
4891				if out.Values[i] == graphql.Null {
4892					invalid = true
4893				}
4894				wg.Done()
4895			}(i, field)
4896		case "avatarUrl":
4897			wg.Add(1)
4898			go func(i int, field graphql.CollectedField) {
4899				out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
4900				wg.Done()
4901			}(i, field)
4902		case "isProtected":
4903			wg.Add(1)
4904			go func(i int, field graphql.CollectedField) {
4905				out.Values[i] = ec._Identity_isProtected(ctx, field, obj)
4906				if out.Values[i] == graphql.Null {
4907					invalid = true
4908				}
4909				wg.Done()
4910			}(i, field)
4911		default:
4912			panic("unknown field " + strconv.Quote(field.Name))
4913		}
4914	}
4915	wg.Wait()
4916	if invalid {
4917		return graphql.Null
4918	}
4919	return out
4920}
4921
4922// nolint: vetshadow
4923func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
4924	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4925	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4926	rctx := &graphql.ResolverContext{
4927		Object: "Identity",
4928		Args:   nil,
4929		Field:  field,
4930	}
4931	ctx = graphql.WithResolverContext(ctx, rctx)
4932	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4933	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4934		ctx = rctx // use context from middleware stack in children
4935		return ec.resolvers.Identity().ID(rctx, obj)
4936	})
4937	if resTmp == nil {
4938		if !ec.HasError(rctx) {
4939			ec.Errorf(ctx, "must not be null")
4940		}
4941		return graphql.Null
4942	}
4943	res := resTmp.(string)
4944	rctx.Result = res
4945	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4946	return graphql.MarshalString(res)
4947}
4948
4949// nolint: vetshadow
4950func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
4951	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4952	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4953	rctx := &graphql.ResolverContext{
4954		Object: "Identity",
4955		Args:   nil,
4956		Field:  field,
4957	}
4958	ctx = graphql.WithResolverContext(ctx, rctx)
4959	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4960	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4961		ctx = rctx // use context from middleware stack in children
4962		return ec.resolvers.Identity().HumanID(rctx, obj)
4963	})
4964	if resTmp == nil {
4965		if !ec.HasError(rctx) {
4966			ec.Errorf(ctx, "must not be null")
4967		}
4968		return graphql.Null
4969	}
4970	res := resTmp.(string)
4971	rctx.Result = res
4972	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4973	return graphql.MarshalString(res)
4974}
4975
4976// nolint: vetshadow
4977func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
4978	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4979	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4980	rctx := &graphql.ResolverContext{
4981		Object: "Identity",
4982		Args:   nil,
4983		Field:  field,
4984	}
4985	ctx = graphql.WithResolverContext(ctx, rctx)
4986	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4987	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4988		ctx = rctx // use context from middleware stack in children
4989		return ec.resolvers.Identity().Name(rctx, obj)
4990	})
4991	if resTmp == nil {
4992		return graphql.Null
4993	}
4994	res := resTmp.(*string)
4995	rctx.Result = res
4996	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4997
4998	if res == nil {
4999		return graphql.Null
5000	}
5001	return graphql.MarshalString(*res)
5002}
5003
5004// nolint: vetshadow
5005func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
5006	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5007	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5008	rctx := &graphql.ResolverContext{
5009		Object: "Identity",
5010		Args:   nil,
5011		Field:  field,
5012	}
5013	ctx = graphql.WithResolverContext(ctx, rctx)
5014	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5015	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5016		ctx = rctx // use context from middleware stack in children
5017		return ec.resolvers.Identity().Email(rctx, obj)
5018	})
5019	if resTmp == nil {
5020		return graphql.Null
5021	}
5022	res := resTmp.(*string)
5023	rctx.Result = res
5024	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5025
5026	if res == nil {
5027		return graphql.Null
5028	}
5029	return graphql.MarshalString(*res)
5030}
5031
5032// nolint: vetshadow
5033func (ec *executionContext) _Identity_login(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
5034	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5035	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5036	rctx := &graphql.ResolverContext{
5037		Object: "Identity",
5038		Args:   nil,
5039		Field:  field,
5040	}
5041	ctx = graphql.WithResolverContext(ctx, rctx)
5042	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5043	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5044		ctx = rctx // use context from middleware stack in children
5045		return ec.resolvers.Identity().Login(rctx, obj)
5046	})
5047	if resTmp == nil {
5048		return graphql.Null
5049	}
5050	res := resTmp.(*string)
5051	rctx.Result = res
5052	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5053
5054	if res == nil {
5055		return graphql.Null
5056	}
5057	return graphql.MarshalString(*res)
5058}
5059
5060// nolint: vetshadow
5061func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
5062	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5063	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5064	rctx := &graphql.ResolverContext{
5065		Object: "Identity",
5066		Args:   nil,
5067		Field:  field,
5068	}
5069	ctx = graphql.WithResolverContext(ctx, rctx)
5070	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5071	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5072		ctx = rctx // use context from middleware stack in children
5073		return ec.resolvers.Identity().DisplayName(rctx, obj)
5074	})
5075	if resTmp == nil {
5076		if !ec.HasError(rctx) {
5077			ec.Errorf(ctx, "must not be null")
5078		}
5079		return graphql.Null
5080	}
5081	res := resTmp.(string)
5082	rctx.Result = res
5083	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5084	return graphql.MarshalString(res)
5085}
5086
5087// nolint: vetshadow
5088func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
5089	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5090	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5091	rctx := &graphql.ResolverContext{
5092		Object: "Identity",
5093		Args:   nil,
5094		Field:  field,
5095	}
5096	ctx = graphql.WithResolverContext(ctx, rctx)
5097	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5098	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5099		ctx = rctx // use context from middleware stack in children
5100		return ec.resolvers.Identity().AvatarURL(rctx, obj)
5101	})
5102	if resTmp == nil {
5103		return graphql.Null
5104	}
5105	res := resTmp.(*string)
5106	rctx.Result = res
5107	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5108
5109	if res == nil {
5110		return graphql.Null
5111	}
5112	return graphql.MarshalString(*res)
5113}
5114
5115// nolint: vetshadow
5116func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
5117	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5118	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5119	rctx := &graphql.ResolverContext{
5120		Object: "Identity",
5121		Args:   nil,
5122		Field:  field,
5123	}
5124	ctx = graphql.WithResolverContext(ctx, rctx)
5125	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5126	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5127		ctx = rctx // use context from middleware stack in children
5128		return ec.resolvers.Identity().IsProtected(rctx, obj)
5129	})
5130	if resTmp == nil {
5131		if !ec.HasError(rctx) {
5132			ec.Errorf(ctx, "must not be null")
5133		}
5134		return graphql.Null
5135	}
5136	res := resTmp.(bool)
5137	rctx.Result = res
5138	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5139	return graphql.MarshalBoolean(res)
5140}
5141
5142var identityConnectionImplementors = []string{"IdentityConnection"}
5143
5144// nolint: gocyclo, errcheck, gas, goconst
5145func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
5146	fields := graphql.CollectFields(ctx, sel, identityConnectionImplementors)
5147
5148	out := graphql.NewOrderedMap(len(fields))
5149	invalid := false
5150	for i, field := range fields {
5151		out.Keys[i] = field.Alias
5152
5153		switch field.Name {
5154		case "__typename":
5155			out.Values[i] = graphql.MarshalString("IdentityConnection")
5156		case "edges":
5157			out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
5158			if out.Values[i] == graphql.Null {
5159				invalid = true
5160			}
5161		case "nodes":
5162			out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
5163			if out.Values[i] == graphql.Null {
5164				invalid = true
5165			}
5166		case "pageInfo":
5167			out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
5168			if out.Values[i] == graphql.Null {
5169				invalid = true
5170			}
5171		case "totalCount":
5172			out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
5173			if out.Values[i] == graphql.Null {
5174				invalid = true
5175			}
5176		default:
5177			panic("unknown field " + strconv.Quote(field.Name))
5178		}
5179	}
5180
5181	if invalid {
5182		return graphql.Null
5183	}
5184	return out
5185}
5186
5187// nolint: vetshadow
5188func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) graphql.Marshaler {
5189	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5190	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5191	rctx := &graphql.ResolverContext{
5192		Object: "IdentityConnection",
5193		Args:   nil,
5194		Field:  field,
5195	}
5196	ctx = graphql.WithResolverContext(ctx, rctx)
5197	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5198	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5199		ctx = rctx // use context from middleware stack in children
5200		return obj.Edges, nil
5201	})
5202	if resTmp == nil {
5203		if !ec.HasError(rctx) {
5204			ec.Errorf(ctx, "must not be null")
5205		}
5206		return graphql.Null
5207	}
5208	res := resTmp.([]models.IdentityEdge)
5209	rctx.Result = res
5210	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5211
5212	arr1 := make(graphql.Array, len(res))
5213	var wg sync.WaitGroup
5214
5215	isLen1 := len(res) == 1
5216	if !isLen1 {
5217		wg.Add(len(res))
5218	}
5219
5220	for idx1 := range res {
5221		idx1 := idx1
5222		rctx := &graphql.ResolverContext{
5223			Index:  &idx1,
5224			Result: &res[idx1],
5225		}
5226		ctx := graphql.WithResolverContext(ctx, rctx)
5227		f := func(idx1 int) {
5228			if !isLen1 {
5229				defer wg.Done()
5230			}
5231			arr1[idx1] = func() graphql.Marshaler {
5232
5233				return ec._IdentityEdge(ctx, field.Selections, &res[idx1])
5234			}()
5235		}
5236		if isLen1 {
5237			f(idx1)
5238		} else {
5239			go f(idx1)
5240		}
5241
5242	}
5243	wg.Wait()
5244	return arr1
5245}
5246
5247// nolint: vetshadow
5248func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) graphql.Marshaler {
5249	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5250	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5251	rctx := &graphql.ResolverContext{
5252		Object: "IdentityConnection",
5253		Args:   nil,
5254		Field:  field,
5255	}
5256	ctx = graphql.WithResolverContext(ctx, rctx)
5257	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5258	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5259		ctx = rctx // use context from middleware stack in children
5260		return obj.Nodes, nil
5261	})
5262	if resTmp == nil {
5263		if !ec.HasError(rctx) {
5264			ec.Errorf(ctx, "must not be null")
5265		}
5266		return graphql.Null
5267	}
5268	res := resTmp.([]identity.Interface)
5269	rctx.Result = res
5270	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5271
5272	arr1 := make(graphql.Array, len(res))
5273	var wg sync.WaitGroup
5274
5275	isLen1 := len(res) == 1
5276	if !isLen1 {
5277		wg.Add(len(res))
5278	}
5279
5280	for idx1 := range res {
5281		idx1 := idx1
5282		rctx := &graphql.ResolverContext{
5283			Index:  &idx1,
5284			Result: &res[idx1],
5285		}
5286		ctx := graphql.WithResolverContext(ctx, rctx)
5287		f := func(idx1 int) {
5288			if !isLen1 {
5289				defer wg.Done()
5290			}
5291			arr1[idx1] = func() graphql.Marshaler {
5292
5293				return ec._Identity(ctx, field.Selections, &res[idx1])
5294			}()
5295		}
5296		if isLen1 {
5297			f(idx1)
5298		} else {
5299			go f(idx1)
5300		}
5301
5302	}
5303	wg.Wait()
5304	return arr1
5305}
5306
5307// nolint: vetshadow
5308func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) graphql.Marshaler {
5309	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5310	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5311	rctx := &graphql.ResolverContext{
5312		Object: "IdentityConnection",
5313		Args:   nil,
5314		Field:  field,
5315	}
5316	ctx = graphql.WithResolverContext(ctx, rctx)
5317	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5318	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5319		ctx = rctx // use context from middleware stack in children
5320		return obj.PageInfo, nil
5321	})
5322	if resTmp == nil {
5323		if !ec.HasError(rctx) {
5324			ec.Errorf(ctx, "must not be null")
5325		}
5326		return graphql.Null
5327	}
5328	res := resTmp.(models.PageInfo)
5329	rctx.Result = res
5330	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5331
5332	return ec._PageInfo(ctx, field.Selections, &res)
5333}
5334
5335// nolint: vetshadow
5336func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) graphql.Marshaler {
5337	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5338	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5339	rctx := &graphql.ResolverContext{
5340		Object: "IdentityConnection",
5341		Args:   nil,
5342		Field:  field,
5343	}
5344	ctx = graphql.WithResolverContext(ctx, rctx)
5345	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5346	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5347		ctx = rctx // use context from middleware stack in children
5348		return obj.TotalCount, nil
5349	})
5350	if resTmp == nil {
5351		if !ec.HasError(rctx) {
5352			ec.Errorf(ctx, "must not be null")
5353		}
5354		return graphql.Null
5355	}
5356	res := resTmp.(int)
5357	rctx.Result = res
5358	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5359	return graphql.MarshalInt(res)
5360}
5361
5362var identityEdgeImplementors = []string{"IdentityEdge"}
5363
5364// nolint: gocyclo, errcheck, gas, goconst
5365func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
5366	fields := graphql.CollectFields(ctx, sel, identityEdgeImplementors)
5367
5368	out := graphql.NewOrderedMap(len(fields))
5369	invalid := false
5370	for i, field := range fields {
5371		out.Keys[i] = field.Alias
5372
5373		switch field.Name {
5374		case "__typename":
5375			out.Values[i] = graphql.MarshalString("IdentityEdge")
5376		case "cursor":
5377			out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
5378			if out.Values[i] == graphql.Null {
5379				invalid = true
5380			}
5381		case "node":
5382			out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
5383			if out.Values[i] == graphql.Null {
5384				invalid = true
5385			}
5386		default:
5387			panic("unknown field " + strconv.Quote(field.Name))
5388		}
5389	}
5390
5391	if invalid {
5392		return graphql.Null
5393	}
5394	return out
5395}
5396
5397// nolint: vetshadow
5398func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) graphql.Marshaler {
5399	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5400	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5401	rctx := &graphql.ResolverContext{
5402		Object: "IdentityEdge",
5403		Args:   nil,
5404		Field:  field,
5405	}
5406	ctx = graphql.WithResolverContext(ctx, rctx)
5407	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5408	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5409		ctx = rctx // use context from middleware stack in children
5410		return obj.Cursor, nil
5411	})
5412	if resTmp == nil {
5413		if !ec.HasError(rctx) {
5414			ec.Errorf(ctx, "must not be null")
5415		}
5416		return graphql.Null
5417	}
5418	res := resTmp.(string)
5419	rctx.Result = res
5420	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5421	return graphql.MarshalString(res)
5422}
5423
5424// nolint: vetshadow
5425func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) graphql.Marshaler {
5426	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5427	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5428	rctx := &graphql.ResolverContext{
5429		Object: "IdentityEdge",
5430		Args:   nil,
5431		Field:  field,
5432	}
5433	ctx = graphql.WithResolverContext(ctx, rctx)
5434	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5435	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5436		ctx = rctx // use context from middleware stack in children
5437		return obj.Node, nil
5438	})
5439	if resTmp == nil {
5440		if !ec.HasError(rctx) {
5441			ec.Errorf(ctx, "must not be null")
5442		}
5443		return graphql.Null
5444	}
5445	res := resTmp.(identity.Interface)
5446	rctx.Result = res
5447	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5448
5449	return ec._Identity(ctx, field.Selections, &res)
5450}
5451
5452var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
5453
5454// nolint: gocyclo, errcheck, gas, goconst
5455func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
5456	fields := graphql.CollectFields(ctx, sel, labelChangeOperationImplementors)
5457
5458	var wg sync.WaitGroup
5459	out := graphql.NewOrderedMap(len(fields))
5460	invalid := false
5461	for i, field := range fields {
5462		out.Keys[i] = field.Alias
5463
5464		switch field.Name {
5465		case "__typename":
5466			out.Values[i] = graphql.MarshalString("LabelChangeOperation")
5467		case "hash":
5468			out.Values[i] = ec._LabelChangeOperation_hash(ctx, field, obj)
5469			if out.Values[i] == graphql.Null {
5470				invalid = true
5471			}
5472		case "author":
5473			out.Values[i] = ec._LabelChangeOperation_author(ctx, field, obj)
5474			if out.Values[i] == graphql.Null {
5475				invalid = true
5476			}
5477		case "date":
5478			wg.Add(1)
5479			go func(i int, field graphql.CollectedField) {
5480				out.Values[i] = ec._LabelChangeOperation_date(ctx, field, obj)
5481				if out.Values[i] == graphql.Null {
5482					invalid = true
5483				}
5484				wg.Done()
5485			}(i, field)
5486		case "added":
5487			out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
5488			if out.Values[i] == graphql.Null {
5489				invalid = true
5490			}
5491		case "removed":
5492			out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
5493			if out.Values[i] == graphql.Null {
5494				invalid = true
5495			}
5496		default:
5497			panic("unknown field " + strconv.Quote(field.Name))
5498		}
5499	}
5500	wg.Wait()
5501	if invalid {
5502		return graphql.Null
5503	}
5504	return out
5505}
5506
5507// nolint: vetshadow
5508func (ec *executionContext) _LabelChangeOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
5509	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5510	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5511	rctx := &graphql.ResolverContext{
5512		Object: "LabelChangeOperation",
5513		Args:   nil,
5514		Field:  field,
5515	}
5516	ctx = graphql.WithResolverContext(ctx, rctx)
5517	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5518	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5519		ctx = rctx // use context from middleware stack in children
5520		return obj.Hash()
5521	})
5522	if resTmp == nil {
5523		if !ec.HasError(rctx) {
5524			ec.Errorf(ctx, "must not be null")
5525		}
5526		return graphql.Null
5527	}
5528	res := resTmp.(git.Hash)
5529	rctx.Result = res
5530	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5531	return res
5532}
5533
5534// nolint: vetshadow
5535func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
5536	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5537	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5538	rctx := &graphql.ResolverContext{
5539		Object: "LabelChangeOperation",
5540		Args:   nil,
5541		Field:  field,
5542	}
5543	ctx = graphql.WithResolverContext(ctx, rctx)
5544	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5545	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5546		ctx = rctx // use context from middleware stack in children
5547		return obj.Author, nil
5548	})
5549	if resTmp == nil {
5550		if !ec.HasError(rctx) {
5551			ec.Errorf(ctx, "must not be null")
5552		}
5553		return graphql.Null
5554	}
5555	res := resTmp.(identity.Interface)
5556	rctx.Result = res
5557	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5558
5559	return ec._Identity(ctx, field.Selections, &res)
5560}
5561
5562// nolint: vetshadow
5563func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
5564	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5565	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5566	rctx := &graphql.ResolverContext{
5567		Object: "LabelChangeOperation",
5568		Args:   nil,
5569		Field:  field,
5570	}
5571	ctx = graphql.WithResolverContext(ctx, rctx)
5572	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5573	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5574		ctx = rctx // use context from middleware stack in children
5575		return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
5576	})
5577	if resTmp == nil {
5578		if !ec.HasError(rctx) {
5579			ec.Errorf(ctx, "must not be null")
5580		}
5581		return graphql.Null
5582	}
5583	res := resTmp.(time.Time)
5584	rctx.Result = res
5585	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5586	return graphql.MarshalTime(res)
5587}
5588
5589// nolint: vetshadow
5590func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
5591	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5592	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5593	rctx := &graphql.ResolverContext{
5594		Object: "LabelChangeOperation",
5595		Args:   nil,
5596		Field:  field,
5597	}
5598	ctx = graphql.WithResolverContext(ctx, rctx)
5599	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5600	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5601		ctx = rctx // use context from middleware stack in children
5602		return obj.Added, nil
5603	})
5604	if resTmp == nil {
5605		if !ec.HasError(rctx) {
5606			ec.Errorf(ctx, "must not be null")
5607		}
5608		return graphql.Null
5609	}
5610	res := resTmp.([]bug.Label)
5611	rctx.Result = res
5612	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5613
5614	arr1 := make(graphql.Array, len(res))
5615
5616	for idx1 := range res {
5617		arr1[idx1] = func() graphql.Marshaler {
5618			return res[idx1]
5619		}()
5620	}
5621
5622	return arr1
5623}
5624
5625// nolint: vetshadow
5626func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
5627	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5628	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5629	rctx := &graphql.ResolverContext{
5630		Object: "LabelChangeOperation",
5631		Args:   nil,
5632		Field:  field,
5633	}
5634	ctx = graphql.WithResolverContext(ctx, rctx)
5635	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5636	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5637		ctx = rctx // use context from middleware stack in children
5638		return obj.Removed, nil
5639	})
5640	if resTmp == nil {
5641		if !ec.HasError(rctx) {
5642			ec.Errorf(ctx, "must not be null")
5643		}
5644		return graphql.Null
5645	}
5646	res := resTmp.([]bug.Label)
5647	rctx.Result = res
5648	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5649
5650	arr1 := make(graphql.Array, len(res))
5651
5652	for idx1 := range res {
5653		arr1[idx1] = func() graphql.Marshaler {
5654			return res[idx1]
5655		}()
5656	}
5657
5658	return arr1
5659}
5660
5661var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem"}
5662
5663// nolint: gocyclo, errcheck, gas, goconst
5664func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
5665	fields := graphql.CollectFields(ctx, sel, labelChangeTimelineItemImplementors)
5666
5667	var wg sync.WaitGroup
5668	out := graphql.NewOrderedMap(len(fields))
5669	invalid := false
5670	for i, field := range fields {
5671		out.Keys[i] = field.Alias
5672
5673		switch field.Name {
5674		case "__typename":
5675			out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
5676		case "hash":
5677			out.Values[i] = ec._LabelChangeTimelineItem_hash(ctx, field, obj)
5678			if out.Values[i] == graphql.Null {
5679				invalid = true
5680			}
5681		case "author":
5682			out.Values[i] = ec._LabelChangeTimelineItem_author(ctx, field, obj)
5683			if out.Values[i] == graphql.Null {
5684				invalid = true
5685			}
5686		case "date":
5687			wg.Add(1)
5688			go func(i int, field graphql.CollectedField) {
5689				out.Values[i] = ec._LabelChangeTimelineItem_date(ctx, field, obj)
5690				if out.Values[i] == graphql.Null {
5691					invalid = true
5692				}
5693				wg.Done()
5694			}(i, field)
5695		case "added":
5696			out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
5697			if out.Values[i] == graphql.Null {
5698				invalid = true
5699			}
5700		case "removed":
5701			out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
5702			if out.Values[i] == graphql.Null {
5703				invalid = true
5704			}
5705		default:
5706			panic("unknown field " + strconv.Quote(field.Name))
5707		}
5708	}
5709	wg.Wait()
5710	if invalid {
5711		return graphql.Null
5712	}
5713	return out
5714}
5715
5716// nolint: vetshadow
5717func (ec *executionContext) _LabelChangeTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
5718	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5719	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5720	rctx := &graphql.ResolverContext{
5721		Object: "LabelChangeTimelineItem",
5722		Args:   nil,
5723		Field:  field,
5724	}
5725	ctx = graphql.WithResolverContext(ctx, rctx)
5726	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5727	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5728		ctx = rctx // use context from middleware stack in children
5729		return obj.Hash(), nil
5730	})
5731	if resTmp == nil {
5732		if !ec.HasError(rctx) {
5733			ec.Errorf(ctx, "must not be null")
5734		}
5735		return graphql.Null
5736	}
5737	res := resTmp.(git.Hash)
5738	rctx.Result = res
5739	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5740	return res
5741}
5742
5743// nolint: vetshadow
5744func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
5745	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5746	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5747	rctx := &graphql.ResolverContext{
5748		Object: "LabelChangeTimelineItem",
5749		Args:   nil,
5750		Field:  field,
5751	}
5752	ctx = graphql.WithResolverContext(ctx, rctx)
5753	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5754	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5755		ctx = rctx // use context from middleware stack in children
5756		return obj.Author, nil
5757	})
5758	if resTmp == nil {
5759		if !ec.HasError(rctx) {
5760			ec.Errorf(ctx, "must not be null")
5761		}
5762		return graphql.Null
5763	}
5764	res := resTmp.(identity.Interface)
5765	rctx.Result = res
5766	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5767
5768	return ec._Identity(ctx, field.Selections, &res)
5769}
5770
5771// nolint: vetshadow
5772func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
5773	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5774	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5775	rctx := &graphql.ResolverContext{
5776		Object: "LabelChangeTimelineItem",
5777		Args:   nil,
5778		Field:  field,
5779	}
5780	ctx = graphql.WithResolverContext(ctx, rctx)
5781	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5782	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5783		ctx = rctx // use context from middleware stack in children
5784		return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
5785	})
5786	if resTmp == nil {
5787		if !ec.HasError(rctx) {
5788			ec.Errorf(ctx, "must not be null")
5789		}
5790		return graphql.Null
5791	}
5792	res := resTmp.(time.Time)
5793	rctx.Result = res
5794	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5795	return graphql.MarshalTime(res)
5796}
5797
5798// nolint: vetshadow
5799func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
5800	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5801	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5802	rctx := &graphql.ResolverContext{
5803		Object: "LabelChangeTimelineItem",
5804		Args:   nil,
5805		Field:  field,
5806	}
5807	ctx = graphql.WithResolverContext(ctx, rctx)
5808	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5809	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5810		ctx = rctx // use context from middleware stack in children
5811		return obj.Added, nil
5812	})
5813	if resTmp == nil {
5814		if !ec.HasError(rctx) {
5815			ec.Errorf(ctx, "must not be null")
5816		}
5817		return graphql.Null
5818	}
5819	res := resTmp.([]bug.Label)
5820	rctx.Result = res
5821	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5822
5823	arr1 := make(graphql.Array, len(res))
5824
5825	for idx1 := range res {
5826		arr1[idx1] = func() graphql.Marshaler {
5827			return res[idx1]
5828		}()
5829	}
5830
5831	return arr1
5832}
5833
5834// nolint: vetshadow
5835func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
5836	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5837	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5838	rctx := &graphql.ResolverContext{
5839		Object: "LabelChangeTimelineItem",
5840		Args:   nil,
5841		Field:  field,
5842	}
5843	ctx = graphql.WithResolverContext(ctx, rctx)
5844	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5845	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5846		ctx = rctx // use context from middleware stack in children
5847		return obj.Removed, nil
5848	})
5849	if resTmp == nil {
5850		if !ec.HasError(rctx) {
5851			ec.Errorf(ctx, "must not be null")
5852		}
5853		return graphql.Null
5854	}
5855	res := resTmp.([]bug.Label)
5856	rctx.Result = res
5857	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5858
5859	arr1 := make(graphql.Array, len(res))
5860
5861	for idx1 := range res {
5862		arr1[idx1] = func() graphql.Marshaler {
5863			return res[idx1]
5864		}()
5865	}
5866
5867	return arr1
5868}
5869
5870var mutationImplementors = []string{"Mutation"}
5871
5872// nolint: gocyclo, errcheck, gas, goconst
5873func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
5874	fields := graphql.CollectFields(ctx, sel, mutationImplementors)
5875
5876	ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
5877		Object: "Mutation",
5878	})
5879
5880	out := graphql.NewOrderedMap(len(fields))
5881	invalid := false
5882	for i, field := range fields {
5883		out.Keys[i] = field.Alias
5884
5885		switch field.Name {
5886		case "__typename":
5887			out.Values[i] = graphql.MarshalString("Mutation")
5888		case "newBug":
5889			out.Values[i] = ec._Mutation_newBug(ctx, field)
5890			if out.Values[i] == graphql.Null {
5891				invalid = true
5892			}
5893		case "addComment":
5894			out.Values[i] = ec._Mutation_addComment(ctx, field)
5895			if out.Values[i] == graphql.Null {
5896				invalid = true
5897			}
5898		case "changeLabels":
5899			out.Values[i] = ec._Mutation_changeLabels(ctx, field)
5900			if out.Values[i] == graphql.Null {
5901				invalid = true
5902			}
5903		case "open":
5904			out.Values[i] = ec._Mutation_open(ctx, field)
5905			if out.Values[i] == graphql.Null {
5906				invalid = true
5907			}
5908		case "close":
5909			out.Values[i] = ec._Mutation_close(ctx, field)
5910			if out.Values[i] == graphql.Null {
5911				invalid = true
5912			}
5913		case "setTitle":
5914			out.Values[i] = ec._Mutation_setTitle(ctx, field)
5915			if out.Values[i] == graphql.Null {
5916				invalid = true
5917			}
5918		case "commit":
5919			out.Values[i] = ec._Mutation_commit(ctx, field)
5920			if out.Values[i] == graphql.Null {
5921				invalid = true
5922			}
5923		default:
5924			panic("unknown field " + strconv.Quote(field.Name))
5925		}
5926	}
5927
5928	if invalid {
5929		return graphql.Null
5930	}
5931	return out
5932}
5933
5934// nolint: vetshadow
5935func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5936	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5937	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5938	rawArgs := field.ArgumentMap(ec.Variables)
5939	args, err := field_Mutation_newBug_args(rawArgs)
5940	if err != nil {
5941		ec.Error(ctx, err)
5942		return graphql.Null
5943	}
5944	rctx := &graphql.ResolverContext{
5945		Object: "Mutation",
5946		Args:   args,
5947		Field:  field,
5948	}
5949	ctx = graphql.WithResolverContext(ctx, rctx)
5950	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5951	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5952		ctx = rctx // use context from middleware stack in children
5953		return ec.resolvers.Mutation().NewBug(rctx, args["repoRef"].(*string), args["title"].(string), args["message"].(string), args["files"].([]git.Hash))
5954	})
5955	if resTmp == nil {
5956		if !ec.HasError(rctx) {
5957			ec.Errorf(ctx, "must not be null")
5958		}
5959		return graphql.Null
5960	}
5961	res := resTmp.(bug.Snapshot)
5962	rctx.Result = res
5963	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5964
5965	return ec._Bug(ctx, field.Selections, &res)
5966}
5967
5968// nolint: vetshadow
5969func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5970	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5971	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5972	rawArgs := field.ArgumentMap(ec.Variables)
5973	args, err := field_Mutation_addComment_args(rawArgs)
5974	if err != nil {
5975		ec.Error(ctx, err)
5976		return graphql.Null
5977	}
5978	rctx := &graphql.ResolverContext{
5979		Object: "Mutation",
5980		Args:   args,
5981		Field:  field,
5982	}
5983	ctx = graphql.WithResolverContext(ctx, rctx)
5984	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5985	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5986		ctx = rctx // use context from middleware stack in children
5987		return ec.resolvers.Mutation().AddComment(rctx, args["repoRef"].(*string), args["prefix"].(string), args["message"].(string), args["files"].([]git.Hash))
5988	})
5989	if resTmp == nil {
5990		if !ec.HasError(rctx) {
5991			ec.Errorf(ctx, "must not be null")
5992		}
5993		return graphql.Null
5994	}
5995	res := resTmp.(bug.Snapshot)
5996	rctx.Result = res
5997	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5998
5999	return ec._Bug(ctx, field.Selections, &res)
6000}
6001
6002// nolint: vetshadow
6003func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6004	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6005	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6006	rawArgs := field.ArgumentMap(ec.Variables)
6007	args, err := field_Mutation_changeLabels_args(rawArgs)
6008	if err != nil {
6009		ec.Error(ctx, err)
6010		return graphql.Null
6011	}
6012	rctx := &graphql.ResolverContext{
6013		Object: "Mutation",
6014		Args:   args,
6015		Field:  field,
6016	}
6017	ctx = graphql.WithResolverContext(ctx, rctx)
6018	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6019	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6020		ctx = rctx // use context from middleware stack in children
6021		return ec.resolvers.Mutation().ChangeLabels(rctx, args["repoRef"].(*string), args["prefix"].(string), args["added"].([]string), args["removed"].([]string))
6022	})
6023	if resTmp == nil {
6024		if !ec.HasError(rctx) {
6025			ec.Errorf(ctx, "must not be null")
6026		}
6027		return graphql.Null
6028	}
6029	res := resTmp.(bug.Snapshot)
6030	rctx.Result = res
6031	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6032
6033	return ec._Bug(ctx, field.Selections, &res)
6034}
6035
6036// nolint: vetshadow
6037func (ec *executionContext) _Mutation_open(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6038	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6039	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6040	rawArgs := field.ArgumentMap(ec.Variables)
6041	args, err := field_Mutation_open_args(rawArgs)
6042	if err != nil {
6043		ec.Error(ctx, err)
6044		return graphql.Null
6045	}
6046	rctx := &graphql.ResolverContext{
6047		Object: "Mutation",
6048		Args:   args,
6049		Field:  field,
6050	}
6051	ctx = graphql.WithResolverContext(ctx, rctx)
6052	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6053	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6054		ctx = rctx // use context from middleware stack in children
6055		return ec.resolvers.Mutation().Open(rctx, args["repoRef"].(*string), args["prefix"].(string))
6056	})
6057	if resTmp == nil {
6058		if !ec.HasError(rctx) {
6059			ec.Errorf(ctx, "must not be null")
6060		}
6061		return graphql.Null
6062	}
6063	res := resTmp.(bug.Snapshot)
6064	rctx.Result = res
6065	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6066
6067	return ec._Bug(ctx, field.Selections, &res)
6068}
6069
6070// nolint: vetshadow
6071func (ec *executionContext) _Mutation_close(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6072	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6073	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6074	rawArgs := field.ArgumentMap(ec.Variables)
6075	args, err := field_Mutation_close_args(rawArgs)
6076	if err != nil {
6077		ec.Error(ctx, err)
6078		return graphql.Null
6079	}
6080	rctx := &graphql.ResolverContext{
6081		Object: "Mutation",
6082		Args:   args,
6083		Field:  field,
6084	}
6085	ctx = graphql.WithResolverContext(ctx, rctx)
6086	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6087	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6088		ctx = rctx // use context from middleware stack in children
6089		return ec.resolvers.Mutation().Close(rctx, args["repoRef"].(*string), args["prefix"].(string))
6090	})
6091	if resTmp == nil {
6092		if !ec.HasError(rctx) {
6093			ec.Errorf(ctx, "must not be null")
6094		}
6095		return graphql.Null
6096	}
6097	res := resTmp.(bug.Snapshot)
6098	rctx.Result = res
6099	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6100
6101	return ec._Bug(ctx, field.Selections, &res)
6102}
6103
6104// nolint: vetshadow
6105func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6106	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6107	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6108	rawArgs := field.ArgumentMap(ec.Variables)
6109	args, err := field_Mutation_setTitle_args(rawArgs)
6110	if err != nil {
6111		ec.Error(ctx, err)
6112		return graphql.Null
6113	}
6114	rctx := &graphql.ResolverContext{
6115		Object: "Mutation",
6116		Args:   args,
6117		Field:  field,
6118	}
6119	ctx = graphql.WithResolverContext(ctx, rctx)
6120	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6121	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6122		ctx = rctx // use context from middleware stack in children
6123		return ec.resolvers.Mutation().SetTitle(rctx, args["repoRef"].(*string), args["prefix"].(string), args["title"].(string))
6124	})
6125	if resTmp == nil {
6126		if !ec.HasError(rctx) {
6127			ec.Errorf(ctx, "must not be null")
6128		}
6129		return graphql.Null
6130	}
6131	res := resTmp.(bug.Snapshot)
6132	rctx.Result = res
6133	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6134
6135	return ec._Bug(ctx, field.Selections, &res)
6136}
6137
6138// nolint: vetshadow
6139func (ec *executionContext) _Mutation_commit(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6140	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6141	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6142	rawArgs := field.ArgumentMap(ec.Variables)
6143	args, err := field_Mutation_commit_args(rawArgs)
6144	if err != nil {
6145		ec.Error(ctx, err)
6146		return graphql.Null
6147	}
6148	rctx := &graphql.ResolverContext{
6149		Object: "Mutation",
6150		Args:   args,
6151		Field:  field,
6152	}
6153	ctx = graphql.WithResolverContext(ctx, rctx)
6154	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6155	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6156		ctx = rctx // use context from middleware stack in children
6157		return ec.resolvers.Mutation().Commit(rctx, args["repoRef"].(*string), args["prefix"].(string))
6158	})
6159	if resTmp == nil {
6160		if !ec.HasError(rctx) {
6161			ec.Errorf(ctx, "must not be null")
6162		}
6163		return graphql.Null
6164	}
6165	res := resTmp.(bug.Snapshot)
6166	rctx.Result = res
6167	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6168
6169	return ec._Bug(ctx, field.Selections, &res)
6170}
6171
6172var operationConnectionImplementors = []string{"OperationConnection"}
6173
6174// nolint: gocyclo, errcheck, gas, goconst
6175func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
6176	fields := graphql.CollectFields(ctx, sel, operationConnectionImplementors)
6177
6178	out := graphql.NewOrderedMap(len(fields))
6179	invalid := false
6180	for i, field := range fields {
6181		out.Keys[i] = field.Alias
6182
6183		switch field.Name {
6184		case "__typename":
6185			out.Values[i] = graphql.MarshalString("OperationConnection")
6186		case "edges":
6187			out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
6188			if out.Values[i] == graphql.Null {
6189				invalid = true
6190			}
6191		case "nodes":
6192			out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
6193			if out.Values[i] == graphql.Null {
6194				invalid = true
6195			}
6196		case "pageInfo":
6197			out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
6198			if out.Values[i] == graphql.Null {
6199				invalid = true
6200			}
6201		case "totalCount":
6202			out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
6203			if out.Values[i] == graphql.Null {
6204				invalid = true
6205			}
6206		default:
6207			panic("unknown field " + strconv.Quote(field.Name))
6208		}
6209	}
6210
6211	if invalid {
6212		return graphql.Null
6213	}
6214	return out
6215}
6216
6217// nolint: vetshadow
6218func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
6219	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6220	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6221	rctx := &graphql.ResolverContext{
6222		Object: "OperationConnection",
6223		Args:   nil,
6224		Field:  field,
6225	}
6226	ctx = graphql.WithResolverContext(ctx, rctx)
6227	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6228	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6229		ctx = rctx // use context from middleware stack in children
6230		return obj.Edges, nil
6231	})
6232	if resTmp == nil {
6233		if !ec.HasError(rctx) {
6234			ec.Errorf(ctx, "must not be null")
6235		}
6236		return graphql.Null
6237	}
6238	res := resTmp.([]models.OperationEdge)
6239	rctx.Result = res
6240	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6241
6242	arr1 := make(graphql.Array, len(res))
6243	var wg sync.WaitGroup
6244
6245	isLen1 := len(res) == 1
6246	if !isLen1 {
6247		wg.Add(len(res))
6248	}
6249
6250	for idx1 := range res {
6251		idx1 := idx1
6252		rctx := &graphql.ResolverContext{
6253			Index:  &idx1,
6254			Result: &res[idx1],
6255		}
6256		ctx := graphql.WithResolverContext(ctx, rctx)
6257		f := func(idx1 int) {
6258			if !isLen1 {
6259				defer wg.Done()
6260			}
6261			arr1[idx1] = func() graphql.Marshaler {
6262
6263				return ec._OperationEdge(ctx, field.Selections, &res[idx1])
6264			}()
6265		}
6266		if isLen1 {
6267			f(idx1)
6268		} else {
6269			go f(idx1)
6270		}
6271
6272	}
6273	wg.Wait()
6274	return arr1
6275}
6276
6277// nolint: vetshadow
6278func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
6279	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6280	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6281	rctx := &graphql.ResolverContext{
6282		Object: "OperationConnection",
6283		Args:   nil,
6284		Field:  field,
6285	}
6286	ctx = graphql.WithResolverContext(ctx, rctx)
6287	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6288	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6289		ctx = rctx // use context from middleware stack in children
6290		return obj.Nodes, nil
6291	})
6292	if resTmp == nil {
6293		if !ec.HasError(rctx) {
6294			ec.Errorf(ctx, "must not be null")
6295		}
6296		return graphql.Null
6297	}
6298	res := resTmp.([]bug.Operation)
6299	rctx.Result = res
6300	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6301
6302	arr1 := make(graphql.Array, len(res))
6303	var wg sync.WaitGroup
6304
6305	isLen1 := len(res) == 1
6306	if !isLen1 {
6307		wg.Add(len(res))
6308	}
6309
6310	for idx1 := range res {
6311		idx1 := idx1
6312		rctx := &graphql.ResolverContext{
6313			Index:  &idx1,
6314			Result: &res[idx1],
6315		}
6316		ctx := graphql.WithResolverContext(ctx, rctx)
6317		f := func(idx1 int) {
6318			if !isLen1 {
6319				defer wg.Done()
6320			}
6321			arr1[idx1] = func() graphql.Marshaler {
6322
6323				return ec._Operation(ctx, field.Selections, &res[idx1])
6324			}()
6325		}
6326		if isLen1 {
6327			f(idx1)
6328		} else {
6329			go f(idx1)
6330		}
6331
6332	}
6333	wg.Wait()
6334	return arr1
6335}
6336
6337// nolint: vetshadow
6338func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
6339	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6340	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6341	rctx := &graphql.ResolverContext{
6342		Object: "OperationConnection",
6343		Args:   nil,
6344		Field:  field,
6345	}
6346	ctx = graphql.WithResolverContext(ctx, rctx)
6347	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6348	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6349		ctx = rctx // use context from middleware stack in children
6350		return obj.PageInfo, nil
6351	})
6352	if resTmp == nil {
6353		if !ec.HasError(rctx) {
6354			ec.Errorf(ctx, "must not be null")
6355		}
6356		return graphql.Null
6357	}
6358	res := resTmp.(models.PageInfo)
6359	rctx.Result = res
6360	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6361
6362	return ec._PageInfo(ctx, field.Selections, &res)
6363}
6364
6365// nolint: vetshadow
6366func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
6367	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6368	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6369	rctx := &graphql.ResolverContext{
6370		Object: "OperationConnection",
6371		Args:   nil,
6372		Field:  field,
6373	}
6374	ctx = graphql.WithResolverContext(ctx, rctx)
6375	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6376	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6377		ctx = rctx // use context from middleware stack in children
6378		return obj.TotalCount, nil
6379	})
6380	if resTmp == nil {
6381		if !ec.HasError(rctx) {
6382			ec.Errorf(ctx, "must not be null")
6383		}
6384		return graphql.Null
6385	}
6386	res := resTmp.(int)
6387	rctx.Result = res
6388	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6389	return graphql.MarshalInt(res)
6390}
6391
6392var operationEdgeImplementors = []string{"OperationEdge"}
6393
6394// nolint: gocyclo, errcheck, gas, goconst
6395func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
6396	fields := graphql.CollectFields(ctx, sel, operationEdgeImplementors)
6397
6398	out := graphql.NewOrderedMap(len(fields))
6399	invalid := false
6400	for i, field := range fields {
6401		out.Keys[i] = field.Alias
6402
6403		switch field.Name {
6404		case "__typename":
6405			out.Values[i] = graphql.MarshalString("OperationEdge")
6406		case "cursor":
6407			out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
6408			if out.Values[i] == graphql.Null {
6409				invalid = true
6410			}
6411		case "node":
6412			out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
6413			if out.Values[i] == graphql.Null {
6414				invalid = true
6415			}
6416		default:
6417			panic("unknown field " + strconv.Quote(field.Name))
6418		}
6419	}
6420
6421	if invalid {
6422		return graphql.Null
6423	}
6424	return out
6425}
6426
6427// nolint: vetshadow
6428func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) graphql.Marshaler {
6429	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6430	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6431	rctx := &graphql.ResolverContext{
6432		Object: "OperationEdge",
6433		Args:   nil,
6434		Field:  field,
6435	}
6436	ctx = graphql.WithResolverContext(ctx, rctx)
6437	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6438	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6439		ctx = rctx // use context from middleware stack in children
6440		return obj.Cursor, nil
6441	})
6442	if resTmp == nil {
6443		if !ec.HasError(rctx) {
6444			ec.Errorf(ctx, "must not be null")
6445		}
6446		return graphql.Null
6447	}
6448	res := resTmp.(string)
6449	rctx.Result = res
6450	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6451	return graphql.MarshalString(res)
6452}
6453
6454// nolint: vetshadow
6455func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) graphql.Marshaler {
6456	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6457	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6458	rctx := &graphql.ResolverContext{
6459		Object: "OperationEdge",
6460		Args:   nil,
6461		Field:  field,
6462	}
6463	ctx = graphql.WithResolverContext(ctx, rctx)
6464	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6465	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6466		ctx = rctx // use context from middleware stack in children
6467		return obj.Node, nil
6468	})
6469	if resTmp == nil {
6470		if !ec.HasError(rctx) {
6471			ec.Errorf(ctx, "must not be null")
6472		}
6473		return graphql.Null
6474	}
6475	res := resTmp.(bug.Operation)
6476	rctx.Result = res
6477	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6478
6479	return ec._Operation(ctx, field.Selections, &res)
6480}
6481
6482var pageInfoImplementors = []string{"PageInfo"}
6483
6484// nolint: gocyclo, errcheck, gas, goconst
6485func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
6486	fields := graphql.CollectFields(ctx, sel, pageInfoImplementors)
6487
6488	out := graphql.NewOrderedMap(len(fields))
6489	invalid := false
6490	for i, field := range fields {
6491		out.Keys[i] = field.Alias
6492
6493		switch field.Name {
6494		case "__typename":
6495			out.Values[i] = graphql.MarshalString("PageInfo")
6496		case "hasNextPage":
6497			out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
6498			if out.Values[i] == graphql.Null {
6499				invalid = true
6500			}
6501		case "hasPreviousPage":
6502			out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
6503			if out.Values[i] == graphql.Null {
6504				invalid = true
6505			}
6506		case "startCursor":
6507			out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
6508			if out.Values[i] == graphql.Null {
6509				invalid = true
6510			}
6511		case "endCursor":
6512			out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
6513			if out.Values[i] == graphql.Null {
6514				invalid = true
6515			}
6516		default:
6517			panic("unknown field " + strconv.Quote(field.Name))
6518		}
6519	}
6520
6521	if invalid {
6522		return graphql.Null
6523	}
6524	return out
6525}
6526
6527// nolint: vetshadow
6528func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
6529	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6530	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6531	rctx := &graphql.ResolverContext{
6532		Object: "PageInfo",
6533		Args:   nil,
6534		Field:  field,
6535	}
6536	ctx = graphql.WithResolverContext(ctx, rctx)
6537	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6538	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6539		ctx = rctx // use context from middleware stack in children
6540		return obj.HasNextPage, nil
6541	})
6542	if resTmp == nil {
6543		if !ec.HasError(rctx) {
6544			ec.Errorf(ctx, "must not be null")
6545		}
6546		return graphql.Null
6547	}
6548	res := resTmp.(bool)
6549	rctx.Result = res
6550	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6551	return graphql.MarshalBoolean(res)
6552}
6553
6554// nolint: vetshadow
6555func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
6556	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6557	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6558	rctx := &graphql.ResolverContext{
6559		Object: "PageInfo",
6560		Args:   nil,
6561		Field:  field,
6562	}
6563	ctx = graphql.WithResolverContext(ctx, rctx)
6564	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6565	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6566		ctx = rctx // use context from middleware stack in children
6567		return obj.HasPreviousPage, nil
6568	})
6569	if resTmp == nil {
6570		if !ec.HasError(rctx) {
6571			ec.Errorf(ctx, "must not be null")
6572		}
6573		return graphql.Null
6574	}
6575	res := resTmp.(bool)
6576	rctx.Result = res
6577	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6578	return graphql.MarshalBoolean(res)
6579}
6580
6581// nolint: vetshadow
6582func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
6583	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6584	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6585	rctx := &graphql.ResolverContext{
6586		Object: "PageInfo",
6587		Args:   nil,
6588		Field:  field,
6589	}
6590	ctx = graphql.WithResolverContext(ctx, rctx)
6591	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6592	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6593		ctx = rctx // use context from middleware stack in children
6594		return obj.StartCursor, nil
6595	})
6596	if resTmp == nil {
6597		if !ec.HasError(rctx) {
6598			ec.Errorf(ctx, "must not be null")
6599		}
6600		return graphql.Null
6601	}
6602	res := resTmp.(string)
6603	rctx.Result = res
6604	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6605	return graphql.MarshalString(res)
6606}
6607
6608// nolint: vetshadow
6609func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
6610	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6611	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6612	rctx := &graphql.ResolverContext{
6613		Object: "PageInfo",
6614		Args:   nil,
6615		Field:  field,
6616	}
6617	ctx = graphql.WithResolverContext(ctx, rctx)
6618	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6619	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6620		ctx = rctx // use context from middleware stack in children
6621		return obj.EndCursor, nil
6622	})
6623	if resTmp == nil {
6624		if !ec.HasError(rctx) {
6625			ec.Errorf(ctx, "must not be null")
6626		}
6627		return graphql.Null
6628	}
6629	res := resTmp.(string)
6630	rctx.Result = res
6631	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6632	return graphql.MarshalString(res)
6633}
6634
6635var queryImplementors = []string{"Query"}
6636
6637// nolint: gocyclo, errcheck, gas, goconst
6638func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
6639	fields := graphql.CollectFields(ctx, sel, queryImplementors)
6640
6641	ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
6642		Object: "Query",
6643	})
6644
6645	var wg sync.WaitGroup
6646	out := graphql.NewOrderedMap(len(fields))
6647	invalid := false
6648	for i, field := range fields {
6649		out.Keys[i] = field.Alias
6650
6651		switch field.Name {
6652		case "__typename":
6653			out.Values[i] = graphql.MarshalString("Query")
6654		case "defaultRepository":
6655			wg.Add(1)
6656			go func(i int, field graphql.CollectedField) {
6657				out.Values[i] = ec._Query_defaultRepository(ctx, field)
6658				wg.Done()
6659			}(i, field)
6660		case "repository":
6661			wg.Add(1)
6662			go func(i int, field graphql.CollectedField) {
6663				out.Values[i] = ec._Query_repository(ctx, field)
6664				wg.Done()
6665			}(i, field)
6666		case "__type":
6667			out.Values[i] = ec._Query___type(ctx, field)
6668		case "__schema":
6669			out.Values[i] = ec._Query___schema(ctx, field)
6670		default:
6671			panic("unknown field " + strconv.Quote(field.Name))
6672		}
6673	}
6674	wg.Wait()
6675	if invalid {
6676		return graphql.Null
6677	}
6678	return out
6679}
6680
6681// nolint: vetshadow
6682func (ec *executionContext) _Query_defaultRepository(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6683	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6684	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6685	rctx := &graphql.ResolverContext{
6686		Object: "Query",
6687		Args:   nil,
6688		Field:  field,
6689	}
6690	ctx = graphql.WithResolverContext(ctx, rctx)
6691	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6692	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6693		ctx = rctx // use context from middleware stack in children
6694		return ec.resolvers.Query().DefaultRepository(rctx)
6695	})
6696	if resTmp == nil {
6697		return graphql.Null
6698	}
6699	res := resTmp.(*models.Repository)
6700	rctx.Result = res
6701	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6702
6703	if res == nil {
6704		return graphql.Null
6705	}
6706
6707	return ec._Repository(ctx, field.Selections, res)
6708}
6709
6710// nolint: vetshadow
6711func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6712	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6713	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6714	rawArgs := field.ArgumentMap(ec.Variables)
6715	args, err := field_Query_repository_args(rawArgs)
6716	if err != nil {
6717		ec.Error(ctx, err)
6718		return graphql.Null
6719	}
6720	rctx := &graphql.ResolverContext{
6721		Object: "Query",
6722		Args:   args,
6723		Field:  field,
6724	}
6725	ctx = graphql.WithResolverContext(ctx, rctx)
6726	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6727	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6728		ctx = rctx // use context from middleware stack in children
6729		return ec.resolvers.Query().Repository(rctx, args["id"].(string))
6730	})
6731	if resTmp == nil {
6732		return graphql.Null
6733	}
6734	res := resTmp.(*models.Repository)
6735	rctx.Result = res
6736	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6737
6738	if res == nil {
6739		return graphql.Null
6740	}
6741
6742	return ec._Repository(ctx, field.Selections, res)
6743}
6744
6745// nolint: vetshadow
6746func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6747	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6748	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6749	rawArgs := field.ArgumentMap(ec.Variables)
6750	args, err := field_Query___type_args(rawArgs)
6751	if err != nil {
6752		ec.Error(ctx, err)
6753		return graphql.Null
6754	}
6755	rctx := &graphql.ResolverContext{
6756		Object: "Query",
6757		Args:   args,
6758		Field:  field,
6759	}
6760	ctx = graphql.WithResolverContext(ctx, rctx)
6761	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6762	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6763		ctx = rctx // use context from middleware stack in children
6764		return ec.introspectType(args["name"].(string))
6765	})
6766	if resTmp == nil {
6767		return graphql.Null
6768	}
6769	res := resTmp.(*introspection.Type)
6770	rctx.Result = res
6771	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6772
6773	if res == nil {
6774		return graphql.Null
6775	}
6776
6777	return ec.___Type(ctx, field.Selections, res)
6778}
6779
6780// nolint: vetshadow
6781func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6782	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6783	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6784	rctx := &graphql.ResolverContext{
6785		Object: "Query",
6786		Args:   nil,
6787		Field:  field,
6788	}
6789	ctx = graphql.WithResolverContext(ctx, rctx)
6790	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6791	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6792		ctx = rctx // use context from middleware stack in children
6793		return ec.introspectSchema()
6794	})
6795	if resTmp == nil {
6796		return graphql.Null
6797	}
6798	res := resTmp.(*introspection.Schema)
6799	rctx.Result = res
6800	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6801
6802	if res == nil {
6803		return graphql.Null
6804	}
6805
6806	return ec.___Schema(ctx, field.Selections, res)
6807}
6808
6809var repositoryImplementors = []string{"Repository"}
6810
6811// nolint: gocyclo, errcheck, gas, goconst
6812func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
6813	fields := graphql.CollectFields(ctx, sel, repositoryImplementors)
6814
6815	var wg sync.WaitGroup
6816	out := graphql.NewOrderedMap(len(fields))
6817	invalid := false
6818	for i, field := range fields {
6819		out.Keys[i] = field.Alias
6820
6821		switch field.Name {
6822		case "__typename":
6823			out.Values[i] = graphql.MarshalString("Repository")
6824		case "allBugs":
6825			wg.Add(1)
6826			go func(i int, field graphql.CollectedField) {
6827				out.Values[i] = ec._Repository_allBugs(ctx, field, obj)
6828				if out.Values[i] == graphql.Null {
6829					invalid = true
6830				}
6831				wg.Done()
6832			}(i, field)
6833		case "bug":
6834			wg.Add(1)
6835			go func(i int, field graphql.CollectedField) {
6836				out.Values[i] = ec._Repository_bug(ctx, field, obj)
6837				wg.Done()
6838			}(i, field)
6839		case "allIdentities":
6840			wg.Add(1)
6841			go func(i int, field graphql.CollectedField) {
6842				out.Values[i] = ec._Repository_allIdentities(ctx, field, obj)
6843				if out.Values[i] == graphql.Null {
6844					invalid = true
6845				}
6846				wg.Done()
6847			}(i, field)
6848		case "identity":
6849			wg.Add(1)
6850			go func(i int, field graphql.CollectedField) {
6851				out.Values[i] = ec._Repository_identity(ctx, field, obj)
6852				wg.Done()
6853			}(i, field)
6854		case "userIdentity":
6855			wg.Add(1)
6856			go func(i int, field graphql.CollectedField) {
6857				out.Values[i] = ec._Repository_userIdentity(ctx, field, obj)
6858				wg.Done()
6859			}(i, field)
6860		default:
6861			panic("unknown field " + strconv.Quote(field.Name))
6862		}
6863	}
6864	wg.Wait()
6865	if invalid {
6866		return graphql.Null
6867	}
6868	return out
6869}
6870
6871// nolint: vetshadow
6872func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
6873	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6874	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6875	rawArgs := field.ArgumentMap(ec.Variables)
6876	args, err := field_Repository_allBugs_args(rawArgs)
6877	if err != nil {
6878		ec.Error(ctx, err)
6879		return graphql.Null
6880	}
6881	rctx := &graphql.ResolverContext{
6882		Object: "Repository",
6883		Args:   args,
6884		Field:  field,
6885	}
6886	ctx = graphql.WithResolverContext(ctx, rctx)
6887	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6888	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6889		ctx = rctx // use context from middleware stack in children
6890		return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
6891	})
6892	if resTmp == nil {
6893		if !ec.HasError(rctx) {
6894			ec.Errorf(ctx, "must not be null")
6895		}
6896		return graphql.Null
6897	}
6898	res := resTmp.(models.BugConnection)
6899	rctx.Result = res
6900	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6901
6902	return ec._BugConnection(ctx, field.Selections, &res)
6903}
6904
6905// nolint: vetshadow
6906func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
6907	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6908	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6909	rawArgs := field.ArgumentMap(ec.Variables)
6910	args, err := field_Repository_bug_args(rawArgs)
6911	if err != nil {
6912		ec.Error(ctx, err)
6913		return graphql.Null
6914	}
6915	rctx := &graphql.ResolverContext{
6916		Object: "Repository",
6917		Args:   args,
6918		Field:  field,
6919	}
6920	ctx = graphql.WithResolverContext(ctx, rctx)
6921	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6922	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6923		ctx = rctx // use context from middleware stack in children
6924		return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
6925	})
6926	if resTmp == nil {
6927		return graphql.Null
6928	}
6929	res := resTmp.(*bug.Snapshot)
6930	rctx.Result = res
6931	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6932
6933	if res == nil {
6934		return graphql.Null
6935	}
6936
6937	return ec._Bug(ctx, field.Selections, res)
6938}
6939
6940// nolint: vetshadow
6941func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
6942	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6943	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6944	rawArgs := field.ArgumentMap(ec.Variables)
6945	args, err := field_Repository_allIdentities_args(rawArgs)
6946	if err != nil {
6947		ec.Error(ctx, err)
6948		return graphql.Null
6949	}
6950	rctx := &graphql.ResolverContext{
6951		Object: "Repository",
6952		Args:   args,
6953		Field:  field,
6954	}
6955	ctx = graphql.WithResolverContext(ctx, rctx)
6956	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6957	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6958		ctx = rctx // use context from middleware stack in children
6959		return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
6960	})
6961	if resTmp == nil {
6962		if !ec.HasError(rctx) {
6963			ec.Errorf(ctx, "must not be null")
6964		}
6965		return graphql.Null
6966	}
6967	res := resTmp.(models.IdentityConnection)
6968	rctx.Result = res
6969	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6970
6971	return ec._IdentityConnection(ctx, field.Selections, &res)
6972}
6973
6974// nolint: vetshadow
6975func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
6976	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6977	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6978	rawArgs := field.ArgumentMap(ec.Variables)
6979	args, err := field_Repository_identity_args(rawArgs)
6980	if err != nil {
6981		ec.Error(ctx, err)
6982		return graphql.Null
6983	}
6984	rctx := &graphql.ResolverContext{
6985		Object: "Repository",
6986		Args:   args,
6987		Field:  field,
6988	}
6989	ctx = graphql.WithResolverContext(ctx, rctx)
6990	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6991	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6992		ctx = rctx // use context from middleware stack in children
6993		return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
6994	})
6995	if resTmp == nil {
6996		return graphql.Null
6997	}
6998	res := resTmp.(*identity.Interface)
6999	rctx.Result = res
7000	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7001
7002	if res == nil {
7003		return graphql.Null
7004	}
7005
7006	return ec._Identity(ctx, field.Selections, res)
7007}
7008
7009// nolint: vetshadow
7010func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
7011	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7012	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7013	rctx := &graphql.ResolverContext{
7014		Object: "Repository",
7015		Args:   nil,
7016		Field:  field,
7017	}
7018	ctx = graphql.WithResolverContext(ctx, rctx)
7019	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7020	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7021		ctx = rctx // use context from middleware stack in children
7022		return ec.resolvers.Repository().UserIdentity(rctx, obj)
7023	})
7024	if resTmp == nil {
7025		return graphql.Null
7026	}
7027	res := resTmp.(*identity.Interface)
7028	rctx.Result = res
7029	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7030
7031	if res == nil {
7032		return graphql.Null
7033	}
7034
7035	return ec._Identity(ctx, field.Selections, res)
7036}
7037
7038var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
7039
7040// nolint: gocyclo, errcheck, gas, goconst
7041func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
7042	fields := graphql.CollectFields(ctx, sel, setStatusOperationImplementors)
7043
7044	var wg sync.WaitGroup
7045	out := graphql.NewOrderedMap(len(fields))
7046	invalid := false
7047	for i, field := range fields {
7048		out.Keys[i] = field.Alias
7049
7050		switch field.Name {
7051		case "__typename":
7052			out.Values[i] = graphql.MarshalString("SetStatusOperation")
7053		case "hash":
7054			out.Values[i] = ec._SetStatusOperation_hash(ctx, field, obj)
7055			if out.Values[i] == graphql.Null {
7056				invalid = true
7057			}
7058		case "author":
7059			out.Values[i] = ec._SetStatusOperation_author(ctx, field, obj)
7060			if out.Values[i] == graphql.Null {
7061				invalid = true
7062			}
7063		case "date":
7064			wg.Add(1)
7065			go func(i int, field graphql.CollectedField) {
7066				out.Values[i] = ec._SetStatusOperation_date(ctx, field, obj)
7067				if out.Values[i] == graphql.Null {
7068					invalid = true
7069				}
7070				wg.Done()
7071			}(i, field)
7072		case "status":
7073			wg.Add(1)
7074			go func(i int, field graphql.CollectedField) {
7075				out.Values[i] = ec._SetStatusOperation_status(ctx, field, obj)
7076				if out.Values[i] == graphql.Null {
7077					invalid = true
7078				}
7079				wg.Done()
7080			}(i, field)
7081		default:
7082			panic("unknown field " + strconv.Quote(field.Name))
7083		}
7084	}
7085	wg.Wait()
7086	if invalid {
7087		return graphql.Null
7088	}
7089	return out
7090}
7091
7092// nolint: vetshadow
7093func (ec *executionContext) _SetStatusOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
7094	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7095	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7096	rctx := &graphql.ResolverContext{
7097		Object: "SetStatusOperation",
7098		Args:   nil,
7099		Field:  field,
7100	}
7101	ctx = graphql.WithResolverContext(ctx, rctx)
7102	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7103	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7104		ctx = rctx // use context from middleware stack in children
7105		return obj.Hash()
7106	})
7107	if resTmp == nil {
7108		if !ec.HasError(rctx) {
7109			ec.Errorf(ctx, "must not be null")
7110		}
7111		return graphql.Null
7112	}
7113	res := resTmp.(git.Hash)
7114	rctx.Result = res
7115	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7116	return res
7117}
7118
7119// nolint: vetshadow
7120func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
7121	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7122	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7123	rctx := &graphql.ResolverContext{
7124		Object: "SetStatusOperation",
7125		Args:   nil,
7126		Field:  field,
7127	}
7128	ctx = graphql.WithResolverContext(ctx, rctx)
7129	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7130	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7131		ctx = rctx // use context from middleware stack in children
7132		return obj.Author, nil
7133	})
7134	if resTmp == nil {
7135		if !ec.HasError(rctx) {
7136			ec.Errorf(ctx, "must not be null")
7137		}
7138		return graphql.Null
7139	}
7140	res := resTmp.(identity.Interface)
7141	rctx.Result = res
7142	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7143
7144	return ec._Identity(ctx, field.Selections, &res)
7145}
7146
7147// nolint: vetshadow
7148func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
7149	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7150	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7151	rctx := &graphql.ResolverContext{
7152		Object: "SetStatusOperation",
7153		Args:   nil,
7154		Field:  field,
7155	}
7156	ctx = graphql.WithResolverContext(ctx, rctx)
7157	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7158	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7159		ctx = rctx // use context from middleware stack in children
7160		return ec.resolvers.SetStatusOperation().Date(rctx, obj)
7161	})
7162	if resTmp == nil {
7163		if !ec.HasError(rctx) {
7164			ec.Errorf(ctx, "must not be null")
7165		}
7166		return graphql.Null
7167	}
7168	res := resTmp.(time.Time)
7169	rctx.Result = res
7170	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7171	return graphql.MarshalTime(res)
7172}
7173
7174// nolint: vetshadow
7175func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
7176	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7177	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7178	rctx := &graphql.ResolverContext{
7179		Object: "SetStatusOperation",
7180		Args:   nil,
7181		Field:  field,
7182	}
7183	ctx = graphql.WithResolverContext(ctx, rctx)
7184	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7185	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7186		ctx = rctx // use context from middleware stack in children
7187		return ec.resolvers.SetStatusOperation().Status(rctx, obj)
7188	})
7189	if resTmp == nil {
7190		if !ec.HasError(rctx) {
7191			ec.Errorf(ctx, "must not be null")
7192		}
7193		return graphql.Null
7194	}
7195	res := resTmp.(models.Status)
7196	rctx.Result = res
7197	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7198	return res
7199}
7200
7201var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem"}
7202
7203// nolint: gocyclo, errcheck, gas, goconst
7204func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
7205	fields := graphql.CollectFields(ctx, sel, setStatusTimelineItemImplementors)
7206
7207	var wg sync.WaitGroup
7208	out := graphql.NewOrderedMap(len(fields))
7209	invalid := false
7210	for i, field := range fields {
7211		out.Keys[i] = field.Alias
7212
7213		switch field.Name {
7214		case "__typename":
7215			out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
7216		case "hash":
7217			out.Values[i] = ec._SetStatusTimelineItem_hash(ctx, field, obj)
7218			if out.Values[i] == graphql.Null {
7219				invalid = true
7220			}
7221		case "author":
7222			out.Values[i] = ec._SetStatusTimelineItem_author(ctx, field, obj)
7223			if out.Values[i] == graphql.Null {
7224				invalid = true
7225			}
7226		case "date":
7227			wg.Add(1)
7228			go func(i int, field graphql.CollectedField) {
7229				out.Values[i] = ec._SetStatusTimelineItem_date(ctx, field, obj)
7230				if out.Values[i] == graphql.Null {
7231					invalid = true
7232				}
7233				wg.Done()
7234			}(i, field)
7235		case "status":
7236			wg.Add(1)
7237			go func(i int, field graphql.CollectedField) {
7238				out.Values[i] = ec._SetStatusTimelineItem_status(ctx, field, obj)
7239				if out.Values[i] == graphql.Null {
7240					invalid = true
7241				}
7242				wg.Done()
7243			}(i, field)
7244		default:
7245			panic("unknown field " + strconv.Quote(field.Name))
7246		}
7247	}
7248	wg.Wait()
7249	if invalid {
7250		return graphql.Null
7251	}
7252	return out
7253}
7254
7255// nolint: vetshadow
7256func (ec *executionContext) _SetStatusTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
7257	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7258	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7259	rctx := &graphql.ResolverContext{
7260		Object: "SetStatusTimelineItem",
7261		Args:   nil,
7262		Field:  field,
7263	}
7264	ctx = graphql.WithResolverContext(ctx, rctx)
7265	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7266	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7267		ctx = rctx // use context from middleware stack in children
7268		return obj.Hash(), nil
7269	})
7270	if resTmp == nil {
7271		if !ec.HasError(rctx) {
7272			ec.Errorf(ctx, "must not be null")
7273		}
7274		return graphql.Null
7275	}
7276	res := resTmp.(git.Hash)
7277	rctx.Result = res
7278	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7279	return res
7280}
7281
7282// nolint: vetshadow
7283func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
7284	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7285	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7286	rctx := &graphql.ResolverContext{
7287		Object: "SetStatusTimelineItem",
7288		Args:   nil,
7289		Field:  field,
7290	}
7291	ctx = graphql.WithResolverContext(ctx, rctx)
7292	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7293	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7294		ctx = rctx // use context from middleware stack in children
7295		return obj.Author, nil
7296	})
7297	if resTmp == nil {
7298		if !ec.HasError(rctx) {
7299			ec.Errorf(ctx, "must not be null")
7300		}
7301		return graphql.Null
7302	}
7303	res := resTmp.(identity.Interface)
7304	rctx.Result = res
7305	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7306
7307	return ec._Identity(ctx, field.Selections, &res)
7308}
7309
7310// nolint: vetshadow
7311func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
7312	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7313	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7314	rctx := &graphql.ResolverContext{
7315		Object: "SetStatusTimelineItem",
7316		Args:   nil,
7317		Field:  field,
7318	}
7319	ctx = graphql.WithResolverContext(ctx, rctx)
7320	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7321	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7322		ctx = rctx // use context from middleware stack in children
7323		return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
7324	})
7325	if resTmp == nil {
7326		if !ec.HasError(rctx) {
7327			ec.Errorf(ctx, "must not be null")
7328		}
7329		return graphql.Null
7330	}
7331	res := resTmp.(time.Time)
7332	rctx.Result = res
7333	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7334	return graphql.MarshalTime(res)
7335}
7336
7337// nolint: vetshadow
7338func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
7339	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7340	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7341	rctx := &graphql.ResolverContext{
7342		Object: "SetStatusTimelineItem",
7343		Args:   nil,
7344		Field:  field,
7345	}
7346	ctx = graphql.WithResolverContext(ctx, rctx)
7347	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7348	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7349		ctx = rctx // use context from middleware stack in children
7350		return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
7351	})
7352	if resTmp == nil {
7353		if !ec.HasError(rctx) {
7354			ec.Errorf(ctx, "must not be null")
7355		}
7356		return graphql.Null
7357	}
7358	res := resTmp.(models.Status)
7359	rctx.Result = res
7360	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7361	return res
7362}
7363
7364var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
7365
7366// nolint: gocyclo, errcheck, gas, goconst
7367func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
7368	fields := graphql.CollectFields(ctx, sel, setTitleOperationImplementors)
7369
7370	var wg sync.WaitGroup
7371	out := graphql.NewOrderedMap(len(fields))
7372	invalid := false
7373	for i, field := range fields {
7374		out.Keys[i] = field.Alias
7375
7376		switch field.Name {
7377		case "__typename":
7378			out.Values[i] = graphql.MarshalString("SetTitleOperation")
7379		case "hash":
7380			out.Values[i] = ec._SetTitleOperation_hash(ctx, field, obj)
7381			if out.Values[i] == graphql.Null {
7382				invalid = true
7383			}
7384		case "author":
7385			out.Values[i] = ec._SetTitleOperation_author(ctx, field, obj)
7386			if out.Values[i] == graphql.Null {
7387				invalid = true
7388			}
7389		case "date":
7390			wg.Add(1)
7391			go func(i int, field graphql.CollectedField) {
7392				out.Values[i] = ec._SetTitleOperation_date(ctx, field, obj)
7393				if out.Values[i] == graphql.Null {
7394					invalid = true
7395				}
7396				wg.Done()
7397			}(i, field)
7398		case "title":
7399			out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
7400			if out.Values[i] == graphql.Null {
7401				invalid = true
7402			}
7403		case "was":
7404			out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
7405			if out.Values[i] == graphql.Null {
7406				invalid = true
7407			}
7408		default:
7409			panic("unknown field " + strconv.Quote(field.Name))
7410		}
7411	}
7412	wg.Wait()
7413	if invalid {
7414		return graphql.Null
7415	}
7416	return out
7417}
7418
7419// nolint: vetshadow
7420func (ec *executionContext) _SetTitleOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
7421	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7422	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7423	rctx := &graphql.ResolverContext{
7424		Object: "SetTitleOperation",
7425		Args:   nil,
7426		Field:  field,
7427	}
7428	ctx = graphql.WithResolverContext(ctx, rctx)
7429	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7430	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7431		ctx = rctx // use context from middleware stack in children
7432		return obj.Hash()
7433	})
7434	if resTmp == nil {
7435		if !ec.HasError(rctx) {
7436			ec.Errorf(ctx, "must not be null")
7437		}
7438		return graphql.Null
7439	}
7440	res := resTmp.(git.Hash)
7441	rctx.Result = res
7442	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7443	return res
7444}
7445
7446// nolint: vetshadow
7447func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
7448	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7449	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7450	rctx := &graphql.ResolverContext{
7451		Object: "SetTitleOperation",
7452		Args:   nil,
7453		Field:  field,
7454	}
7455	ctx = graphql.WithResolverContext(ctx, rctx)
7456	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7457	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7458		ctx = rctx // use context from middleware stack in children
7459		return obj.Author, nil
7460	})
7461	if resTmp == nil {
7462		if !ec.HasError(rctx) {
7463			ec.Errorf(ctx, "must not be null")
7464		}
7465		return graphql.Null
7466	}
7467	res := resTmp.(identity.Interface)
7468	rctx.Result = res
7469	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7470
7471	return ec._Identity(ctx, field.Selections, &res)
7472}
7473
7474// nolint: vetshadow
7475func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
7476	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7477	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7478	rctx := &graphql.ResolverContext{
7479		Object: "SetTitleOperation",
7480		Args:   nil,
7481		Field:  field,
7482	}
7483	ctx = graphql.WithResolverContext(ctx, rctx)
7484	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7485	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7486		ctx = rctx // use context from middleware stack in children
7487		return ec.resolvers.SetTitleOperation().Date(rctx, obj)
7488	})
7489	if resTmp == nil {
7490		if !ec.HasError(rctx) {
7491			ec.Errorf(ctx, "must not be null")
7492		}
7493		return graphql.Null
7494	}
7495	res := resTmp.(time.Time)
7496	rctx.Result = res
7497	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7498	return graphql.MarshalTime(res)
7499}
7500
7501// nolint: vetshadow
7502func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
7503	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7504	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7505	rctx := &graphql.ResolverContext{
7506		Object: "SetTitleOperation",
7507		Args:   nil,
7508		Field:  field,
7509	}
7510	ctx = graphql.WithResolverContext(ctx, rctx)
7511	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7512	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7513		ctx = rctx // use context from middleware stack in children
7514		return obj.Title, nil
7515	})
7516	if resTmp == nil {
7517		if !ec.HasError(rctx) {
7518			ec.Errorf(ctx, "must not be null")
7519		}
7520		return graphql.Null
7521	}
7522	res := resTmp.(string)
7523	rctx.Result = res
7524	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7525	return graphql.MarshalString(res)
7526}
7527
7528// nolint: vetshadow
7529func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
7530	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7531	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7532	rctx := &graphql.ResolverContext{
7533		Object: "SetTitleOperation",
7534		Args:   nil,
7535		Field:  field,
7536	}
7537	ctx = graphql.WithResolverContext(ctx, rctx)
7538	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7539	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7540		ctx = rctx // use context from middleware stack in children
7541		return obj.Was, nil
7542	})
7543	if resTmp == nil {
7544		if !ec.HasError(rctx) {
7545			ec.Errorf(ctx, "must not be null")
7546		}
7547		return graphql.Null
7548	}
7549	res := resTmp.(string)
7550	rctx.Result = res
7551	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7552	return graphql.MarshalString(res)
7553}
7554
7555var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem"}
7556
7557// nolint: gocyclo, errcheck, gas, goconst
7558func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
7559	fields := graphql.CollectFields(ctx, sel, setTitleTimelineItemImplementors)
7560
7561	var wg sync.WaitGroup
7562	out := graphql.NewOrderedMap(len(fields))
7563	invalid := false
7564	for i, field := range fields {
7565		out.Keys[i] = field.Alias
7566
7567		switch field.Name {
7568		case "__typename":
7569			out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
7570		case "hash":
7571			out.Values[i] = ec._SetTitleTimelineItem_hash(ctx, field, obj)
7572			if out.Values[i] == graphql.Null {
7573				invalid = true
7574			}
7575		case "author":
7576			out.Values[i] = ec._SetTitleTimelineItem_author(ctx, field, obj)
7577			if out.Values[i] == graphql.Null {
7578				invalid = true
7579			}
7580		case "date":
7581			wg.Add(1)
7582			go func(i int, field graphql.CollectedField) {
7583				out.Values[i] = ec._SetTitleTimelineItem_date(ctx, field, obj)
7584				if out.Values[i] == graphql.Null {
7585					invalid = true
7586				}
7587				wg.Done()
7588			}(i, field)
7589		case "title":
7590			out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
7591			if out.Values[i] == graphql.Null {
7592				invalid = true
7593			}
7594		case "was":
7595			out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
7596			if out.Values[i] == graphql.Null {
7597				invalid = true
7598			}
7599		default:
7600			panic("unknown field " + strconv.Quote(field.Name))
7601		}
7602	}
7603	wg.Wait()
7604	if invalid {
7605		return graphql.Null
7606	}
7607	return out
7608}
7609
7610// nolint: vetshadow
7611func (ec *executionContext) _SetTitleTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
7612	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7613	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7614	rctx := &graphql.ResolverContext{
7615		Object: "SetTitleTimelineItem",
7616		Args:   nil,
7617		Field:  field,
7618	}
7619	ctx = graphql.WithResolverContext(ctx, rctx)
7620	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7621	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7622		ctx = rctx // use context from middleware stack in children
7623		return obj.Hash(), nil
7624	})
7625	if resTmp == nil {
7626		if !ec.HasError(rctx) {
7627			ec.Errorf(ctx, "must not be null")
7628		}
7629		return graphql.Null
7630	}
7631	res := resTmp.(git.Hash)
7632	rctx.Result = res
7633	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7634	return res
7635}
7636
7637// nolint: vetshadow
7638func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
7639	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7640	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7641	rctx := &graphql.ResolverContext{
7642		Object: "SetTitleTimelineItem",
7643		Args:   nil,
7644		Field:  field,
7645	}
7646	ctx = graphql.WithResolverContext(ctx, rctx)
7647	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7648	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7649		ctx = rctx // use context from middleware stack in children
7650		return obj.Author, nil
7651	})
7652	if resTmp == nil {
7653		if !ec.HasError(rctx) {
7654			ec.Errorf(ctx, "must not be null")
7655		}
7656		return graphql.Null
7657	}
7658	res := resTmp.(identity.Interface)
7659	rctx.Result = res
7660	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7661
7662	return ec._Identity(ctx, field.Selections, &res)
7663}
7664
7665// nolint: vetshadow
7666func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
7667	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7668	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7669	rctx := &graphql.ResolverContext{
7670		Object: "SetTitleTimelineItem",
7671		Args:   nil,
7672		Field:  field,
7673	}
7674	ctx = graphql.WithResolverContext(ctx, rctx)
7675	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7676	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7677		ctx = rctx // use context from middleware stack in children
7678		return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
7679	})
7680	if resTmp == nil {
7681		if !ec.HasError(rctx) {
7682			ec.Errorf(ctx, "must not be null")
7683		}
7684		return graphql.Null
7685	}
7686	res := resTmp.(time.Time)
7687	rctx.Result = res
7688	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7689	return graphql.MarshalTime(res)
7690}
7691
7692// nolint: vetshadow
7693func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
7694	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7695	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7696	rctx := &graphql.ResolverContext{
7697		Object: "SetTitleTimelineItem",
7698		Args:   nil,
7699		Field:  field,
7700	}
7701	ctx = graphql.WithResolverContext(ctx, rctx)
7702	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7703	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7704		ctx = rctx // use context from middleware stack in children
7705		return obj.Title, nil
7706	})
7707	if resTmp == nil {
7708		if !ec.HasError(rctx) {
7709			ec.Errorf(ctx, "must not be null")
7710		}
7711		return graphql.Null
7712	}
7713	res := resTmp.(string)
7714	rctx.Result = res
7715	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7716	return graphql.MarshalString(res)
7717}
7718
7719// nolint: vetshadow
7720func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
7721	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7722	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7723	rctx := &graphql.ResolverContext{
7724		Object: "SetTitleTimelineItem",
7725		Args:   nil,
7726		Field:  field,
7727	}
7728	ctx = graphql.WithResolverContext(ctx, rctx)
7729	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7730	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7731		ctx = rctx // use context from middleware stack in children
7732		return obj.Was, nil
7733	})
7734	if resTmp == nil {
7735		if !ec.HasError(rctx) {
7736			ec.Errorf(ctx, "must not be null")
7737		}
7738		return graphql.Null
7739	}
7740	res := resTmp.(string)
7741	rctx.Result = res
7742	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7743	return graphql.MarshalString(res)
7744}
7745
7746var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
7747
7748// nolint: gocyclo, errcheck, gas, goconst
7749func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
7750	fields := graphql.CollectFields(ctx, sel, timelineItemConnectionImplementors)
7751
7752	out := graphql.NewOrderedMap(len(fields))
7753	invalid := false
7754	for i, field := range fields {
7755		out.Keys[i] = field.Alias
7756
7757		switch field.Name {
7758		case "__typename":
7759			out.Values[i] = graphql.MarshalString("TimelineItemConnection")
7760		case "edges":
7761			out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
7762			if out.Values[i] == graphql.Null {
7763				invalid = true
7764			}
7765		case "nodes":
7766			out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
7767			if out.Values[i] == graphql.Null {
7768				invalid = true
7769			}
7770		case "pageInfo":
7771			out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
7772			if out.Values[i] == graphql.Null {
7773				invalid = true
7774			}
7775		case "totalCount":
7776			out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
7777			if out.Values[i] == graphql.Null {
7778				invalid = true
7779			}
7780		default:
7781			panic("unknown field " + strconv.Quote(field.Name))
7782		}
7783	}
7784
7785	if invalid {
7786		return graphql.Null
7787	}
7788	return out
7789}
7790
7791// nolint: vetshadow
7792func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
7793	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7794	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7795	rctx := &graphql.ResolverContext{
7796		Object: "TimelineItemConnection",
7797		Args:   nil,
7798		Field:  field,
7799	}
7800	ctx = graphql.WithResolverContext(ctx, rctx)
7801	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7802	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7803		ctx = rctx // use context from middleware stack in children
7804		return obj.Edges, nil
7805	})
7806	if resTmp == nil {
7807		if !ec.HasError(rctx) {
7808			ec.Errorf(ctx, "must not be null")
7809		}
7810		return graphql.Null
7811	}
7812	res := resTmp.([]models.TimelineItemEdge)
7813	rctx.Result = res
7814	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7815
7816	arr1 := make(graphql.Array, len(res))
7817	var wg sync.WaitGroup
7818
7819	isLen1 := len(res) == 1
7820	if !isLen1 {
7821		wg.Add(len(res))
7822	}
7823
7824	for idx1 := range res {
7825		idx1 := idx1
7826		rctx := &graphql.ResolverContext{
7827			Index:  &idx1,
7828			Result: &res[idx1],
7829		}
7830		ctx := graphql.WithResolverContext(ctx, rctx)
7831		f := func(idx1 int) {
7832			if !isLen1 {
7833				defer wg.Done()
7834			}
7835			arr1[idx1] = func() graphql.Marshaler {
7836
7837				return ec._TimelineItemEdge(ctx, field.Selections, &res[idx1])
7838			}()
7839		}
7840		if isLen1 {
7841			f(idx1)
7842		} else {
7843			go f(idx1)
7844		}
7845
7846	}
7847	wg.Wait()
7848	return arr1
7849}
7850
7851// nolint: vetshadow
7852func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
7853	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7854	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7855	rctx := &graphql.ResolverContext{
7856		Object: "TimelineItemConnection",
7857		Args:   nil,
7858		Field:  field,
7859	}
7860	ctx = graphql.WithResolverContext(ctx, rctx)
7861	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7862	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7863		ctx = rctx // use context from middleware stack in children
7864		return obj.Nodes, nil
7865	})
7866	if resTmp == nil {
7867		if !ec.HasError(rctx) {
7868			ec.Errorf(ctx, "must not be null")
7869		}
7870		return graphql.Null
7871	}
7872	res := resTmp.([]bug.TimelineItem)
7873	rctx.Result = res
7874	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7875
7876	arr1 := make(graphql.Array, len(res))
7877	var wg sync.WaitGroup
7878
7879	isLen1 := len(res) == 1
7880	if !isLen1 {
7881		wg.Add(len(res))
7882	}
7883
7884	for idx1 := range res {
7885		idx1 := idx1
7886		rctx := &graphql.ResolverContext{
7887			Index:  &idx1,
7888			Result: &res[idx1],
7889		}
7890		ctx := graphql.WithResolverContext(ctx, rctx)
7891		f := func(idx1 int) {
7892			if !isLen1 {
7893				defer wg.Done()
7894			}
7895			arr1[idx1] = func() graphql.Marshaler {
7896
7897				return ec._TimelineItem(ctx, field.Selections, &res[idx1])
7898			}()
7899		}
7900		if isLen1 {
7901			f(idx1)
7902		} else {
7903			go f(idx1)
7904		}
7905
7906	}
7907	wg.Wait()
7908	return arr1
7909}
7910
7911// nolint: vetshadow
7912func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
7913	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7914	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7915	rctx := &graphql.ResolverContext{
7916		Object: "TimelineItemConnection",
7917		Args:   nil,
7918		Field:  field,
7919	}
7920	ctx = graphql.WithResolverContext(ctx, rctx)
7921	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7922	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7923		ctx = rctx // use context from middleware stack in children
7924		return obj.PageInfo, nil
7925	})
7926	if resTmp == nil {
7927		if !ec.HasError(rctx) {
7928			ec.Errorf(ctx, "must not be null")
7929		}
7930		return graphql.Null
7931	}
7932	res := resTmp.(models.PageInfo)
7933	rctx.Result = res
7934	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7935
7936	return ec._PageInfo(ctx, field.Selections, &res)
7937}
7938
7939// nolint: vetshadow
7940func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
7941	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7942	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7943	rctx := &graphql.ResolverContext{
7944		Object: "TimelineItemConnection",
7945		Args:   nil,
7946		Field:  field,
7947	}
7948	ctx = graphql.WithResolverContext(ctx, rctx)
7949	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7950	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7951		ctx = rctx // use context from middleware stack in children
7952		return obj.TotalCount, nil
7953	})
7954	if resTmp == nil {
7955		if !ec.HasError(rctx) {
7956			ec.Errorf(ctx, "must not be null")
7957		}
7958		return graphql.Null
7959	}
7960	res := resTmp.(int)
7961	rctx.Result = res
7962	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7963	return graphql.MarshalInt(res)
7964}
7965
7966var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
7967
7968// nolint: gocyclo, errcheck, gas, goconst
7969func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
7970	fields := graphql.CollectFields(ctx, sel, timelineItemEdgeImplementors)
7971
7972	out := graphql.NewOrderedMap(len(fields))
7973	invalid := false
7974	for i, field := range fields {
7975		out.Keys[i] = field.Alias
7976
7977		switch field.Name {
7978		case "__typename":
7979			out.Values[i] = graphql.MarshalString("TimelineItemEdge")
7980		case "cursor":
7981			out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
7982			if out.Values[i] == graphql.Null {
7983				invalid = true
7984			}
7985		case "node":
7986			out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
7987			if out.Values[i] == graphql.Null {
7988				invalid = true
7989			}
7990		default:
7991			panic("unknown field " + strconv.Quote(field.Name))
7992		}
7993	}
7994
7995	if invalid {
7996		return graphql.Null
7997	}
7998	return out
7999}
8000
8001// nolint: vetshadow
8002func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) graphql.Marshaler {
8003	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8004	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8005	rctx := &graphql.ResolverContext{
8006		Object: "TimelineItemEdge",
8007		Args:   nil,
8008		Field:  field,
8009	}
8010	ctx = graphql.WithResolverContext(ctx, rctx)
8011	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8012	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8013		ctx = rctx // use context from middleware stack in children
8014		return obj.Cursor, nil
8015	})
8016	if resTmp == nil {
8017		if !ec.HasError(rctx) {
8018			ec.Errorf(ctx, "must not be null")
8019		}
8020		return graphql.Null
8021	}
8022	res := resTmp.(string)
8023	rctx.Result = res
8024	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8025	return graphql.MarshalString(res)
8026}
8027
8028// nolint: vetshadow
8029func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) graphql.Marshaler {
8030	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8031	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8032	rctx := &graphql.ResolverContext{
8033		Object: "TimelineItemEdge",
8034		Args:   nil,
8035		Field:  field,
8036	}
8037	ctx = graphql.WithResolverContext(ctx, rctx)
8038	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8039	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8040		ctx = rctx // use context from middleware stack in children
8041		return obj.Node, nil
8042	})
8043	if resTmp == nil {
8044		if !ec.HasError(rctx) {
8045			ec.Errorf(ctx, "must not be null")
8046		}
8047		return graphql.Null
8048	}
8049	res := resTmp.(bug.TimelineItem)
8050	rctx.Result = res
8051	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8052
8053	return ec._TimelineItem(ctx, field.Selections, &res)
8054}
8055
8056var __DirectiveImplementors = []string{"__Directive"}
8057
8058// nolint: gocyclo, errcheck, gas, goconst
8059func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
8060	fields := graphql.CollectFields(ctx, sel, __DirectiveImplementors)
8061
8062	out := graphql.NewOrderedMap(len(fields))
8063	invalid := false
8064	for i, field := range fields {
8065		out.Keys[i] = field.Alias
8066
8067		switch field.Name {
8068		case "__typename":
8069			out.Values[i] = graphql.MarshalString("__Directive")
8070		case "name":
8071			out.Values[i] = ec.___Directive_name(ctx, field, obj)
8072			if out.Values[i] == graphql.Null {
8073				invalid = true
8074			}
8075		case "description":
8076			out.Values[i] = ec.___Directive_description(ctx, field, obj)
8077		case "locations":
8078			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
8079			if out.Values[i] == graphql.Null {
8080				invalid = true
8081			}
8082		case "args":
8083			out.Values[i] = ec.___Directive_args(ctx, field, obj)
8084			if out.Values[i] == graphql.Null {
8085				invalid = true
8086			}
8087		default:
8088			panic("unknown field " + strconv.Quote(field.Name))
8089		}
8090	}
8091
8092	if invalid {
8093		return graphql.Null
8094	}
8095	return out
8096}
8097
8098// nolint: vetshadow
8099func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
8100	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8101	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8102	rctx := &graphql.ResolverContext{
8103		Object: "__Directive",
8104		Args:   nil,
8105		Field:  field,
8106	}
8107	ctx = graphql.WithResolverContext(ctx, rctx)
8108	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8109	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8110		ctx = rctx // use context from middleware stack in children
8111		return obj.Name, nil
8112	})
8113	if resTmp == nil {
8114		if !ec.HasError(rctx) {
8115			ec.Errorf(ctx, "must not be null")
8116		}
8117		return graphql.Null
8118	}
8119	res := resTmp.(string)
8120	rctx.Result = res
8121	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8122	return graphql.MarshalString(res)
8123}
8124
8125// nolint: vetshadow
8126func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
8127	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8128	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8129	rctx := &graphql.ResolverContext{
8130		Object: "__Directive",
8131		Args:   nil,
8132		Field:  field,
8133	}
8134	ctx = graphql.WithResolverContext(ctx, rctx)
8135	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8136	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8137		ctx = rctx // use context from middleware stack in children
8138		return obj.Description, nil
8139	})
8140	if resTmp == nil {
8141		return graphql.Null
8142	}
8143	res := resTmp.(string)
8144	rctx.Result = res
8145	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8146	return graphql.MarshalString(res)
8147}
8148
8149// nolint: vetshadow
8150func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
8151	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8152	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8153	rctx := &graphql.ResolverContext{
8154		Object: "__Directive",
8155		Args:   nil,
8156		Field:  field,
8157	}
8158	ctx = graphql.WithResolverContext(ctx, rctx)
8159	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8160	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8161		ctx = rctx // use context from middleware stack in children
8162		return obj.Locations, nil
8163	})
8164	if resTmp == nil {
8165		if !ec.HasError(rctx) {
8166			ec.Errorf(ctx, "must not be null")
8167		}
8168		return graphql.Null
8169	}
8170	res := resTmp.([]string)
8171	rctx.Result = res
8172	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8173
8174	arr1 := make(graphql.Array, len(res))
8175
8176	for idx1 := range res {
8177		arr1[idx1] = func() graphql.Marshaler {
8178			return graphql.MarshalString(res[idx1])
8179		}()
8180	}
8181
8182	return arr1
8183}
8184
8185// nolint: vetshadow
8186func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
8187	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8188	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8189	rctx := &graphql.ResolverContext{
8190		Object: "__Directive",
8191		Args:   nil,
8192		Field:  field,
8193	}
8194	ctx = graphql.WithResolverContext(ctx, rctx)
8195	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8196	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8197		ctx = rctx // use context from middleware stack in children
8198		return obj.Args, nil
8199	})
8200	if resTmp == nil {
8201		if !ec.HasError(rctx) {
8202			ec.Errorf(ctx, "must not be null")
8203		}
8204		return graphql.Null
8205	}
8206	res := resTmp.([]introspection.InputValue)
8207	rctx.Result = res
8208	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8209
8210	arr1 := make(graphql.Array, len(res))
8211	var wg sync.WaitGroup
8212
8213	isLen1 := len(res) == 1
8214	if !isLen1 {
8215		wg.Add(len(res))
8216	}
8217
8218	for idx1 := range res {
8219		idx1 := idx1
8220		rctx := &graphql.ResolverContext{
8221			Index:  &idx1,
8222			Result: &res[idx1],
8223		}
8224		ctx := graphql.WithResolverContext(ctx, rctx)
8225		f := func(idx1 int) {
8226			if !isLen1 {
8227				defer wg.Done()
8228			}
8229			arr1[idx1] = func() graphql.Marshaler {
8230
8231				return ec.___InputValue(ctx, field.Selections, &res[idx1])
8232			}()
8233		}
8234		if isLen1 {
8235			f(idx1)
8236		} else {
8237			go f(idx1)
8238		}
8239
8240	}
8241	wg.Wait()
8242	return arr1
8243}
8244
8245var __EnumValueImplementors = []string{"__EnumValue"}
8246
8247// nolint: gocyclo, errcheck, gas, goconst
8248func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
8249	fields := graphql.CollectFields(ctx, sel, __EnumValueImplementors)
8250
8251	out := graphql.NewOrderedMap(len(fields))
8252	invalid := false
8253	for i, field := range fields {
8254		out.Keys[i] = field.Alias
8255
8256		switch field.Name {
8257		case "__typename":
8258			out.Values[i] = graphql.MarshalString("__EnumValue")
8259		case "name":
8260			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
8261			if out.Values[i] == graphql.Null {
8262				invalid = true
8263			}
8264		case "description":
8265			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
8266		case "isDeprecated":
8267			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
8268			if out.Values[i] == graphql.Null {
8269				invalid = true
8270			}
8271		case "deprecationReason":
8272			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
8273		default:
8274			panic("unknown field " + strconv.Quote(field.Name))
8275		}
8276	}
8277
8278	if invalid {
8279		return graphql.Null
8280	}
8281	return out
8282}
8283
8284// nolint: vetshadow
8285func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
8286	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8287	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8288	rctx := &graphql.ResolverContext{
8289		Object: "__EnumValue",
8290		Args:   nil,
8291		Field:  field,
8292	}
8293	ctx = graphql.WithResolverContext(ctx, rctx)
8294	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8295	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8296		ctx = rctx // use context from middleware stack in children
8297		return obj.Name, nil
8298	})
8299	if resTmp == nil {
8300		if !ec.HasError(rctx) {
8301			ec.Errorf(ctx, "must not be null")
8302		}
8303		return graphql.Null
8304	}
8305	res := resTmp.(string)
8306	rctx.Result = res
8307	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8308	return graphql.MarshalString(res)
8309}
8310
8311// nolint: vetshadow
8312func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
8313	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8314	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8315	rctx := &graphql.ResolverContext{
8316		Object: "__EnumValue",
8317		Args:   nil,
8318		Field:  field,
8319	}
8320	ctx = graphql.WithResolverContext(ctx, rctx)
8321	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8322	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8323		ctx = rctx // use context from middleware stack in children
8324		return obj.Description, nil
8325	})
8326	if resTmp == nil {
8327		return graphql.Null
8328	}
8329	res := resTmp.(string)
8330	rctx.Result = res
8331	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8332	return graphql.MarshalString(res)
8333}
8334
8335// nolint: vetshadow
8336func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
8337	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8338	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8339	rctx := &graphql.ResolverContext{
8340		Object: "__EnumValue",
8341		Args:   nil,
8342		Field:  field,
8343	}
8344	ctx = graphql.WithResolverContext(ctx, rctx)
8345	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8346	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8347		ctx = rctx // use context from middleware stack in children
8348		return obj.IsDeprecated(), nil
8349	})
8350	if resTmp == nil {
8351		if !ec.HasError(rctx) {
8352			ec.Errorf(ctx, "must not be null")
8353		}
8354		return graphql.Null
8355	}
8356	res := resTmp.(bool)
8357	rctx.Result = res
8358	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8359	return graphql.MarshalBoolean(res)
8360}
8361
8362// nolint: vetshadow
8363func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
8364	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8365	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8366	rctx := &graphql.ResolverContext{
8367		Object: "__EnumValue",
8368		Args:   nil,
8369		Field:  field,
8370	}
8371	ctx = graphql.WithResolverContext(ctx, rctx)
8372	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8373	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8374		ctx = rctx // use context from middleware stack in children
8375		return obj.DeprecationReason(), nil
8376	})
8377	if resTmp == nil {
8378		return graphql.Null
8379	}
8380	res := resTmp.(*string)
8381	rctx.Result = res
8382	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8383
8384	if res == nil {
8385		return graphql.Null
8386	}
8387	return graphql.MarshalString(*res)
8388}
8389
8390var __FieldImplementors = []string{"__Field"}
8391
8392// nolint: gocyclo, errcheck, gas, goconst
8393func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
8394	fields := graphql.CollectFields(ctx, sel, __FieldImplementors)
8395
8396	out := graphql.NewOrderedMap(len(fields))
8397	invalid := false
8398	for i, field := range fields {
8399		out.Keys[i] = field.Alias
8400
8401		switch field.Name {
8402		case "__typename":
8403			out.Values[i] = graphql.MarshalString("__Field")
8404		case "name":
8405			out.Values[i] = ec.___Field_name(ctx, field, obj)
8406			if out.Values[i] == graphql.Null {
8407				invalid = true
8408			}
8409		case "description":
8410			out.Values[i] = ec.___Field_description(ctx, field, obj)
8411		case "args":
8412			out.Values[i] = ec.___Field_args(ctx, field, obj)
8413			if out.Values[i] == graphql.Null {
8414				invalid = true
8415			}
8416		case "type":
8417			out.Values[i] = ec.___Field_type(ctx, field, obj)
8418			if out.Values[i] == graphql.Null {
8419				invalid = true
8420			}
8421		case "isDeprecated":
8422			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
8423			if out.Values[i] == graphql.Null {
8424				invalid = true
8425			}
8426		case "deprecationReason":
8427			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
8428		default:
8429			panic("unknown field " + strconv.Quote(field.Name))
8430		}
8431	}
8432
8433	if invalid {
8434		return graphql.Null
8435	}
8436	return out
8437}
8438
8439// nolint: vetshadow
8440func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
8441	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8442	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8443	rctx := &graphql.ResolverContext{
8444		Object: "__Field",
8445		Args:   nil,
8446		Field:  field,
8447	}
8448	ctx = graphql.WithResolverContext(ctx, rctx)
8449	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8450	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8451		ctx = rctx // use context from middleware stack in children
8452		return obj.Name, nil
8453	})
8454	if resTmp == nil {
8455		if !ec.HasError(rctx) {
8456			ec.Errorf(ctx, "must not be null")
8457		}
8458		return graphql.Null
8459	}
8460	res := resTmp.(string)
8461	rctx.Result = res
8462	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8463	return graphql.MarshalString(res)
8464}
8465
8466// nolint: vetshadow
8467func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
8468	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8469	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8470	rctx := &graphql.ResolverContext{
8471		Object: "__Field",
8472		Args:   nil,
8473		Field:  field,
8474	}
8475	ctx = graphql.WithResolverContext(ctx, rctx)
8476	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8477	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8478		ctx = rctx // use context from middleware stack in children
8479		return obj.Description, nil
8480	})
8481	if resTmp == nil {
8482		return graphql.Null
8483	}
8484	res := resTmp.(string)
8485	rctx.Result = res
8486	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8487	return graphql.MarshalString(res)
8488}
8489
8490// nolint: vetshadow
8491func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
8492	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8493	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8494	rctx := &graphql.ResolverContext{
8495		Object: "__Field",
8496		Args:   nil,
8497		Field:  field,
8498	}
8499	ctx = graphql.WithResolverContext(ctx, rctx)
8500	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8501	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8502		ctx = rctx // use context from middleware stack in children
8503		return obj.Args, nil
8504	})
8505	if resTmp == nil {
8506		if !ec.HasError(rctx) {
8507			ec.Errorf(ctx, "must not be null")
8508		}
8509		return graphql.Null
8510	}
8511	res := resTmp.([]introspection.InputValue)
8512	rctx.Result = res
8513	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8514
8515	arr1 := make(graphql.Array, len(res))
8516	var wg sync.WaitGroup
8517
8518	isLen1 := len(res) == 1
8519	if !isLen1 {
8520		wg.Add(len(res))
8521	}
8522
8523	for idx1 := range res {
8524		idx1 := idx1
8525		rctx := &graphql.ResolverContext{
8526			Index:  &idx1,
8527			Result: &res[idx1],
8528		}
8529		ctx := graphql.WithResolverContext(ctx, rctx)
8530		f := func(idx1 int) {
8531			if !isLen1 {
8532				defer wg.Done()
8533			}
8534			arr1[idx1] = func() graphql.Marshaler {
8535
8536				return ec.___InputValue(ctx, field.Selections, &res[idx1])
8537			}()
8538		}
8539		if isLen1 {
8540			f(idx1)
8541		} else {
8542			go f(idx1)
8543		}
8544
8545	}
8546	wg.Wait()
8547	return arr1
8548}
8549
8550// nolint: vetshadow
8551func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
8552	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8553	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8554	rctx := &graphql.ResolverContext{
8555		Object: "__Field",
8556		Args:   nil,
8557		Field:  field,
8558	}
8559	ctx = graphql.WithResolverContext(ctx, rctx)
8560	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8561	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8562		ctx = rctx // use context from middleware stack in children
8563		return obj.Type, nil
8564	})
8565	if resTmp == nil {
8566		if !ec.HasError(rctx) {
8567			ec.Errorf(ctx, "must not be null")
8568		}
8569		return graphql.Null
8570	}
8571	res := resTmp.(*introspection.Type)
8572	rctx.Result = res
8573	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8574
8575	if res == nil {
8576		if !ec.HasError(rctx) {
8577			ec.Errorf(ctx, "must not be null")
8578		}
8579		return graphql.Null
8580	}
8581
8582	return ec.___Type(ctx, field.Selections, res)
8583}
8584
8585// nolint: vetshadow
8586func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
8587	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8588	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8589	rctx := &graphql.ResolverContext{
8590		Object: "__Field",
8591		Args:   nil,
8592		Field:  field,
8593	}
8594	ctx = graphql.WithResolverContext(ctx, rctx)
8595	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8596	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8597		ctx = rctx // use context from middleware stack in children
8598		return obj.IsDeprecated(), nil
8599	})
8600	if resTmp == nil {
8601		if !ec.HasError(rctx) {
8602			ec.Errorf(ctx, "must not be null")
8603		}
8604		return graphql.Null
8605	}
8606	res := resTmp.(bool)
8607	rctx.Result = res
8608	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8609	return graphql.MarshalBoolean(res)
8610}
8611
8612// nolint: vetshadow
8613func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
8614	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8615	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8616	rctx := &graphql.ResolverContext{
8617		Object: "__Field",
8618		Args:   nil,
8619		Field:  field,
8620	}
8621	ctx = graphql.WithResolverContext(ctx, rctx)
8622	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8623	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8624		ctx = rctx // use context from middleware stack in children
8625		return obj.DeprecationReason(), nil
8626	})
8627	if resTmp == nil {
8628		return graphql.Null
8629	}
8630	res := resTmp.(*string)
8631	rctx.Result = res
8632	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8633
8634	if res == nil {
8635		return graphql.Null
8636	}
8637	return graphql.MarshalString(*res)
8638}
8639
8640var __InputValueImplementors = []string{"__InputValue"}
8641
8642// nolint: gocyclo, errcheck, gas, goconst
8643func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
8644	fields := graphql.CollectFields(ctx, sel, __InputValueImplementors)
8645
8646	out := graphql.NewOrderedMap(len(fields))
8647	invalid := false
8648	for i, field := range fields {
8649		out.Keys[i] = field.Alias
8650
8651		switch field.Name {
8652		case "__typename":
8653			out.Values[i] = graphql.MarshalString("__InputValue")
8654		case "name":
8655			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
8656			if out.Values[i] == graphql.Null {
8657				invalid = true
8658			}
8659		case "description":
8660			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
8661		case "type":
8662			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
8663			if out.Values[i] == graphql.Null {
8664				invalid = true
8665			}
8666		case "defaultValue":
8667			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
8668		default:
8669			panic("unknown field " + strconv.Quote(field.Name))
8670		}
8671	}
8672
8673	if invalid {
8674		return graphql.Null
8675	}
8676	return out
8677}
8678
8679// nolint: vetshadow
8680func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
8681	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8682	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8683	rctx := &graphql.ResolverContext{
8684		Object: "__InputValue",
8685		Args:   nil,
8686		Field:  field,
8687	}
8688	ctx = graphql.WithResolverContext(ctx, rctx)
8689	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8690	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8691		ctx = rctx // use context from middleware stack in children
8692		return obj.Name, nil
8693	})
8694	if resTmp == nil {
8695		if !ec.HasError(rctx) {
8696			ec.Errorf(ctx, "must not be null")
8697		}
8698		return graphql.Null
8699	}
8700	res := resTmp.(string)
8701	rctx.Result = res
8702	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8703	return graphql.MarshalString(res)
8704}
8705
8706// nolint: vetshadow
8707func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
8708	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8709	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8710	rctx := &graphql.ResolverContext{
8711		Object: "__InputValue",
8712		Args:   nil,
8713		Field:  field,
8714	}
8715	ctx = graphql.WithResolverContext(ctx, rctx)
8716	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8717	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8718		ctx = rctx // use context from middleware stack in children
8719		return obj.Description, nil
8720	})
8721	if resTmp == nil {
8722		return graphql.Null
8723	}
8724	res := resTmp.(string)
8725	rctx.Result = res
8726	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8727	return graphql.MarshalString(res)
8728}
8729
8730// nolint: vetshadow
8731func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
8732	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8733	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8734	rctx := &graphql.ResolverContext{
8735		Object: "__InputValue",
8736		Args:   nil,
8737		Field:  field,
8738	}
8739	ctx = graphql.WithResolverContext(ctx, rctx)
8740	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8741	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8742		ctx = rctx // use context from middleware stack in children
8743		return obj.Type, nil
8744	})
8745	if resTmp == nil {
8746		if !ec.HasError(rctx) {
8747			ec.Errorf(ctx, "must not be null")
8748		}
8749		return graphql.Null
8750	}
8751	res := resTmp.(*introspection.Type)
8752	rctx.Result = res
8753	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8754
8755	if res == nil {
8756		if !ec.HasError(rctx) {
8757			ec.Errorf(ctx, "must not be null")
8758		}
8759		return graphql.Null
8760	}
8761
8762	return ec.___Type(ctx, field.Selections, res)
8763}
8764
8765// nolint: vetshadow
8766func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
8767	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8768	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8769	rctx := &graphql.ResolverContext{
8770		Object: "__InputValue",
8771		Args:   nil,
8772		Field:  field,
8773	}
8774	ctx = graphql.WithResolverContext(ctx, rctx)
8775	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8776	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8777		ctx = rctx // use context from middleware stack in children
8778		return obj.DefaultValue, nil
8779	})
8780	if resTmp == nil {
8781		return graphql.Null
8782	}
8783	res := resTmp.(*string)
8784	rctx.Result = res
8785	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8786
8787	if res == nil {
8788		return graphql.Null
8789	}
8790	return graphql.MarshalString(*res)
8791}
8792
8793var __SchemaImplementors = []string{"__Schema"}
8794
8795// nolint: gocyclo, errcheck, gas, goconst
8796func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
8797	fields := graphql.CollectFields(ctx, sel, __SchemaImplementors)
8798
8799	out := graphql.NewOrderedMap(len(fields))
8800	invalid := false
8801	for i, field := range fields {
8802		out.Keys[i] = field.Alias
8803
8804		switch field.Name {
8805		case "__typename":
8806			out.Values[i] = graphql.MarshalString("__Schema")
8807		case "types":
8808			out.Values[i] = ec.___Schema_types(ctx, field, obj)
8809			if out.Values[i] == graphql.Null {
8810				invalid = true
8811			}
8812		case "queryType":
8813			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
8814			if out.Values[i] == graphql.Null {
8815				invalid = true
8816			}
8817		case "mutationType":
8818			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
8819		case "subscriptionType":
8820			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
8821		case "directives":
8822			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
8823			if out.Values[i] == graphql.Null {
8824				invalid = true
8825			}
8826		default:
8827			panic("unknown field " + strconv.Quote(field.Name))
8828		}
8829	}
8830
8831	if invalid {
8832		return graphql.Null
8833	}
8834	return out
8835}
8836
8837// nolint: vetshadow
8838func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
8839	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8840	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8841	rctx := &graphql.ResolverContext{
8842		Object: "__Schema",
8843		Args:   nil,
8844		Field:  field,
8845	}
8846	ctx = graphql.WithResolverContext(ctx, rctx)
8847	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8848	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8849		ctx = rctx // use context from middleware stack in children
8850		return obj.Types(), nil
8851	})
8852	if resTmp == nil {
8853		if !ec.HasError(rctx) {
8854			ec.Errorf(ctx, "must not be null")
8855		}
8856		return graphql.Null
8857	}
8858	res := resTmp.([]introspection.Type)
8859	rctx.Result = res
8860	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8861
8862	arr1 := make(graphql.Array, len(res))
8863	var wg sync.WaitGroup
8864
8865	isLen1 := len(res) == 1
8866	if !isLen1 {
8867		wg.Add(len(res))
8868	}
8869
8870	for idx1 := range res {
8871		idx1 := idx1
8872		rctx := &graphql.ResolverContext{
8873			Index:  &idx1,
8874			Result: &res[idx1],
8875		}
8876		ctx := graphql.WithResolverContext(ctx, rctx)
8877		f := func(idx1 int) {
8878			if !isLen1 {
8879				defer wg.Done()
8880			}
8881			arr1[idx1] = func() graphql.Marshaler {
8882
8883				return ec.___Type(ctx, field.Selections, &res[idx1])
8884			}()
8885		}
8886		if isLen1 {
8887			f(idx1)
8888		} else {
8889			go f(idx1)
8890		}
8891
8892	}
8893	wg.Wait()
8894	return arr1
8895}
8896
8897// nolint: vetshadow
8898func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
8899	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8900	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8901	rctx := &graphql.ResolverContext{
8902		Object: "__Schema",
8903		Args:   nil,
8904		Field:  field,
8905	}
8906	ctx = graphql.WithResolverContext(ctx, rctx)
8907	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8908	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8909		ctx = rctx // use context from middleware stack in children
8910		return obj.QueryType(), nil
8911	})
8912	if resTmp == nil {
8913		if !ec.HasError(rctx) {
8914			ec.Errorf(ctx, "must not be null")
8915		}
8916		return graphql.Null
8917	}
8918	res := resTmp.(*introspection.Type)
8919	rctx.Result = res
8920	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8921
8922	if res == nil {
8923		if !ec.HasError(rctx) {
8924			ec.Errorf(ctx, "must not be null")
8925		}
8926		return graphql.Null
8927	}
8928
8929	return ec.___Type(ctx, field.Selections, res)
8930}
8931
8932// nolint: vetshadow
8933func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
8934	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8935	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8936	rctx := &graphql.ResolverContext{
8937		Object: "__Schema",
8938		Args:   nil,
8939		Field:  field,
8940	}
8941	ctx = graphql.WithResolverContext(ctx, rctx)
8942	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8943	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8944		ctx = rctx // use context from middleware stack in children
8945		return obj.MutationType(), nil
8946	})
8947	if resTmp == nil {
8948		return graphql.Null
8949	}
8950	res := resTmp.(*introspection.Type)
8951	rctx.Result = res
8952	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8953
8954	if res == nil {
8955		return graphql.Null
8956	}
8957
8958	return ec.___Type(ctx, field.Selections, res)
8959}
8960
8961// nolint: vetshadow
8962func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
8963	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8964	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8965	rctx := &graphql.ResolverContext{
8966		Object: "__Schema",
8967		Args:   nil,
8968		Field:  field,
8969	}
8970	ctx = graphql.WithResolverContext(ctx, rctx)
8971	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8972	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8973		ctx = rctx // use context from middleware stack in children
8974		return obj.SubscriptionType(), nil
8975	})
8976	if resTmp == nil {
8977		return graphql.Null
8978	}
8979	res := resTmp.(*introspection.Type)
8980	rctx.Result = res
8981	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8982
8983	if res == nil {
8984		return graphql.Null
8985	}
8986
8987	return ec.___Type(ctx, field.Selections, res)
8988}
8989
8990// nolint: vetshadow
8991func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
8992	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8993	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8994	rctx := &graphql.ResolverContext{
8995		Object: "__Schema",
8996		Args:   nil,
8997		Field:  field,
8998	}
8999	ctx = graphql.WithResolverContext(ctx, rctx)
9000	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9001	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
9002		ctx = rctx // use context from middleware stack in children
9003		return obj.Directives(), nil
9004	})
9005	if resTmp == nil {
9006		if !ec.HasError(rctx) {
9007			ec.Errorf(ctx, "must not be null")
9008		}
9009		return graphql.Null
9010	}
9011	res := resTmp.([]introspection.Directive)
9012	rctx.Result = res
9013	ctx = ec.Tracer.StartFieldChildExecution(ctx)
9014
9015	arr1 := make(graphql.Array, len(res))
9016	var wg sync.WaitGroup
9017
9018	isLen1 := len(res) == 1
9019	if !isLen1 {
9020		wg.Add(len(res))
9021	}
9022
9023	for idx1 := range res {
9024		idx1 := idx1
9025		rctx := &graphql.ResolverContext{
9026			Index:  &idx1,
9027			Result: &res[idx1],
9028		}
9029		ctx := graphql.WithResolverContext(ctx, rctx)
9030		f := func(idx1 int) {
9031			if !isLen1 {
9032				defer wg.Done()
9033			}
9034			arr1[idx1] = func() graphql.Marshaler {
9035
9036				return ec.___Directive(ctx, field.Selections, &res[idx1])
9037			}()
9038		}
9039		if isLen1 {
9040			f(idx1)
9041		} else {
9042			go f(idx1)
9043		}
9044
9045	}
9046	wg.Wait()
9047	return arr1
9048}
9049
9050var __TypeImplementors = []string{"__Type"}
9051
9052// nolint: gocyclo, errcheck, gas, goconst
9053func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
9054	fields := graphql.CollectFields(ctx, sel, __TypeImplementors)
9055
9056	out := graphql.NewOrderedMap(len(fields))
9057	invalid := false
9058	for i, field := range fields {
9059		out.Keys[i] = field.Alias
9060
9061		switch field.Name {
9062		case "__typename":
9063			out.Values[i] = graphql.MarshalString("__Type")
9064		case "kind":
9065			out.Values[i] = ec.___Type_kind(ctx, field, obj)
9066			if out.Values[i] == graphql.Null {
9067				invalid = true
9068			}
9069		case "name":
9070			out.Values[i] = ec.___Type_name(ctx, field, obj)
9071		case "description":
9072			out.Values[i] = ec.___Type_description(ctx, field, obj)
9073		case "fields":
9074			out.Values[i] = ec.___Type_fields(ctx, field, obj)
9075		case "interfaces":
9076			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
9077		case "possibleTypes":
9078			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
9079		case "enumValues":
9080			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
9081		case "inputFields":
9082			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
9083		case "ofType":
9084			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
9085		default:
9086			panic("unknown field " + strconv.Quote(field.Name))
9087		}
9088	}
9089
9090	if invalid {
9091		return graphql.Null
9092	}
9093	return out
9094}
9095
9096// nolint: vetshadow
9097func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
9098	ctx = ec.Tracer.StartFieldExecution(ctx, field)
9099	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
9100	rctx := &graphql.ResolverContext{
9101		Object: "__Type",
9102		Args:   nil,
9103		Field:  field,
9104	}
9105	ctx = graphql.WithResolverContext(ctx, rctx)
9106	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9107	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
9108		ctx = rctx // use context from middleware stack in children
9109		return obj.Kind(), nil
9110	})
9111	if resTmp == nil {
9112		if !ec.HasError(rctx) {
9113			ec.Errorf(ctx, "must not be null")
9114		}
9115		return graphql.Null
9116	}
9117	res := resTmp.(string)
9118	rctx.Result = res
9119	ctx = ec.Tracer.StartFieldChildExecution(ctx)
9120	return graphql.MarshalString(res)
9121}
9122
9123// nolint: vetshadow
9124func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
9125	ctx = ec.Tracer.StartFieldExecution(ctx, field)
9126	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
9127	rctx := &graphql.ResolverContext{
9128		Object: "__Type",
9129		Args:   nil,
9130		Field:  field,
9131	}
9132	ctx = graphql.WithResolverContext(ctx, rctx)
9133	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9134	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
9135		ctx = rctx // use context from middleware stack in children
9136		return obj.Name(), nil
9137	})
9138	if resTmp == nil {
9139		return graphql.Null
9140	}
9141	res := resTmp.(*string)
9142	rctx.Result = res
9143	ctx = ec.Tracer.StartFieldChildExecution(ctx)
9144
9145	if res == nil {
9146		return graphql.Null
9147	}
9148	return graphql.MarshalString(*res)
9149}
9150
9151// nolint: vetshadow
9152func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
9153	ctx = ec.Tracer.StartFieldExecution(ctx, field)
9154	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
9155	rctx := &graphql.ResolverContext{
9156		Object: "__Type",
9157		Args:   nil,
9158		Field:  field,
9159	}
9160	ctx = graphql.WithResolverContext(ctx, rctx)
9161	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9162	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
9163		ctx = rctx // use context from middleware stack in children
9164		return obj.Description(), nil
9165	})
9166	if resTmp == nil {
9167		return graphql.Null
9168	}
9169	res := resTmp.(string)
9170	rctx.Result = res
9171	ctx = ec.Tracer.StartFieldChildExecution(ctx)
9172	return graphql.MarshalString(res)
9173}
9174
9175// nolint: vetshadow
9176func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
9177	ctx = ec.Tracer.StartFieldExecution(ctx, field)
9178	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
9179	rawArgs := field.ArgumentMap(ec.Variables)
9180	args, err := field___Type_fields_args(rawArgs)
9181	if err != nil {
9182		ec.Error(ctx, err)
9183		return graphql.Null
9184	}
9185	rctx := &graphql.ResolverContext{
9186		Object: "__Type",
9187		Args:   args,
9188		Field:  field,
9189	}
9190	ctx = graphql.WithResolverContext(ctx, rctx)
9191	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9192	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
9193		ctx = rctx // use context from middleware stack in children
9194		return obj.Fields(args["includeDeprecated"].(bool)), nil
9195	})
9196	if resTmp == nil {
9197		return graphql.Null
9198	}
9199	res := resTmp.([]introspection.Field)
9200	rctx.Result = res
9201	ctx = ec.Tracer.StartFieldChildExecution(ctx)
9202
9203	arr1 := make(graphql.Array, len(res))
9204	var wg sync.WaitGroup
9205
9206	isLen1 := len(res) == 1
9207	if !isLen1 {
9208		wg.Add(len(res))
9209	}
9210
9211	for idx1 := range res {
9212		idx1 := idx1
9213		rctx := &graphql.ResolverContext{
9214			Index:  &idx1,
9215			Result: &res[idx1],
9216		}
9217		ctx := graphql.WithResolverContext(ctx, rctx)
9218		f := func(idx1 int) {
9219			if !isLen1 {
9220				defer wg.Done()
9221			}
9222			arr1[idx1] = func() graphql.Marshaler {
9223
9224				return ec.___Field(ctx, field.Selections, &res[idx1])
9225			}()
9226		}
9227		if isLen1 {
9228			f(idx1)
9229		} else {
9230			go f(idx1)
9231		}
9232
9233	}
9234	wg.Wait()
9235	return arr1
9236}
9237
9238// nolint: vetshadow
9239func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
9240	ctx = ec.Tracer.StartFieldExecution(ctx, field)
9241	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
9242	rctx := &graphql.ResolverContext{
9243		Object: "__Type",
9244		Args:   nil,
9245		Field:  field,
9246	}
9247	ctx = graphql.WithResolverContext(ctx, rctx)
9248	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9249	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
9250		ctx = rctx // use context from middleware stack in children
9251		return obj.Interfaces(), nil
9252	})
9253	if resTmp == nil {
9254		return graphql.Null
9255	}
9256	res := resTmp.([]introspection.Type)
9257	rctx.Result = res
9258	ctx = ec.Tracer.StartFieldChildExecution(ctx)
9259
9260	arr1 := make(graphql.Array, len(res))
9261	var wg sync.WaitGroup
9262
9263	isLen1 := len(res) == 1
9264	if !isLen1 {
9265		wg.Add(len(res))
9266	}
9267
9268	for idx1 := range res {
9269		idx1 := idx1
9270		rctx := &graphql.ResolverContext{
9271			Index:  &idx1,
9272			Result: &res[idx1],
9273		}
9274		ctx := graphql.WithResolverContext(ctx, rctx)
9275		f := func(idx1 int) {
9276			if !isLen1 {
9277				defer wg.Done()
9278			}
9279			arr1[idx1] = func() graphql.Marshaler {
9280
9281				return ec.___Type(ctx, field.Selections, &res[idx1])
9282			}()
9283		}
9284		if isLen1 {
9285			f(idx1)
9286		} else {
9287			go f(idx1)
9288		}
9289
9290	}
9291	wg.Wait()
9292	return arr1
9293}
9294
9295// nolint: vetshadow
9296func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
9297	ctx = ec.Tracer.StartFieldExecution(ctx, field)
9298	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
9299	rctx := &graphql.ResolverContext{
9300		Object: "__Type",
9301		Args:   nil,
9302		Field:  field,
9303	}
9304	ctx = graphql.WithResolverContext(ctx, rctx)
9305	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9306	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
9307		ctx = rctx // use context from middleware stack in children
9308		return obj.PossibleTypes(), nil
9309	})
9310	if resTmp == nil {
9311		return graphql.Null
9312	}
9313	res := resTmp.([]introspection.Type)
9314	rctx.Result = res
9315	ctx = ec.Tracer.StartFieldChildExecution(ctx)
9316
9317	arr1 := make(graphql.Array, len(res))
9318	var wg sync.WaitGroup
9319
9320	isLen1 := len(res) == 1
9321	if !isLen1 {
9322		wg.Add(len(res))
9323	}
9324
9325	for idx1 := range res {
9326		idx1 := idx1
9327		rctx := &graphql.ResolverContext{
9328			Index:  &idx1,
9329			Result: &res[idx1],
9330		}
9331		ctx := graphql.WithResolverContext(ctx, rctx)
9332		f := func(idx1 int) {
9333			if !isLen1 {
9334				defer wg.Done()
9335			}
9336			arr1[idx1] = func() graphql.Marshaler {
9337
9338				return ec.___Type(ctx, field.Selections, &res[idx1])
9339			}()
9340		}
9341		if isLen1 {
9342			f(idx1)
9343		} else {
9344			go f(idx1)
9345		}
9346
9347	}
9348	wg.Wait()
9349	return arr1
9350}
9351
9352// nolint: vetshadow
9353func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
9354	ctx = ec.Tracer.StartFieldExecution(ctx, field)
9355	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
9356	rawArgs := field.ArgumentMap(ec.Variables)
9357	args, err := field___Type_enumValues_args(rawArgs)
9358	if err != nil {
9359		ec.Error(ctx, err)
9360		return graphql.Null
9361	}
9362	rctx := &graphql.ResolverContext{
9363		Object: "__Type",
9364		Args:   args,
9365		Field:  field,
9366	}
9367	ctx = graphql.WithResolverContext(ctx, rctx)
9368	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9369	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
9370		ctx = rctx // use context from middleware stack in children
9371		return obj.EnumValues(args["includeDeprecated"].(bool)), nil
9372	})
9373	if resTmp == nil {
9374		return graphql.Null
9375	}
9376	res := resTmp.([]introspection.EnumValue)
9377	rctx.Result = res
9378	ctx = ec.Tracer.StartFieldChildExecution(ctx)
9379
9380	arr1 := make(graphql.Array, len(res))
9381	var wg sync.WaitGroup
9382
9383	isLen1 := len(res) == 1
9384	if !isLen1 {
9385		wg.Add(len(res))
9386	}
9387
9388	for idx1 := range res {
9389		idx1 := idx1
9390		rctx := &graphql.ResolverContext{
9391			Index:  &idx1,
9392			Result: &res[idx1],
9393		}
9394		ctx := graphql.WithResolverContext(ctx, rctx)
9395		f := func(idx1 int) {
9396			if !isLen1 {
9397				defer wg.Done()
9398			}
9399			arr1[idx1] = func() graphql.Marshaler {
9400
9401				return ec.___EnumValue(ctx, field.Selections, &res[idx1])
9402			}()
9403		}
9404		if isLen1 {
9405			f(idx1)
9406		} else {
9407			go f(idx1)
9408		}
9409
9410	}
9411	wg.Wait()
9412	return arr1
9413}
9414
9415// nolint: vetshadow
9416func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
9417	ctx = ec.Tracer.StartFieldExecution(ctx, field)
9418	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
9419	rctx := &graphql.ResolverContext{
9420		Object: "__Type",
9421		Args:   nil,
9422		Field:  field,
9423	}
9424	ctx = graphql.WithResolverContext(ctx, rctx)
9425	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9426	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
9427		ctx = rctx // use context from middleware stack in children
9428		return obj.InputFields(), nil
9429	})
9430	if resTmp == nil {
9431		return graphql.Null
9432	}
9433	res := resTmp.([]introspection.InputValue)
9434	rctx.Result = res
9435	ctx = ec.Tracer.StartFieldChildExecution(ctx)
9436
9437	arr1 := make(graphql.Array, len(res))
9438	var wg sync.WaitGroup
9439
9440	isLen1 := len(res) == 1
9441	if !isLen1 {
9442		wg.Add(len(res))
9443	}
9444
9445	for idx1 := range res {
9446		idx1 := idx1
9447		rctx := &graphql.ResolverContext{
9448			Index:  &idx1,
9449			Result: &res[idx1],
9450		}
9451		ctx := graphql.WithResolverContext(ctx, rctx)
9452		f := func(idx1 int) {
9453			if !isLen1 {
9454				defer wg.Done()
9455			}
9456			arr1[idx1] = func() graphql.Marshaler {
9457
9458				return ec.___InputValue(ctx, field.Selections, &res[idx1])
9459			}()
9460		}
9461		if isLen1 {
9462			f(idx1)
9463		} else {
9464			go f(idx1)
9465		}
9466
9467	}
9468	wg.Wait()
9469	return arr1
9470}
9471
9472// nolint: vetshadow
9473func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
9474	ctx = ec.Tracer.StartFieldExecution(ctx, field)
9475	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
9476	rctx := &graphql.ResolverContext{
9477		Object: "__Type",
9478		Args:   nil,
9479		Field:  field,
9480	}
9481	ctx = graphql.WithResolverContext(ctx, rctx)
9482	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
9483	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
9484		ctx = rctx // use context from middleware stack in children
9485		return obj.OfType(), nil
9486	})
9487	if resTmp == nil {
9488		return graphql.Null
9489	}
9490	res := resTmp.(*introspection.Type)
9491	rctx.Result = res
9492	ctx = ec.Tracer.StartFieldChildExecution(ctx)
9493
9494	if res == nil {
9495		return graphql.Null
9496	}
9497
9498	return ec.___Type(ctx, field.Selections, res)
9499}
9500
9501func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj *models.Authored) graphql.Marshaler {
9502	switch obj := (*obj).(type) {
9503	case nil:
9504		return graphql.Null
9505	case bug.Comment:
9506		return ec._Comment(ctx, sel, &obj)
9507	case *bug.Comment:
9508		return ec._Comment(ctx, sel, obj)
9509	case *bug.CreateOperation:
9510		return ec._CreateOperation(ctx, sel, obj)
9511	case *bug.SetTitleOperation:
9512		return ec._SetTitleOperation(ctx, sel, obj)
9513	case *bug.AddCommentOperation:
9514		return ec._AddCommentOperation(ctx, sel, obj)
9515	case *bug.EditCommentOperation:
9516		return ec._EditCommentOperation(ctx, sel, obj)
9517	case *bug.SetStatusOperation:
9518		return ec._SetStatusOperation(ctx, sel, obj)
9519	case *bug.LabelChangeOperation:
9520		return ec._LabelChangeOperation(ctx, sel, obj)
9521	default:
9522		panic(fmt.Errorf("unexpected type %T", obj))
9523	}
9524}
9525
9526func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj *bug.Operation) graphql.Marshaler {
9527	switch obj := (*obj).(type) {
9528	case nil:
9529		return graphql.Null
9530	case *bug.CreateOperation:
9531		return ec._CreateOperation(ctx, sel, obj)
9532	case *bug.SetTitleOperation:
9533		return ec._SetTitleOperation(ctx, sel, obj)
9534	case *bug.AddCommentOperation:
9535		return ec._AddCommentOperation(ctx, sel, obj)
9536	case *bug.EditCommentOperation:
9537		return ec._EditCommentOperation(ctx, sel, obj)
9538	case *bug.SetStatusOperation:
9539		return ec._SetStatusOperation(ctx, sel, obj)
9540	case *bug.LabelChangeOperation:
9541		return ec._LabelChangeOperation(ctx, sel, obj)
9542	default:
9543		panic(fmt.Errorf("unexpected type %T", obj))
9544	}
9545}
9546
9547func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.TimelineItem) graphql.Marshaler {
9548	switch obj := (*obj).(type) {
9549	case nil:
9550		return graphql.Null
9551	case *bug.CreateTimelineItem:
9552		return ec._CreateTimelineItem(ctx, sel, obj)
9553	case *bug.AddCommentTimelineItem:
9554		return ec._AddCommentTimelineItem(ctx, sel, obj)
9555	case bug.LabelChangeTimelineItem:
9556		return ec._LabelChangeTimelineItem(ctx, sel, &obj)
9557	case *bug.LabelChangeTimelineItem:
9558		return ec._LabelChangeTimelineItem(ctx, sel, obj)
9559	case bug.SetStatusTimelineItem:
9560		return ec._SetStatusTimelineItem(ctx, sel, &obj)
9561	case *bug.SetStatusTimelineItem:
9562		return ec._SetStatusTimelineItem(ctx, sel, obj)
9563	case bug.SetTitleTimelineItem:
9564		return ec._SetTitleTimelineItem(ctx, sel, &obj)
9565	case *bug.SetTitleTimelineItem:
9566		return ec._SetTitleTimelineItem(ctx, sel, obj)
9567	default:
9568		panic(fmt.Errorf("unexpected type %T", obj))
9569	}
9570}
9571
9572func (ec *executionContext) FieldMiddleware(ctx context.Context, obj interface{}, next graphql.Resolver) (ret interface{}) {
9573	defer func() {
9574		if r := recover(); r != nil {
9575			ec.Error(ctx, ec.Recover(ctx, r))
9576			ret = nil
9577		}
9578	}()
9579	res, err := ec.ResolverMiddleware(ctx, next)
9580	if err != nil {
9581		ec.Error(ctx, err)
9582		return nil
9583	}
9584	return res
9585}
9586
9587func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
9588	if ec.DisableIntrospection {
9589		return nil, errors.New("introspection disabled")
9590	}
9591	return introspection.WrapSchema(parsedSchema), nil
9592}
9593
9594func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
9595	if ec.DisableIntrospection {
9596		return nil, errors.New("introspection disabled")
9597	}
9598	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
9599}
9600
9601var parsedSchema = gqlparser.MustLoadSchema(
9602	&ast.Source{Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
9603type Comment implements Authored {
9604  """The author of this comment."""
9605  author: Identity!
9606
9607  """The message of this comment."""
9608  message: String!
9609
9610  """All media's hash referenced in this comment"""
9611  files: [Hash!]!
9612}
9613
9614type CommentConnection {
9615  edges: [CommentEdge!]!
9616  nodes: [Comment!]!
9617  pageInfo: PageInfo!
9618  totalCount: Int!
9619}
9620
9621type CommentEdge {
9622  cursor: String!
9623  node: Comment!
9624}
9625
9626enum Status {
9627  OPEN
9628  CLOSED
9629}
9630
9631type Bug {
9632  """The identifier for this bug"""
9633  id: String!
9634  """The human version (truncated) identifier for this bug"""
9635  humanId: String!
9636  status: Status!
9637  title: String!
9638  labels: [Label!]!
9639  author: Identity!
9640  createdAt: Time!
9641  lastEdit: Time!
9642
9643  comments(
9644    """Returns the elements in the list that come after the specified cursor."""
9645    after: String
9646    """Returns the elements in the list that come before the specified cursor."""
9647    before: String
9648    """Returns the first _n_ elements from the list."""
9649    first: Int
9650    """Returns the last _n_ elements from the list."""
9651    last: Int
9652  ): CommentConnection!
9653
9654  timeline(
9655    """Returns the elements in the list that come after the specified cursor."""
9656    after: String
9657    """Returns the elements in the list that come before the specified cursor."""
9658    before: String
9659    """Returns the first _n_ elements from the list."""
9660    first: Int
9661    """Returns the last _n_ elements from the list."""
9662    last: Int
9663  ): TimelineItemConnection!
9664
9665  operations(
9666    """Returns the elements in the list that come after the specified cursor."""
9667    after: String
9668    """Returns the elements in the list that come before the specified cursor."""
9669    before: String
9670    """Returns the first _n_ elements from the list."""
9671    first: Int
9672    """Returns the last _n_ elements from the list."""
9673    last: Int
9674  ): OperationConnection!
9675}
9676
9677"""The connection type for Bug."""
9678type BugConnection {
9679  """A list of edges."""
9680  edges: [BugEdge!]!
9681  nodes: [Bug!]!
9682  """Information to aid in pagination."""
9683  pageInfo: PageInfo!
9684  """Identifies the total count of items in the connection."""
9685  totalCount: Int!
9686}
9687
9688"""An edge in a connection."""
9689type BugEdge {
9690  """A cursor for use in pagination."""
9691  cursor: String!
9692  """The item at the end of the edge."""
9693  node: Bug!
9694}
9695
9696`},
9697	&ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
9698type Identity {
9699    """The identifier for this identity"""
9700    id: String!
9701    """The human version (truncated) identifier for this identity"""
9702    humanId: String!
9703    """The name of the person, if known."""
9704    name: String
9705    """The email of the person, if known."""
9706    email: String
9707    """The login of the person, if known."""
9708    login: String
9709    """A string containing the either the name of the person, its login or both"""
9710    displayName: String!
9711    """An url to an avatar"""
9712    avatarUrl: String
9713    """isProtected is true if the chain of git commits started to be signed.
9714    If that's the case, only signed commit with a valid key for this identity can be added."""
9715    isProtected: Boolean!
9716}
9717
9718type IdentityConnection {
9719    edges: [IdentityEdge!]!
9720    nodes: [Identity!]!
9721    pageInfo: PageInfo!
9722    totalCount: Int!
9723}
9724
9725type IdentityEdge {
9726    cursor: String!
9727    node: Identity!
9728}`},
9729	&ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
9730interface Operation {
9731    """The hash of the operation"""
9732    hash: Hash!
9733    """The operations author."""
9734    author: Identity!
9735    """The datetime when this operation was issued."""
9736    date: Time!
9737}
9738
9739# Connection
9740
9741"""The connection type for an Operation"""
9742type OperationConnection {
9743    edges: [OperationEdge!]!
9744    nodes: [Operation!]!
9745    pageInfo: PageInfo!
9746    totalCount: Int!
9747}
9748
9749"""Represent an Operation"""
9750type OperationEdge {
9751    cursor: String!
9752    node: Operation!
9753}
9754
9755# Operations
9756
9757type CreateOperation implements Operation & Authored {
9758    """The hash of the operation"""
9759    hash: Hash!
9760    """The author of this object."""
9761    author: Identity!
9762    """The datetime when this operation was issued."""
9763    date: Time!
9764
9765    title: String!
9766    message: String!
9767    files: [Hash!]!
9768}
9769
9770type SetTitleOperation implements Operation & Authored {
9771    """The hash of the operation"""
9772    hash: Hash!
9773    """The author of this object."""
9774    author: Identity!
9775    """The datetime when this operation was issued."""
9776    date: Time!
9777
9778    title: String!
9779    was: String!
9780}
9781
9782type AddCommentOperation implements Operation & Authored {
9783    """The hash of the operation"""
9784    hash: Hash!
9785    """The author of this object."""
9786    author: Identity!
9787    """The datetime when this operation was issued."""
9788    date: Time!
9789
9790    message: String!
9791    files: [Hash!]!
9792}
9793
9794type EditCommentOperation implements Operation & Authored {
9795    """The hash of the operation"""
9796    hash: Hash!
9797    """The author of this object."""
9798    author: Identity!
9799    """The datetime when this operation was issued."""
9800    date: Time!
9801
9802    target: Hash!
9803    message: String!
9804    files: [Hash!]!
9805}
9806
9807type SetStatusOperation implements Operation & Authored {
9808    """The hash of the operation"""
9809    hash: Hash!
9810    """The author of this object."""
9811    author: Identity!
9812    """The datetime when this operation was issued."""
9813    date: Time!
9814
9815    status: Status!
9816}
9817
9818type LabelChangeOperation implements Operation & Authored {
9819    """The hash of the operation"""
9820    hash: Hash!
9821    """The author of this object."""
9822    author: Identity!
9823    """The datetime when this operation was issued."""
9824    date: Time!
9825
9826    added: [Label!]!
9827    removed: [Label!]!
9828}
9829`},
9830	&ast.Source{Name: "schema/repository.graphql", Input: `
9831type Repository {
9832    """All the bugs"""
9833    allBugs(
9834        """Returns the elements in the list that come after the specified cursor."""
9835        after: String
9836        """Returns the elements in the list that come before the specified cursor."""
9837        before: String
9838        """Returns the first _n_ elements from the list."""
9839        first: Int
9840        """Returns the last _n_ elements from the list."""
9841        last: Int
9842        """A query to select and order bugs"""
9843        query: String
9844    ): BugConnection!
9845
9846    bug(prefix: String!): Bug
9847
9848    """All the identities"""
9849    allIdentities(
9850        """Returns the elements in the list that come after the specified cursor."""
9851        after: String
9852        """Returns the elements in the list that come before the specified cursor."""
9853        before: String
9854        """Returns the first _n_ elements from the list."""
9855        first: Int
9856        """Returns the last _n_ elements from the list."""
9857        last: Int
9858    ): IdentityConnection!
9859
9860    identity(prefix: String!):Identity
9861
9862    """The identity created or selected by the user as its own"""
9863    userIdentity:Identity
9864}`},
9865	&ast.Source{Name: "schema/root.graphql", Input: `type Query {
9866    defaultRepository: Repository
9867    repository(id: String!): Repository
9868}
9869
9870type Mutation {
9871    newBug(repoRef: String, title: String!, message: String!, files: [Hash!]): Bug!
9872
9873    addComment(repoRef: String, prefix: String!, message: String!, files: [Hash!]): Bug!
9874    changeLabels(repoRef: String, prefix: String!, added: [String!], removed: [String!]): Bug!
9875    open(repoRef: String, prefix: String!): Bug!
9876    close(repoRef: String, prefix: String!): Bug!
9877    setTitle(repoRef: String, prefix: String!, title: String!): Bug!
9878
9879    commit(repoRef: String, prefix: String!): Bug!
9880}
9881`},
9882	&ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
9883interface TimelineItem {
9884    """The hash of the source operation"""
9885    hash: Hash!
9886}
9887
9888"""CommentHistoryStep hold one version of a message in the history"""
9889type CommentHistoryStep {
9890    message: String!
9891    date: Time!
9892}
9893
9894# Connection
9895
9896"""The connection type for TimelineItem"""
9897type TimelineItemConnection {
9898    edges: [TimelineItemEdge!]!
9899    nodes: [TimelineItem!]!
9900    pageInfo: PageInfo!
9901    totalCount: Int!
9902}
9903
9904"""Represent a TimelineItem"""
9905type TimelineItemEdge {
9906    cursor: String!
9907    node: TimelineItem!
9908}
9909
9910# Items
9911
9912"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
9913type CreateTimelineItem implements TimelineItem {
9914    """The hash of the source operation"""
9915    hash: Hash!
9916    author: Identity!
9917    message: String!
9918    messageIsEmpty: Boolean!
9919    files: [Hash!]!
9920    createdAt: Time!
9921    lastEdit: Time!
9922    edited: Boolean!
9923    history: [CommentHistoryStep!]!
9924}
9925
9926"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
9927type AddCommentTimelineItem implements TimelineItem {
9928    """The hash of the source operation"""
9929    hash: Hash!
9930    author: Identity!
9931    message: String!
9932    messageIsEmpty: Boolean!
9933    files: [Hash!]!
9934    createdAt: Time!
9935    lastEdit: Time!
9936    edited: Boolean!
9937    history: [CommentHistoryStep!]!
9938}
9939
9940"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
9941type LabelChangeTimelineItem implements TimelineItem {
9942    """The hash of the source operation"""
9943    hash: Hash!
9944    author: Identity!
9945    date: Time!
9946    added: [Label!]!
9947    removed: [Label!]!
9948}
9949
9950"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
9951type SetStatusTimelineItem implements TimelineItem {
9952    """The hash of the source operation"""
9953    hash: Hash!
9954    author: Identity!
9955    date: Time!
9956    status: Status!
9957}
9958
9959"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
9960type SetTitleTimelineItem implements TimelineItem {
9961    """The hash of the source operation"""
9962    hash: Hash!
9963    author: Identity!
9964    date: Time!
9965    title: String!
9966    was: String!
9967}
9968`},
9969	&ast.Source{Name: "schema/types.graphql", Input: `scalar Time
9970scalar Label
9971scalar Hash
9972
9973"""Information about pagination in a connection."""
9974type PageInfo {
9975    """When paginating forwards, are there more items?"""
9976    hasNextPage: Boolean!
9977    """When paginating backwards, are there more items?"""
9978    hasPreviousPage: Boolean!
9979    """When paginating backwards, the cursor to continue."""
9980    startCursor: String!
9981    """When paginating forwards, the cursor to continue."""
9982    endCursor: String!
9983}
9984
9985"""An object that has an author."""
9986interface Authored {
9987    """The author of this object."""
9988    author: Identity!
9989}`},
9990)