1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
   2
   3package graph
   4
   5import (
   6	"context"
   7	"errors"
   8	"fmt"
   9	"strconv"
  10	"sync"
  11	"sync/atomic"
  12
  13	"github.com/99designs/gqlgen/graphql"
  14	"github.com/git-bug/git-bug/api/graphql/models"
  15	"github.com/vektah/gqlparser/v2/ast"
  16)
  17
  18// region    ************************** generated!.gotpl **************************
  19
  20type RepositoryResolver interface {
  21	Name(ctx context.Context, obj *models.Repository) (*string, error)
  22	AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
  23	Bug(ctx context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error)
  24	AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  25	Identity(ctx context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error)
  26	UserIdentity(ctx context.Context, obj *models.Repository) (models.IdentityWrapper, error)
  27	ValidLabels(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error)
  28}
  29
  30// endregion ************************** generated!.gotpl **************************
  31
  32// region    ***************************** args.gotpl *****************************
  33
  34func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
  35	var err error
  36	args := map[string]any{}
  37	arg0, err := ec.field_Repository_allBugs_argsAfter(ctx, rawArgs)
  38	if err != nil {
  39		return nil, err
  40	}
  41	args["after"] = arg0
  42	arg1, err := ec.field_Repository_allBugs_argsBefore(ctx, rawArgs)
  43	if err != nil {
  44		return nil, err
  45	}
  46	args["before"] = arg1
  47	arg2, err := ec.field_Repository_allBugs_argsFirst(ctx, rawArgs)
  48	if err != nil {
  49		return nil, err
  50	}
  51	args["first"] = arg2
  52	arg3, err := ec.field_Repository_allBugs_argsLast(ctx, rawArgs)
  53	if err != nil {
  54		return nil, err
  55	}
  56	args["last"] = arg3
  57	arg4, err := ec.field_Repository_allBugs_argsQuery(ctx, rawArgs)
  58	if err != nil {
  59		return nil, err
  60	}
  61	args["query"] = arg4
  62	return args, nil
  63}
  64func (ec *executionContext) field_Repository_allBugs_argsAfter(
  65	ctx context.Context,
  66	rawArgs map[string]any,
  67) (*string, error) {
  68	if _, ok := rawArgs["after"]; !ok {
  69		var zeroVal *string
  70		return zeroVal, nil
  71	}
  72
  73	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
  74	if tmp, ok := rawArgs["after"]; ok {
  75		return ec.unmarshalOString2ᚖstring(ctx, tmp)
  76	}
  77
  78	var zeroVal *string
  79	return zeroVal, nil
  80}
  81
  82func (ec *executionContext) field_Repository_allBugs_argsBefore(
  83	ctx context.Context,
  84	rawArgs map[string]any,
  85) (*string, error) {
  86	if _, ok := rawArgs["before"]; !ok {
  87		var zeroVal *string
  88		return zeroVal, nil
  89	}
  90
  91	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
  92	if tmp, ok := rawArgs["before"]; ok {
  93		return ec.unmarshalOString2ᚖstring(ctx, tmp)
  94	}
  95
  96	var zeroVal *string
  97	return zeroVal, nil
  98}
  99
 100func (ec *executionContext) field_Repository_allBugs_argsFirst(
 101	ctx context.Context,
 102	rawArgs map[string]any,
 103) (*int, error) {
 104	if _, ok := rawArgs["first"]; !ok {
 105		var zeroVal *int
 106		return zeroVal, nil
 107	}
 108
 109	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
 110	if tmp, ok := rawArgs["first"]; ok {
 111		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 112	}
 113
 114	var zeroVal *int
 115	return zeroVal, nil
 116}
 117
 118func (ec *executionContext) field_Repository_allBugs_argsLast(
 119	ctx context.Context,
 120	rawArgs map[string]any,
 121) (*int, error) {
 122	if _, ok := rawArgs["last"]; !ok {
 123		var zeroVal *int
 124		return zeroVal, nil
 125	}
 126
 127	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
 128	if tmp, ok := rawArgs["last"]; ok {
 129		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 130	}
 131
 132	var zeroVal *int
 133	return zeroVal, nil
 134}
 135
 136func (ec *executionContext) field_Repository_allBugs_argsQuery(
 137	ctx context.Context,
 138	rawArgs map[string]any,
 139) (*string, error) {
 140	if _, ok := rawArgs["query"]; !ok {
 141		var zeroVal *string
 142		return zeroVal, nil
 143	}
 144
 145	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query"))
 146	if tmp, ok := rawArgs["query"]; ok {
 147		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 148	}
 149
 150	var zeroVal *string
 151	return zeroVal, nil
 152}
 153
 154func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 155	var err error
 156	args := map[string]any{}
 157	arg0, err := ec.field_Repository_allIdentities_argsAfter(ctx, rawArgs)
 158	if err != nil {
 159		return nil, err
 160	}
 161	args["after"] = arg0
 162	arg1, err := ec.field_Repository_allIdentities_argsBefore(ctx, rawArgs)
 163	if err != nil {
 164		return nil, err
 165	}
 166	args["before"] = arg1
 167	arg2, err := ec.field_Repository_allIdentities_argsFirst(ctx, rawArgs)
 168	if err != nil {
 169		return nil, err
 170	}
 171	args["first"] = arg2
 172	arg3, err := ec.field_Repository_allIdentities_argsLast(ctx, rawArgs)
 173	if err != nil {
 174		return nil, err
 175	}
 176	args["last"] = arg3
 177	return args, nil
 178}
 179func (ec *executionContext) field_Repository_allIdentities_argsAfter(
 180	ctx context.Context,
 181	rawArgs map[string]any,
 182) (*string, error) {
 183	if _, ok := rawArgs["after"]; !ok {
 184		var zeroVal *string
 185		return zeroVal, nil
 186	}
 187
 188	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
 189	if tmp, ok := rawArgs["after"]; ok {
 190		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 191	}
 192
 193	var zeroVal *string
 194	return zeroVal, nil
 195}
 196
 197func (ec *executionContext) field_Repository_allIdentities_argsBefore(
 198	ctx context.Context,
 199	rawArgs map[string]any,
 200) (*string, error) {
 201	if _, ok := rawArgs["before"]; !ok {
 202		var zeroVal *string
 203		return zeroVal, nil
 204	}
 205
 206	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
 207	if tmp, ok := rawArgs["before"]; ok {
 208		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 209	}
 210
 211	var zeroVal *string
 212	return zeroVal, nil
 213}
 214
 215func (ec *executionContext) field_Repository_allIdentities_argsFirst(
 216	ctx context.Context,
 217	rawArgs map[string]any,
 218) (*int, error) {
 219	if _, ok := rawArgs["first"]; !ok {
 220		var zeroVal *int
 221		return zeroVal, nil
 222	}
 223
 224	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
 225	if tmp, ok := rawArgs["first"]; ok {
 226		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 227	}
 228
 229	var zeroVal *int
 230	return zeroVal, nil
 231}
 232
 233func (ec *executionContext) field_Repository_allIdentities_argsLast(
 234	ctx context.Context,
 235	rawArgs map[string]any,
 236) (*int, error) {
 237	if _, ok := rawArgs["last"]; !ok {
 238		var zeroVal *int
 239		return zeroVal, nil
 240	}
 241
 242	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
 243	if tmp, ok := rawArgs["last"]; ok {
 244		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 245	}
 246
 247	var zeroVal *int
 248	return zeroVal, nil
 249}
 250
 251func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 252	var err error
 253	args := map[string]any{}
 254	arg0, err := ec.field_Repository_bug_argsPrefix(ctx, rawArgs)
 255	if err != nil {
 256		return nil, err
 257	}
 258	args["prefix"] = arg0
 259	return args, nil
 260}
 261func (ec *executionContext) field_Repository_bug_argsPrefix(
 262	ctx context.Context,
 263	rawArgs map[string]any,
 264) (string, error) {
 265	if _, ok := rawArgs["prefix"]; !ok {
 266		var zeroVal string
 267		return zeroVal, nil
 268	}
 269
 270	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
 271	if tmp, ok := rawArgs["prefix"]; ok {
 272		return ec.unmarshalNString2string(ctx, tmp)
 273	}
 274
 275	var zeroVal string
 276	return zeroVal, nil
 277}
 278
 279func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 280	var err error
 281	args := map[string]any{}
 282	arg0, err := ec.field_Repository_identity_argsPrefix(ctx, rawArgs)
 283	if err != nil {
 284		return nil, err
 285	}
 286	args["prefix"] = arg0
 287	return args, nil
 288}
 289func (ec *executionContext) field_Repository_identity_argsPrefix(
 290	ctx context.Context,
 291	rawArgs map[string]any,
 292) (string, error) {
 293	if _, ok := rawArgs["prefix"]; !ok {
 294		var zeroVal string
 295		return zeroVal, nil
 296	}
 297
 298	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
 299	if tmp, ok := rawArgs["prefix"]; ok {
 300		return ec.unmarshalNString2string(ctx, tmp)
 301	}
 302
 303	var zeroVal string
 304	return zeroVal, nil
 305}
 306
 307func (ec *executionContext) field_Repository_validLabels_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 308	var err error
 309	args := map[string]any{}
 310	arg0, err := ec.field_Repository_validLabels_argsAfter(ctx, rawArgs)
 311	if err != nil {
 312		return nil, err
 313	}
 314	args["after"] = arg0
 315	arg1, err := ec.field_Repository_validLabels_argsBefore(ctx, rawArgs)
 316	if err != nil {
 317		return nil, err
 318	}
 319	args["before"] = arg1
 320	arg2, err := ec.field_Repository_validLabels_argsFirst(ctx, rawArgs)
 321	if err != nil {
 322		return nil, err
 323	}
 324	args["first"] = arg2
 325	arg3, err := ec.field_Repository_validLabels_argsLast(ctx, rawArgs)
 326	if err != nil {
 327		return nil, err
 328	}
 329	args["last"] = arg3
 330	return args, nil
 331}
 332func (ec *executionContext) field_Repository_validLabels_argsAfter(
 333	ctx context.Context,
 334	rawArgs map[string]any,
 335) (*string, error) {
 336	if _, ok := rawArgs["after"]; !ok {
 337		var zeroVal *string
 338		return zeroVal, nil
 339	}
 340
 341	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
 342	if tmp, ok := rawArgs["after"]; ok {
 343		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 344	}
 345
 346	var zeroVal *string
 347	return zeroVal, nil
 348}
 349
 350func (ec *executionContext) field_Repository_validLabels_argsBefore(
 351	ctx context.Context,
 352	rawArgs map[string]any,
 353) (*string, error) {
 354	if _, ok := rawArgs["before"]; !ok {
 355		var zeroVal *string
 356		return zeroVal, nil
 357	}
 358
 359	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
 360	if tmp, ok := rawArgs["before"]; ok {
 361		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 362	}
 363
 364	var zeroVal *string
 365	return zeroVal, nil
 366}
 367
 368func (ec *executionContext) field_Repository_validLabels_argsFirst(
 369	ctx context.Context,
 370	rawArgs map[string]any,
 371) (*int, error) {
 372	if _, ok := rawArgs["first"]; !ok {
 373		var zeroVal *int
 374		return zeroVal, nil
 375	}
 376
 377	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
 378	if tmp, ok := rawArgs["first"]; ok {
 379		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 380	}
 381
 382	var zeroVal *int
 383	return zeroVal, nil
 384}
 385
 386func (ec *executionContext) field_Repository_validLabels_argsLast(
 387	ctx context.Context,
 388	rawArgs map[string]any,
 389) (*int, error) {
 390	if _, ok := rawArgs["last"]; !ok {
 391		var zeroVal *int
 392		return zeroVal, nil
 393	}
 394
 395	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
 396	if tmp, ok := rawArgs["last"]; ok {
 397		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 398	}
 399
 400	var zeroVal *int
 401	return zeroVal, nil
 402}
 403
 404// endregion ***************************** args.gotpl *****************************
 405
 406// region    ************************** directives.gotpl **************************
 407
 408// endregion ************************** directives.gotpl **************************
 409
 410// region    **************************** field.gotpl *****************************
 411
 412func (ec *executionContext) _Repository_name(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 413	fc, err := ec.fieldContext_Repository_name(ctx, field)
 414	if err != nil {
 415		return graphql.Null
 416	}
 417	ctx = graphql.WithFieldContext(ctx, fc)
 418	defer func() {
 419		if r := recover(); r != nil {
 420			ec.Error(ctx, ec.Recover(ctx, r))
 421			ret = graphql.Null
 422		}
 423	}()
 424	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 425		ctx = rctx // use context from middleware stack in children
 426		return ec.resolvers.Repository().Name(rctx, obj)
 427	})
 428	if err != nil {
 429		ec.Error(ctx, err)
 430		return graphql.Null
 431	}
 432	if resTmp == nil {
 433		return graphql.Null
 434	}
 435	res := resTmp.(*string)
 436	fc.Result = res
 437	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 438}
 439
 440func (ec *executionContext) fieldContext_Repository_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 441	fc = &graphql.FieldContext{
 442		Object:     "Repository",
 443		Field:      field,
 444		IsMethod:   true,
 445		IsResolver: true,
 446		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 447			return nil, errors.New("field of type String does not have child fields")
 448		},
 449	}
 450	return fc, nil
 451}
 452
 453func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 454	fc, err := ec.fieldContext_Repository_allBugs(ctx, field)
 455	if err != nil {
 456		return graphql.Null
 457	}
 458	ctx = graphql.WithFieldContext(ctx, fc)
 459	defer func() {
 460		if r := recover(); r != nil {
 461			ec.Error(ctx, ec.Recover(ctx, r))
 462			ret = graphql.Null
 463		}
 464	}()
 465	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 466		ctx = rctx // use context from middleware stack in children
 467		return ec.resolvers.Repository().AllBugs(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int), fc.Args["query"].(*string))
 468	})
 469	if err != nil {
 470		ec.Error(ctx, err)
 471		return graphql.Null
 472	}
 473	if resTmp == nil {
 474		if !graphql.HasFieldError(ctx, fc) {
 475			ec.Errorf(ctx, "must not be null")
 476		}
 477		return graphql.Null
 478	}
 479	res := resTmp.(*models.BugConnection)
 480	fc.Result = res
 481	return ec.marshalNBugConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
 482}
 483
 484func (ec *executionContext) fieldContext_Repository_allBugs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 485	fc = &graphql.FieldContext{
 486		Object:     "Repository",
 487		Field:      field,
 488		IsMethod:   true,
 489		IsResolver: true,
 490		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 491			switch field.Name {
 492			case "edges":
 493				return ec.fieldContext_BugConnection_edges(ctx, field)
 494			case "nodes":
 495				return ec.fieldContext_BugConnection_nodes(ctx, field)
 496			case "pageInfo":
 497				return ec.fieldContext_BugConnection_pageInfo(ctx, field)
 498			case "totalCount":
 499				return ec.fieldContext_BugConnection_totalCount(ctx, field)
 500			}
 501			return nil, fmt.Errorf("no field named %q was found under type BugConnection", field.Name)
 502		},
 503	}
 504	defer func() {
 505		if r := recover(); r != nil {
 506			err = ec.Recover(ctx, r)
 507			ec.Error(ctx, err)
 508		}
 509	}()
 510	ctx = graphql.WithFieldContext(ctx, fc)
 511	if fc.Args, err = ec.field_Repository_allBugs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 512		ec.Error(ctx, err)
 513		return fc, err
 514	}
 515	return fc, nil
 516}
 517
 518func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 519	fc, err := ec.fieldContext_Repository_bug(ctx, field)
 520	if err != nil {
 521		return graphql.Null
 522	}
 523	ctx = graphql.WithFieldContext(ctx, fc)
 524	defer func() {
 525		if r := recover(); r != nil {
 526			ec.Error(ctx, ec.Recover(ctx, r))
 527			ret = graphql.Null
 528		}
 529	}()
 530	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 531		ctx = rctx // use context from middleware stack in children
 532		return ec.resolvers.Repository().Bug(rctx, obj, fc.Args["prefix"].(string))
 533	})
 534	if err != nil {
 535		ec.Error(ctx, err)
 536		return graphql.Null
 537	}
 538	if resTmp == nil {
 539		return graphql.Null
 540	}
 541	res := resTmp.(models.BugWrapper)
 542	fc.Result = res
 543	return ec.marshalOBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 544}
 545
 546func (ec *executionContext) fieldContext_Repository_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 547	fc = &graphql.FieldContext{
 548		Object:     "Repository",
 549		Field:      field,
 550		IsMethod:   true,
 551		IsResolver: true,
 552		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 553			switch field.Name {
 554			case "id":
 555				return ec.fieldContext_Bug_id(ctx, field)
 556			case "humanId":
 557				return ec.fieldContext_Bug_humanId(ctx, field)
 558			case "status":
 559				return ec.fieldContext_Bug_status(ctx, field)
 560			case "title":
 561				return ec.fieldContext_Bug_title(ctx, field)
 562			case "labels":
 563				return ec.fieldContext_Bug_labels(ctx, field)
 564			case "author":
 565				return ec.fieldContext_Bug_author(ctx, field)
 566			case "createdAt":
 567				return ec.fieldContext_Bug_createdAt(ctx, field)
 568			case "lastEdit":
 569				return ec.fieldContext_Bug_lastEdit(ctx, field)
 570			case "actors":
 571				return ec.fieldContext_Bug_actors(ctx, field)
 572			case "participants":
 573				return ec.fieldContext_Bug_participants(ctx, field)
 574			case "comments":
 575				return ec.fieldContext_Bug_comments(ctx, field)
 576			case "timeline":
 577				return ec.fieldContext_Bug_timeline(ctx, field)
 578			case "operations":
 579				return ec.fieldContext_Bug_operations(ctx, field)
 580			}
 581			return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
 582		},
 583	}
 584	defer func() {
 585		if r := recover(); r != nil {
 586			err = ec.Recover(ctx, r)
 587			ec.Error(ctx, err)
 588		}
 589	}()
 590	ctx = graphql.WithFieldContext(ctx, fc)
 591	if fc.Args, err = ec.field_Repository_bug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 592		ec.Error(ctx, err)
 593		return fc, err
 594	}
 595	return fc, nil
 596}
 597
 598func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 599	fc, err := ec.fieldContext_Repository_allIdentities(ctx, field)
 600	if err != nil {
 601		return graphql.Null
 602	}
 603	ctx = graphql.WithFieldContext(ctx, fc)
 604	defer func() {
 605		if r := recover(); r != nil {
 606			ec.Error(ctx, ec.Recover(ctx, r))
 607			ret = graphql.Null
 608		}
 609	}()
 610	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 611		ctx = rctx // use context from middleware stack in children
 612		return ec.resolvers.Repository().AllIdentities(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
 613	})
 614	if err != nil {
 615		ec.Error(ctx, err)
 616		return graphql.Null
 617	}
 618	if resTmp == nil {
 619		if !graphql.HasFieldError(ctx, fc) {
 620			ec.Errorf(ctx, "must not be null")
 621		}
 622		return graphql.Null
 623	}
 624	res := resTmp.(*models.IdentityConnection)
 625	fc.Result = res
 626	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 627}
 628
 629func (ec *executionContext) fieldContext_Repository_allIdentities(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 630	fc = &graphql.FieldContext{
 631		Object:     "Repository",
 632		Field:      field,
 633		IsMethod:   true,
 634		IsResolver: true,
 635		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 636			switch field.Name {
 637			case "edges":
 638				return ec.fieldContext_IdentityConnection_edges(ctx, field)
 639			case "nodes":
 640				return ec.fieldContext_IdentityConnection_nodes(ctx, field)
 641			case "pageInfo":
 642				return ec.fieldContext_IdentityConnection_pageInfo(ctx, field)
 643			case "totalCount":
 644				return ec.fieldContext_IdentityConnection_totalCount(ctx, field)
 645			}
 646			return nil, fmt.Errorf("no field named %q was found under type IdentityConnection", field.Name)
 647		},
 648	}
 649	defer func() {
 650		if r := recover(); r != nil {
 651			err = ec.Recover(ctx, r)
 652			ec.Error(ctx, err)
 653		}
 654	}()
 655	ctx = graphql.WithFieldContext(ctx, fc)
 656	if fc.Args, err = ec.field_Repository_allIdentities_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 657		ec.Error(ctx, err)
 658		return fc, err
 659	}
 660	return fc, nil
 661}
 662
 663func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 664	fc, err := ec.fieldContext_Repository_identity(ctx, field)
 665	if err != nil {
 666		return graphql.Null
 667	}
 668	ctx = graphql.WithFieldContext(ctx, fc)
 669	defer func() {
 670		if r := recover(); r != nil {
 671			ec.Error(ctx, ec.Recover(ctx, r))
 672			ret = graphql.Null
 673		}
 674	}()
 675	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 676		ctx = rctx // use context from middleware stack in children
 677		return ec.resolvers.Repository().Identity(rctx, obj, fc.Args["prefix"].(string))
 678	})
 679	if err != nil {
 680		ec.Error(ctx, err)
 681		return graphql.Null
 682	}
 683	if resTmp == nil {
 684		return graphql.Null
 685	}
 686	res := resTmp.(models.IdentityWrapper)
 687	fc.Result = res
 688	return ec.marshalOIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 689}
 690
 691func (ec *executionContext) fieldContext_Repository_identity(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 692	fc = &graphql.FieldContext{
 693		Object:     "Repository",
 694		Field:      field,
 695		IsMethod:   true,
 696		IsResolver: true,
 697		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 698			switch field.Name {
 699			case "id":
 700				return ec.fieldContext_Identity_id(ctx, field)
 701			case "humanId":
 702				return ec.fieldContext_Identity_humanId(ctx, field)
 703			case "name":
 704				return ec.fieldContext_Identity_name(ctx, field)
 705			case "email":
 706				return ec.fieldContext_Identity_email(ctx, field)
 707			case "login":
 708				return ec.fieldContext_Identity_login(ctx, field)
 709			case "displayName":
 710				return ec.fieldContext_Identity_displayName(ctx, field)
 711			case "avatarUrl":
 712				return ec.fieldContext_Identity_avatarUrl(ctx, field)
 713			case "isProtected":
 714				return ec.fieldContext_Identity_isProtected(ctx, field)
 715			}
 716			return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
 717		},
 718	}
 719	defer func() {
 720		if r := recover(); r != nil {
 721			err = ec.Recover(ctx, r)
 722			ec.Error(ctx, err)
 723		}
 724	}()
 725	ctx = graphql.WithFieldContext(ctx, fc)
 726	if fc.Args, err = ec.field_Repository_identity_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 727		ec.Error(ctx, err)
 728		return fc, err
 729	}
 730	return fc, nil
 731}
 732
 733func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 734	fc, err := ec.fieldContext_Repository_userIdentity(ctx, field)
 735	if err != nil {
 736		return graphql.Null
 737	}
 738	ctx = graphql.WithFieldContext(ctx, fc)
 739	defer func() {
 740		if r := recover(); r != nil {
 741			ec.Error(ctx, ec.Recover(ctx, r))
 742			ret = graphql.Null
 743		}
 744	}()
 745	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 746		ctx = rctx // use context from middleware stack in children
 747		return ec.resolvers.Repository().UserIdentity(rctx, obj)
 748	})
 749	if err != nil {
 750		ec.Error(ctx, err)
 751		return graphql.Null
 752	}
 753	if resTmp == nil {
 754		return graphql.Null
 755	}
 756	res := resTmp.(models.IdentityWrapper)
 757	fc.Result = res
 758	return ec.marshalOIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 759}
 760
 761func (ec *executionContext) fieldContext_Repository_userIdentity(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 762	fc = &graphql.FieldContext{
 763		Object:     "Repository",
 764		Field:      field,
 765		IsMethod:   true,
 766		IsResolver: true,
 767		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 768			switch field.Name {
 769			case "id":
 770				return ec.fieldContext_Identity_id(ctx, field)
 771			case "humanId":
 772				return ec.fieldContext_Identity_humanId(ctx, field)
 773			case "name":
 774				return ec.fieldContext_Identity_name(ctx, field)
 775			case "email":
 776				return ec.fieldContext_Identity_email(ctx, field)
 777			case "login":
 778				return ec.fieldContext_Identity_login(ctx, field)
 779			case "displayName":
 780				return ec.fieldContext_Identity_displayName(ctx, field)
 781			case "avatarUrl":
 782				return ec.fieldContext_Identity_avatarUrl(ctx, field)
 783			case "isProtected":
 784				return ec.fieldContext_Identity_isProtected(ctx, field)
 785			}
 786			return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
 787		},
 788	}
 789	return fc, nil
 790}
 791
 792func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 793	fc, err := ec.fieldContext_Repository_validLabels(ctx, field)
 794	if err != nil {
 795		return graphql.Null
 796	}
 797	ctx = graphql.WithFieldContext(ctx, fc)
 798	defer func() {
 799		if r := recover(); r != nil {
 800			ec.Error(ctx, ec.Recover(ctx, r))
 801			ret = graphql.Null
 802		}
 803	}()
 804	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 805		ctx = rctx // use context from middleware stack in children
 806		return ec.resolvers.Repository().ValidLabels(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
 807	})
 808	if err != nil {
 809		ec.Error(ctx, err)
 810		return graphql.Null
 811	}
 812	if resTmp == nil {
 813		if !graphql.HasFieldError(ctx, fc) {
 814			ec.Errorf(ctx, "must not be null")
 815		}
 816		return graphql.Null
 817	}
 818	res := resTmp.(*models.LabelConnection)
 819	fc.Result = res
 820	return ec.marshalNLabelConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx, field.Selections, res)
 821}
 822
 823func (ec *executionContext) fieldContext_Repository_validLabels(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 824	fc = &graphql.FieldContext{
 825		Object:     "Repository",
 826		Field:      field,
 827		IsMethod:   true,
 828		IsResolver: true,
 829		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 830			switch field.Name {
 831			case "edges":
 832				return ec.fieldContext_LabelConnection_edges(ctx, field)
 833			case "nodes":
 834				return ec.fieldContext_LabelConnection_nodes(ctx, field)
 835			case "pageInfo":
 836				return ec.fieldContext_LabelConnection_pageInfo(ctx, field)
 837			case "totalCount":
 838				return ec.fieldContext_LabelConnection_totalCount(ctx, field)
 839			}
 840			return nil, fmt.Errorf("no field named %q was found under type LabelConnection", field.Name)
 841		},
 842	}
 843	defer func() {
 844		if r := recover(); r != nil {
 845			err = ec.Recover(ctx, r)
 846			ec.Error(ctx, err)
 847		}
 848	}()
 849	ctx = graphql.WithFieldContext(ctx, fc)
 850	if fc.Args, err = ec.field_Repository_validLabels_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 851		ec.Error(ctx, err)
 852		return fc, err
 853	}
 854	return fc, nil
 855}
 856
 857func (ec *executionContext) _RepositoryConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.RepositoryConnection) (ret graphql.Marshaler) {
 858	fc, err := ec.fieldContext_RepositoryConnection_edges(ctx, field)
 859	if err != nil {
 860		return graphql.Null
 861	}
 862	ctx = graphql.WithFieldContext(ctx, fc)
 863	defer func() {
 864		if r := recover(); r != nil {
 865			ec.Error(ctx, ec.Recover(ctx, r))
 866			ret = graphql.Null
 867		}
 868	}()
 869	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 870		ctx = rctx // use context from middleware stack in children
 871		return obj.Edges, nil
 872	})
 873	if err != nil {
 874		ec.Error(ctx, err)
 875		return graphql.Null
 876	}
 877	if resTmp == nil {
 878		if !graphql.HasFieldError(ctx, fc) {
 879			ec.Errorf(ctx, "must not be null")
 880		}
 881		return graphql.Null
 882	}
 883	res := resTmp.([]*models.RepositoryEdge)
 884	fc.Result = res
 885	return ec.marshalNRepositoryEdge2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryEdgeᚄ(ctx, field.Selections, res)
 886}
 887
 888func (ec *executionContext) fieldContext_RepositoryConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 889	fc = &graphql.FieldContext{
 890		Object:     "RepositoryConnection",
 891		Field:      field,
 892		IsMethod:   false,
 893		IsResolver: false,
 894		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 895			switch field.Name {
 896			case "cursor":
 897				return ec.fieldContext_RepositoryEdge_cursor(ctx, field)
 898			case "node":
 899				return ec.fieldContext_RepositoryEdge_node(ctx, field)
 900			}
 901			return nil, fmt.Errorf("no field named %q was found under type RepositoryEdge", field.Name)
 902		},
 903	}
 904	return fc, nil
 905}
 906
 907func (ec *executionContext) _RepositoryConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.RepositoryConnection) (ret graphql.Marshaler) {
 908	fc, err := ec.fieldContext_RepositoryConnection_nodes(ctx, field)
 909	if err != nil {
 910		return graphql.Null
 911	}
 912	ctx = graphql.WithFieldContext(ctx, fc)
 913	defer func() {
 914		if r := recover(); r != nil {
 915			ec.Error(ctx, ec.Recover(ctx, r))
 916			ret = graphql.Null
 917		}
 918	}()
 919	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 920		ctx = rctx // use context from middleware stack in children
 921		return obj.Nodes, nil
 922	})
 923	if err != nil {
 924		ec.Error(ctx, err)
 925		return graphql.Null
 926	}
 927	if resTmp == nil {
 928		if !graphql.HasFieldError(ctx, fc) {
 929			ec.Errorf(ctx, "must not be null")
 930		}
 931		return graphql.Null
 932	}
 933	res := resTmp.([]*models.Repository)
 934	fc.Result = res
 935	return ec.marshalNRepository2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryᚄ(ctx, field.Selections, res)
 936}
 937
 938func (ec *executionContext) fieldContext_RepositoryConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 939	fc = &graphql.FieldContext{
 940		Object:     "RepositoryConnection",
 941		Field:      field,
 942		IsMethod:   false,
 943		IsResolver: false,
 944		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 945			switch field.Name {
 946			case "name":
 947				return ec.fieldContext_Repository_name(ctx, field)
 948			case "allBugs":
 949				return ec.fieldContext_Repository_allBugs(ctx, field)
 950			case "bug":
 951				return ec.fieldContext_Repository_bug(ctx, field)
 952			case "allIdentities":
 953				return ec.fieldContext_Repository_allIdentities(ctx, field)
 954			case "identity":
 955				return ec.fieldContext_Repository_identity(ctx, field)
 956			case "userIdentity":
 957				return ec.fieldContext_Repository_userIdentity(ctx, field)
 958			case "validLabels":
 959				return ec.fieldContext_Repository_validLabels(ctx, field)
 960			}
 961			return nil, fmt.Errorf("no field named %q was found under type Repository", field.Name)
 962		},
 963	}
 964	return fc, nil
 965}
 966
 967func (ec *executionContext) _RepositoryConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.RepositoryConnection) (ret graphql.Marshaler) {
 968	fc, err := ec.fieldContext_RepositoryConnection_pageInfo(ctx, field)
 969	if err != nil {
 970		return graphql.Null
 971	}
 972	ctx = graphql.WithFieldContext(ctx, fc)
 973	defer func() {
 974		if r := recover(); r != nil {
 975			ec.Error(ctx, ec.Recover(ctx, r))
 976			ret = graphql.Null
 977		}
 978	}()
 979	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 980		ctx = rctx // use context from middleware stack in children
 981		return obj.PageInfo, nil
 982	})
 983	if err != nil {
 984		ec.Error(ctx, err)
 985		return graphql.Null
 986	}
 987	if resTmp == nil {
 988		if !graphql.HasFieldError(ctx, fc) {
 989			ec.Errorf(ctx, "must not be null")
 990		}
 991		return graphql.Null
 992	}
 993	res := resTmp.(*models.PageInfo)
 994	fc.Result = res
 995	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 996}
 997
 998func (ec *executionContext) fieldContext_RepositoryConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 999	fc = &graphql.FieldContext{
1000		Object:     "RepositoryConnection",
1001		Field:      field,
1002		IsMethod:   false,
1003		IsResolver: false,
1004		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1005			switch field.Name {
1006			case "hasNextPage":
1007				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
1008			case "hasPreviousPage":
1009				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
1010			case "startCursor":
1011				return ec.fieldContext_PageInfo_startCursor(ctx, field)
1012			case "endCursor":
1013				return ec.fieldContext_PageInfo_endCursor(ctx, field)
1014			}
1015			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
1016		},
1017	}
1018	return fc, nil
1019}
1020
1021func (ec *executionContext) _RepositoryConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.RepositoryConnection) (ret graphql.Marshaler) {
1022	fc, err := ec.fieldContext_RepositoryConnection_totalCount(ctx, field)
1023	if err != nil {
1024		return graphql.Null
1025	}
1026	ctx = graphql.WithFieldContext(ctx, fc)
1027	defer func() {
1028		if r := recover(); r != nil {
1029			ec.Error(ctx, ec.Recover(ctx, r))
1030			ret = graphql.Null
1031		}
1032	}()
1033	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1034		ctx = rctx // use context from middleware stack in children
1035		return obj.TotalCount, nil
1036	})
1037	if err != nil {
1038		ec.Error(ctx, err)
1039		return graphql.Null
1040	}
1041	if resTmp == nil {
1042		if !graphql.HasFieldError(ctx, fc) {
1043			ec.Errorf(ctx, "must not be null")
1044		}
1045		return graphql.Null
1046	}
1047	res := resTmp.(int)
1048	fc.Result = res
1049	return ec.marshalNInt2int(ctx, field.Selections, res)
1050}
1051
1052func (ec *executionContext) fieldContext_RepositoryConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1053	fc = &graphql.FieldContext{
1054		Object:     "RepositoryConnection",
1055		Field:      field,
1056		IsMethod:   false,
1057		IsResolver: false,
1058		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1059			return nil, errors.New("field of type Int does not have child fields")
1060		},
1061	}
1062	return fc, nil
1063}
1064
1065func (ec *executionContext) _RepositoryEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.RepositoryEdge) (ret graphql.Marshaler) {
1066	fc, err := ec.fieldContext_RepositoryEdge_cursor(ctx, field)
1067	if err != nil {
1068		return graphql.Null
1069	}
1070	ctx = graphql.WithFieldContext(ctx, fc)
1071	defer func() {
1072		if r := recover(); r != nil {
1073			ec.Error(ctx, ec.Recover(ctx, r))
1074			ret = graphql.Null
1075		}
1076	}()
1077	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1078		ctx = rctx // use context from middleware stack in children
1079		return obj.Cursor, nil
1080	})
1081	if err != nil {
1082		ec.Error(ctx, err)
1083		return graphql.Null
1084	}
1085	if resTmp == nil {
1086		if !graphql.HasFieldError(ctx, fc) {
1087			ec.Errorf(ctx, "must not be null")
1088		}
1089		return graphql.Null
1090	}
1091	res := resTmp.(string)
1092	fc.Result = res
1093	return ec.marshalNString2string(ctx, field.Selections, res)
1094}
1095
1096func (ec *executionContext) fieldContext_RepositoryEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1097	fc = &graphql.FieldContext{
1098		Object:     "RepositoryEdge",
1099		Field:      field,
1100		IsMethod:   false,
1101		IsResolver: false,
1102		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1103			return nil, errors.New("field of type String does not have child fields")
1104		},
1105	}
1106	return fc, nil
1107}
1108
1109func (ec *executionContext) _RepositoryEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.RepositoryEdge) (ret graphql.Marshaler) {
1110	fc, err := ec.fieldContext_RepositoryEdge_node(ctx, field)
1111	if err != nil {
1112		return graphql.Null
1113	}
1114	ctx = graphql.WithFieldContext(ctx, fc)
1115	defer func() {
1116		if r := recover(); r != nil {
1117			ec.Error(ctx, ec.Recover(ctx, r))
1118			ret = graphql.Null
1119		}
1120	}()
1121	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1122		ctx = rctx // use context from middleware stack in children
1123		return obj.Node, nil
1124	})
1125	if err != nil {
1126		ec.Error(ctx, err)
1127		return graphql.Null
1128	}
1129	if resTmp == nil {
1130		if !graphql.HasFieldError(ctx, fc) {
1131			ec.Errorf(ctx, "must not be null")
1132		}
1133		return graphql.Null
1134	}
1135	res := resTmp.(*models.Repository)
1136	fc.Result = res
1137	return ec.marshalNRepository2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
1138}
1139
1140func (ec *executionContext) fieldContext_RepositoryEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1141	fc = &graphql.FieldContext{
1142		Object:     "RepositoryEdge",
1143		Field:      field,
1144		IsMethod:   false,
1145		IsResolver: false,
1146		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1147			switch field.Name {
1148			case "name":
1149				return ec.fieldContext_Repository_name(ctx, field)
1150			case "allBugs":
1151				return ec.fieldContext_Repository_allBugs(ctx, field)
1152			case "bug":
1153				return ec.fieldContext_Repository_bug(ctx, field)
1154			case "allIdentities":
1155				return ec.fieldContext_Repository_allIdentities(ctx, field)
1156			case "identity":
1157				return ec.fieldContext_Repository_identity(ctx, field)
1158			case "userIdentity":
1159				return ec.fieldContext_Repository_userIdentity(ctx, field)
1160			case "validLabels":
1161				return ec.fieldContext_Repository_validLabels(ctx, field)
1162			}
1163			return nil, fmt.Errorf("no field named %q was found under type Repository", field.Name)
1164		},
1165	}
1166	return fc, nil
1167}
1168
1169// endregion **************************** field.gotpl *****************************
1170
1171// region    **************************** input.gotpl *****************************
1172
1173// endregion **************************** input.gotpl *****************************
1174
1175// region    ************************** interface.gotpl ***************************
1176
1177// endregion ************************** interface.gotpl ***************************
1178
1179// region    **************************** object.gotpl ****************************
1180
1181var repositoryImplementors = []string{"Repository"}
1182
1183func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
1184	fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
1185
1186	out := graphql.NewFieldSet(fields)
1187	deferred := make(map[string]*graphql.FieldSet)
1188	for i, field := range fields {
1189		switch field.Name {
1190		case "__typename":
1191			out.Values[i] = graphql.MarshalString("Repository")
1192		case "name":
1193			field := field
1194
1195			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
1196				defer func() {
1197					if r := recover(); r != nil {
1198						ec.Error(ctx, ec.Recover(ctx, r))
1199					}
1200				}()
1201				res = ec._Repository_name(ctx, field, obj)
1202				return res
1203			}
1204
1205			if field.Deferrable != nil {
1206				dfs, ok := deferred[field.Deferrable.Label]
1207				di := 0
1208				if ok {
1209					dfs.AddField(field)
1210					di = len(dfs.Values) - 1
1211				} else {
1212					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1213					deferred[field.Deferrable.Label] = dfs
1214				}
1215				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1216					return innerFunc(ctx, dfs)
1217				})
1218
1219				// don't run the out.Concurrently() call below
1220				out.Values[i] = graphql.Null
1221				continue
1222			}
1223
1224			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1225		case "allBugs":
1226			field := field
1227
1228			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1229				defer func() {
1230					if r := recover(); r != nil {
1231						ec.Error(ctx, ec.Recover(ctx, r))
1232					}
1233				}()
1234				res = ec._Repository_allBugs(ctx, field, obj)
1235				if res == graphql.Null {
1236					atomic.AddUint32(&fs.Invalids, 1)
1237				}
1238				return res
1239			}
1240
1241			if field.Deferrable != nil {
1242				dfs, ok := deferred[field.Deferrable.Label]
1243				di := 0
1244				if ok {
1245					dfs.AddField(field)
1246					di = len(dfs.Values) - 1
1247				} else {
1248					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1249					deferred[field.Deferrable.Label] = dfs
1250				}
1251				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1252					return innerFunc(ctx, dfs)
1253				})
1254
1255				// don't run the out.Concurrently() call below
1256				out.Values[i] = graphql.Null
1257				continue
1258			}
1259
1260			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1261		case "bug":
1262			field := field
1263
1264			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
1265				defer func() {
1266					if r := recover(); r != nil {
1267						ec.Error(ctx, ec.Recover(ctx, r))
1268					}
1269				}()
1270				res = ec._Repository_bug(ctx, field, obj)
1271				return res
1272			}
1273
1274			if field.Deferrable != nil {
1275				dfs, ok := deferred[field.Deferrable.Label]
1276				di := 0
1277				if ok {
1278					dfs.AddField(field)
1279					di = len(dfs.Values) - 1
1280				} else {
1281					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1282					deferred[field.Deferrable.Label] = dfs
1283				}
1284				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1285					return innerFunc(ctx, dfs)
1286				})
1287
1288				// don't run the out.Concurrently() call below
1289				out.Values[i] = graphql.Null
1290				continue
1291			}
1292
1293			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1294		case "allIdentities":
1295			field := field
1296
1297			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1298				defer func() {
1299					if r := recover(); r != nil {
1300						ec.Error(ctx, ec.Recover(ctx, r))
1301					}
1302				}()
1303				res = ec._Repository_allIdentities(ctx, field, obj)
1304				if res == graphql.Null {
1305					atomic.AddUint32(&fs.Invalids, 1)
1306				}
1307				return res
1308			}
1309
1310			if field.Deferrable != nil {
1311				dfs, ok := deferred[field.Deferrable.Label]
1312				di := 0
1313				if ok {
1314					dfs.AddField(field)
1315					di = len(dfs.Values) - 1
1316				} else {
1317					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1318					deferred[field.Deferrable.Label] = dfs
1319				}
1320				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1321					return innerFunc(ctx, dfs)
1322				})
1323
1324				// don't run the out.Concurrently() call below
1325				out.Values[i] = graphql.Null
1326				continue
1327			}
1328
1329			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1330		case "identity":
1331			field := field
1332
1333			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
1334				defer func() {
1335					if r := recover(); r != nil {
1336						ec.Error(ctx, ec.Recover(ctx, r))
1337					}
1338				}()
1339				res = ec._Repository_identity(ctx, field, obj)
1340				return res
1341			}
1342
1343			if field.Deferrable != nil {
1344				dfs, ok := deferred[field.Deferrable.Label]
1345				di := 0
1346				if ok {
1347					dfs.AddField(field)
1348					di = len(dfs.Values) - 1
1349				} else {
1350					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1351					deferred[field.Deferrable.Label] = dfs
1352				}
1353				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1354					return innerFunc(ctx, dfs)
1355				})
1356
1357				// don't run the out.Concurrently() call below
1358				out.Values[i] = graphql.Null
1359				continue
1360			}
1361
1362			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1363		case "userIdentity":
1364			field := field
1365
1366			innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) {
1367				defer func() {
1368					if r := recover(); r != nil {
1369						ec.Error(ctx, ec.Recover(ctx, r))
1370					}
1371				}()
1372				res = ec._Repository_userIdentity(ctx, field, obj)
1373				return res
1374			}
1375
1376			if field.Deferrable != nil {
1377				dfs, ok := deferred[field.Deferrable.Label]
1378				di := 0
1379				if ok {
1380					dfs.AddField(field)
1381					di = len(dfs.Values) - 1
1382				} else {
1383					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1384					deferred[field.Deferrable.Label] = dfs
1385				}
1386				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1387					return innerFunc(ctx, dfs)
1388				})
1389
1390				// don't run the out.Concurrently() call below
1391				out.Values[i] = graphql.Null
1392				continue
1393			}
1394
1395			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1396		case "validLabels":
1397			field := field
1398
1399			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1400				defer func() {
1401					if r := recover(); r != nil {
1402						ec.Error(ctx, ec.Recover(ctx, r))
1403					}
1404				}()
1405				res = ec._Repository_validLabels(ctx, field, obj)
1406				if res == graphql.Null {
1407					atomic.AddUint32(&fs.Invalids, 1)
1408				}
1409				return res
1410			}
1411
1412			if field.Deferrable != nil {
1413				dfs, ok := deferred[field.Deferrable.Label]
1414				di := 0
1415				if ok {
1416					dfs.AddField(field)
1417					di = len(dfs.Values) - 1
1418				} else {
1419					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1420					deferred[field.Deferrable.Label] = dfs
1421				}
1422				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1423					return innerFunc(ctx, dfs)
1424				})
1425
1426				// don't run the out.Concurrently() call below
1427				out.Values[i] = graphql.Null
1428				continue
1429			}
1430
1431			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1432		default:
1433			panic("unknown field " + strconv.Quote(field.Name))
1434		}
1435	}
1436	out.Dispatch(ctx)
1437	if out.Invalids > 0 {
1438		return graphql.Null
1439	}
1440
1441	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1442
1443	for label, dfs := range deferred {
1444		ec.processDeferredGroup(graphql.DeferredGroup{
1445			Label:    label,
1446			Path:     graphql.GetPath(ctx),
1447			FieldSet: dfs,
1448			Context:  ctx,
1449		})
1450	}
1451
1452	return out
1453}
1454
1455var repositoryConnectionImplementors = []string{"RepositoryConnection"}
1456
1457func (ec *executionContext) _RepositoryConnection(ctx context.Context, sel ast.SelectionSet, obj *models.RepositoryConnection) graphql.Marshaler {
1458	fields := graphql.CollectFields(ec.OperationContext, sel, repositoryConnectionImplementors)
1459
1460	out := graphql.NewFieldSet(fields)
1461	deferred := make(map[string]*graphql.FieldSet)
1462	for i, field := range fields {
1463		switch field.Name {
1464		case "__typename":
1465			out.Values[i] = graphql.MarshalString("RepositoryConnection")
1466		case "edges":
1467			out.Values[i] = ec._RepositoryConnection_edges(ctx, field, obj)
1468			if out.Values[i] == graphql.Null {
1469				out.Invalids++
1470			}
1471		case "nodes":
1472			out.Values[i] = ec._RepositoryConnection_nodes(ctx, field, obj)
1473			if out.Values[i] == graphql.Null {
1474				out.Invalids++
1475			}
1476		case "pageInfo":
1477			out.Values[i] = ec._RepositoryConnection_pageInfo(ctx, field, obj)
1478			if out.Values[i] == graphql.Null {
1479				out.Invalids++
1480			}
1481		case "totalCount":
1482			out.Values[i] = ec._RepositoryConnection_totalCount(ctx, field, obj)
1483			if out.Values[i] == graphql.Null {
1484				out.Invalids++
1485			}
1486		default:
1487			panic("unknown field " + strconv.Quote(field.Name))
1488		}
1489	}
1490	out.Dispatch(ctx)
1491	if out.Invalids > 0 {
1492		return graphql.Null
1493	}
1494
1495	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1496
1497	for label, dfs := range deferred {
1498		ec.processDeferredGroup(graphql.DeferredGroup{
1499			Label:    label,
1500			Path:     graphql.GetPath(ctx),
1501			FieldSet: dfs,
1502			Context:  ctx,
1503		})
1504	}
1505
1506	return out
1507}
1508
1509var repositoryEdgeImplementors = []string{"RepositoryEdge"}
1510
1511func (ec *executionContext) _RepositoryEdge(ctx context.Context, sel ast.SelectionSet, obj *models.RepositoryEdge) graphql.Marshaler {
1512	fields := graphql.CollectFields(ec.OperationContext, sel, repositoryEdgeImplementors)
1513
1514	out := graphql.NewFieldSet(fields)
1515	deferred := make(map[string]*graphql.FieldSet)
1516	for i, field := range fields {
1517		switch field.Name {
1518		case "__typename":
1519			out.Values[i] = graphql.MarshalString("RepositoryEdge")
1520		case "cursor":
1521			out.Values[i] = ec._RepositoryEdge_cursor(ctx, field, obj)
1522			if out.Values[i] == graphql.Null {
1523				out.Invalids++
1524			}
1525		case "node":
1526			out.Values[i] = ec._RepositoryEdge_node(ctx, field, obj)
1527			if out.Values[i] == graphql.Null {
1528				out.Invalids++
1529			}
1530		default:
1531			panic("unknown field " + strconv.Quote(field.Name))
1532		}
1533	}
1534	out.Dispatch(ctx)
1535	if out.Invalids > 0 {
1536		return graphql.Null
1537	}
1538
1539	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1540
1541	for label, dfs := range deferred {
1542		ec.processDeferredGroup(graphql.DeferredGroup{
1543			Label:    label,
1544			Path:     graphql.GetPath(ctx),
1545			FieldSet: dfs,
1546			Context:  ctx,
1547		})
1548	}
1549
1550	return out
1551}
1552
1553// endregion **************************** object.gotpl ****************************
1554
1555// region    ***************************** type.gotpl *****************************
1556
1557func (ec *executionContext) marshalNRepository2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.Repository) graphql.Marshaler {
1558	ret := make(graphql.Array, len(v))
1559	var wg sync.WaitGroup
1560	isLen1 := len(v) == 1
1561	if !isLen1 {
1562		wg.Add(len(v))
1563	}
1564	for i := range v {
1565		i := i
1566		fc := &graphql.FieldContext{
1567			Index:  &i,
1568			Result: &v[i],
1569		}
1570		ctx := graphql.WithFieldContext(ctx, fc)
1571		f := func(i int) {
1572			defer func() {
1573				if r := recover(); r != nil {
1574					ec.Error(ctx, ec.Recover(ctx, r))
1575					ret = nil
1576				}
1577			}()
1578			if !isLen1 {
1579				defer wg.Done()
1580			}
1581			ret[i] = ec.marshalNRepository2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx, sel, v[i])
1582		}
1583		if isLen1 {
1584			f(i)
1585		} else {
1586			go f(i)
1587		}
1588
1589	}
1590	wg.Wait()
1591
1592	for _, e := range ret {
1593		if e == graphql.Null {
1594			return graphql.Null
1595		}
1596	}
1597
1598	return ret
1599}
1600
1601func (ec *executionContext) marshalNRepository2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
1602	if v == nil {
1603		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
1604			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
1605		}
1606		return graphql.Null
1607	}
1608	return ec._Repository(ctx, sel, v)
1609}
1610
1611func (ec *executionContext) marshalNRepositoryConnection2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryConnection(ctx context.Context, sel ast.SelectionSet, v models.RepositoryConnection) graphql.Marshaler {
1612	return ec._RepositoryConnection(ctx, sel, &v)
1613}
1614
1615func (ec *executionContext) marshalNRepositoryConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryConnection(ctx context.Context, sel ast.SelectionSet, v *models.RepositoryConnection) graphql.Marshaler {
1616	if v == nil {
1617		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
1618			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
1619		}
1620		return graphql.Null
1621	}
1622	return ec._RepositoryConnection(ctx, sel, v)
1623}
1624
1625func (ec *executionContext) marshalNRepositoryEdge2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.RepositoryEdge) graphql.Marshaler {
1626	ret := make(graphql.Array, len(v))
1627	var wg sync.WaitGroup
1628	isLen1 := len(v) == 1
1629	if !isLen1 {
1630		wg.Add(len(v))
1631	}
1632	for i := range v {
1633		i := i
1634		fc := &graphql.FieldContext{
1635			Index:  &i,
1636			Result: &v[i],
1637		}
1638		ctx := graphql.WithFieldContext(ctx, fc)
1639		f := func(i int) {
1640			defer func() {
1641				if r := recover(); r != nil {
1642					ec.Error(ctx, ec.Recover(ctx, r))
1643					ret = nil
1644				}
1645			}()
1646			if !isLen1 {
1647				defer wg.Done()
1648			}
1649			ret[i] = ec.marshalNRepositoryEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryEdge(ctx, sel, v[i])
1650		}
1651		if isLen1 {
1652			f(i)
1653		} else {
1654			go f(i)
1655		}
1656
1657	}
1658	wg.Wait()
1659
1660	for _, e := range ret {
1661		if e == graphql.Null {
1662			return graphql.Null
1663		}
1664	}
1665
1666	return ret
1667}
1668
1669func (ec *executionContext) marshalNRepositoryEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepositoryEdge(ctx context.Context, sel ast.SelectionSet, v *models.RepositoryEdge) graphql.Marshaler {
1670	if v == nil {
1671		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
1672			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
1673		}
1674		return graphql.Null
1675	}
1676	return ec._RepositoryEdge(ctx, sel, v)
1677}
1678
1679func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
1680	if v == nil {
1681		return graphql.Null
1682	}
1683	return ec._Repository(ctx, sel, v)
1684}
1685
1686// endregion ***************************** type.gotpl *****************************