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