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