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/MichaelMure/git-bug/api/graphql/models"
  16	"github.com/MichaelMure/git-bug/entities/bug"
  17	"github.com/MichaelMure/git-bug/entities/common"
  18	"github.com/MichaelMure/git-bug/entity"
  19	"github.com/MichaelMure/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
 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
 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
 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
 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
 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	out := graphql.NewFieldSet(fields)
1809	var invalids uint32
1810	for i, field := range fields {
1811		switch field.Name {
1812		case "__typename":
1813			out.Values[i] = graphql.MarshalString("Bug")
1814		case "id":
1815
1816			out.Values[i] = ec._Bug_id(ctx, field, obj)
1817
1818			if out.Values[i] == graphql.Null {
1819				atomic.AddUint32(&invalids, 1)
1820			}
1821		case "humanId":
1822			field := field
1823
1824			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
1825				defer func() {
1826					if r := recover(); r != nil {
1827						ec.Error(ctx, ec.Recover(ctx, r))
1828					}
1829				}()
1830				res = ec._Bug_humanId(ctx, field, obj)
1831				if res == graphql.Null {
1832					atomic.AddUint32(&invalids, 1)
1833				}
1834				return res
1835			}
1836
1837			out.Concurrently(i, func() graphql.Marshaler {
1838				return innerFunc(ctx)
1839
1840			})
1841		case "status":
1842
1843			out.Values[i] = ec._Bug_status(ctx, field, obj)
1844
1845			if out.Values[i] == graphql.Null {
1846				atomic.AddUint32(&invalids, 1)
1847			}
1848		case "title":
1849
1850			out.Values[i] = ec._Bug_title(ctx, field, obj)
1851
1852			if out.Values[i] == graphql.Null {
1853				atomic.AddUint32(&invalids, 1)
1854			}
1855		case "labels":
1856
1857			out.Values[i] = ec._Bug_labels(ctx, field, obj)
1858
1859			if out.Values[i] == graphql.Null {
1860				atomic.AddUint32(&invalids, 1)
1861			}
1862		case "author":
1863
1864			out.Values[i] = ec._Bug_author(ctx, field, obj)
1865
1866			if out.Values[i] == graphql.Null {
1867				atomic.AddUint32(&invalids, 1)
1868			}
1869		case "createdAt":
1870
1871			out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
1872
1873			if out.Values[i] == graphql.Null {
1874				atomic.AddUint32(&invalids, 1)
1875			}
1876		case "lastEdit":
1877
1878			out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
1879
1880			if out.Values[i] == graphql.Null {
1881				atomic.AddUint32(&invalids, 1)
1882			}
1883		case "actors":
1884			field := field
1885
1886			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
1887				defer func() {
1888					if r := recover(); r != nil {
1889						ec.Error(ctx, ec.Recover(ctx, r))
1890					}
1891				}()
1892				res = ec._Bug_actors(ctx, field, obj)
1893				if res == graphql.Null {
1894					atomic.AddUint32(&invalids, 1)
1895				}
1896				return res
1897			}
1898
1899			out.Concurrently(i, func() graphql.Marshaler {
1900				return innerFunc(ctx)
1901
1902			})
1903		case "participants":
1904			field := field
1905
1906			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
1907				defer func() {
1908					if r := recover(); r != nil {
1909						ec.Error(ctx, ec.Recover(ctx, r))
1910					}
1911				}()
1912				res = ec._Bug_participants(ctx, field, obj)
1913				if res == graphql.Null {
1914					atomic.AddUint32(&invalids, 1)
1915				}
1916				return res
1917			}
1918
1919			out.Concurrently(i, func() graphql.Marshaler {
1920				return innerFunc(ctx)
1921
1922			})
1923		case "comments":
1924			field := field
1925
1926			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
1927				defer func() {
1928					if r := recover(); r != nil {
1929						ec.Error(ctx, ec.Recover(ctx, r))
1930					}
1931				}()
1932				res = ec._Bug_comments(ctx, field, obj)
1933				if res == graphql.Null {
1934					atomic.AddUint32(&invalids, 1)
1935				}
1936				return res
1937			}
1938
1939			out.Concurrently(i, func() graphql.Marshaler {
1940				return innerFunc(ctx)
1941
1942			})
1943		case "timeline":
1944			field := field
1945
1946			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
1947				defer func() {
1948					if r := recover(); r != nil {
1949						ec.Error(ctx, ec.Recover(ctx, r))
1950					}
1951				}()
1952				res = ec._Bug_timeline(ctx, field, obj)
1953				if res == graphql.Null {
1954					atomic.AddUint32(&invalids, 1)
1955				}
1956				return res
1957			}
1958
1959			out.Concurrently(i, func() graphql.Marshaler {
1960				return innerFunc(ctx)
1961
1962			})
1963		case "operations":
1964			field := field
1965
1966			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
1967				defer func() {
1968					if r := recover(); r != nil {
1969						ec.Error(ctx, ec.Recover(ctx, r))
1970					}
1971				}()
1972				res = ec._Bug_operations(ctx, field, obj)
1973				if res == graphql.Null {
1974					atomic.AddUint32(&invalids, 1)
1975				}
1976				return res
1977			}
1978
1979			out.Concurrently(i, func() graphql.Marshaler {
1980				return innerFunc(ctx)
1981
1982			})
1983		default:
1984			panic("unknown field " + strconv.Quote(field.Name))
1985		}
1986	}
1987	out.Dispatch()
1988	if invalids > 0 {
1989		return graphql.Null
1990	}
1991	return out
1992}
1993
1994var bugConnectionImplementors = []string{"BugConnection"}
1995
1996func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
1997	fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
1998	out := graphql.NewFieldSet(fields)
1999	var invalids uint32
2000	for i, field := range fields {
2001		switch field.Name {
2002		case "__typename":
2003			out.Values[i] = graphql.MarshalString("BugConnection")
2004		case "edges":
2005
2006			out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
2007
2008			if out.Values[i] == graphql.Null {
2009				invalids++
2010			}
2011		case "nodes":
2012
2013			out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
2014
2015			if out.Values[i] == graphql.Null {
2016				invalids++
2017			}
2018		case "pageInfo":
2019
2020			out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
2021
2022			if out.Values[i] == graphql.Null {
2023				invalids++
2024			}
2025		case "totalCount":
2026
2027			out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
2028
2029			if out.Values[i] == graphql.Null {
2030				invalids++
2031			}
2032		default:
2033			panic("unknown field " + strconv.Quote(field.Name))
2034		}
2035	}
2036	out.Dispatch()
2037	if invalids > 0 {
2038		return graphql.Null
2039	}
2040	return out
2041}
2042
2043var bugEdgeImplementors = []string{"BugEdge"}
2044
2045func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
2046	fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
2047	out := graphql.NewFieldSet(fields)
2048	var invalids uint32
2049	for i, field := range fields {
2050		switch field.Name {
2051		case "__typename":
2052			out.Values[i] = graphql.MarshalString("BugEdge")
2053		case "cursor":
2054
2055			out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
2056
2057			if out.Values[i] == graphql.Null {
2058				invalids++
2059			}
2060		case "node":
2061
2062			out.Values[i] = ec._BugEdge_node(ctx, field, obj)
2063
2064			if out.Values[i] == graphql.Null {
2065				invalids++
2066			}
2067		default:
2068			panic("unknown field " + strconv.Quote(field.Name))
2069		}
2070	}
2071	out.Dispatch()
2072	if invalids > 0 {
2073		return graphql.Null
2074	}
2075	return out
2076}
2077
2078var commentImplementors = []string{"Comment", "Authored"}
2079
2080func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
2081	fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
2082	out := graphql.NewFieldSet(fields)
2083	var invalids uint32
2084	for i, field := range fields {
2085		switch field.Name {
2086		case "__typename":
2087			out.Values[i] = graphql.MarshalString("Comment")
2088		case "id":
2089			field := field
2090
2091			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
2092				defer func() {
2093					if r := recover(); r != nil {
2094						ec.Error(ctx, ec.Recover(ctx, r))
2095					}
2096				}()
2097				res = ec._Comment_id(ctx, field, obj)
2098				if res == graphql.Null {
2099					atomic.AddUint32(&invalids, 1)
2100				}
2101				return res
2102			}
2103
2104			out.Concurrently(i, func() graphql.Marshaler {
2105				return innerFunc(ctx)
2106
2107			})
2108		case "author":
2109			field := field
2110
2111			innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
2112				defer func() {
2113					if r := recover(); r != nil {
2114						ec.Error(ctx, ec.Recover(ctx, r))
2115					}
2116				}()
2117				res = ec._Comment_author(ctx, field, obj)
2118				if res == graphql.Null {
2119					atomic.AddUint32(&invalids, 1)
2120				}
2121				return res
2122			}
2123
2124			out.Concurrently(i, func() graphql.Marshaler {
2125				return innerFunc(ctx)
2126
2127			})
2128		case "message":
2129
2130			out.Values[i] = ec._Comment_message(ctx, field, obj)
2131
2132			if out.Values[i] == graphql.Null {
2133				atomic.AddUint32(&invalids, 1)
2134			}
2135		case "files":
2136
2137			out.Values[i] = ec._Comment_files(ctx, field, obj)
2138
2139			if out.Values[i] == graphql.Null {
2140				atomic.AddUint32(&invalids, 1)
2141			}
2142		default:
2143			panic("unknown field " + strconv.Quote(field.Name))
2144		}
2145	}
2146	out.Dispatch()
2147	if invalids > 0 {
2148		return graphql.Null
2149	}
2150	return out
2151}
2152
2153var commentConnectionImplementors = []string{"CommentConnection"}
2154
2155func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
2156	fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
2157	out := graphql.NewFieldSet(fields)
2158	var invalids uint32
2159	for i, field := range fields {
2160		switch field.Name {
2161		case "__typename":
2162			out.Values[i] = graphql.MarshalString("CommentConnection")
2163		case "edges":
2164
2165			out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
2166
2167			if out.Values[i] == graphql.Null {
2168				invalids++
2169			}
2170		case "nodes":
2171
2172			out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
2173
2174			if out.Values[i] == graphql.Null {
2175				invalids++
2176			}
2177		case "pageInfo":
2178
2179			out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
2180
2181			if out.Values[i] == graphql.Null {
2182				invalids++
2183			}
2184		case "totalCount":
2185
2186			out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
2187
2188			if out.Values[i] == graphql.Null {
2189				invalids++
2190			}
2191		default:
2192			panic("unknown field " + strconv.Quote(field.Name))
2193		}
2194	}
2195	out.Dispatch()
2196	if invalids > 0 {
2197		return graphql.Null
2198	}
2199	return out
2200}
2201
2202var commentEdgeImplementors = []string{"CommentEdge"}
2203
2204func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
2205	fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
2206	out := graphql.NewFieldSet(fields)
2207	var invalids uint32
2208	for i, field := range fields {
2209		switch field.Name {
2210		case "__typename":
2211			out.Values[i] = graphql.MarshalString("CommentEdge")
2212		case "cursor":
2213
2214			out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
2215
2216			if out.Values[i] == graphql.Null {
2217				invalids++
2218			}
2219		case "node":
2220
2221			out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
2222
2223			if out.Values[i] == graphql.Null {
2224				invalids++
2225			}
2226		default:
2227			panic("unknown field " + strconv.Quote(field.Name))
2228		}
2229	}
2230	out.Dispatch()
2231	if invalids > 0 {
2232		return graphql.Null
2233	}
2234	return out
2235}
2236
2237// endregion **************************** object.gotpl ****************************
2238
2239// region    ***************************** type.gotpl *****************************
2240
2241func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
2242	if v == nil {
2243		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2244			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2245		}
2246		return graphql.Null
2247	}
2248	return ec._Bug(ctx, sel, v)
2249}
2250
2251func (ec *executionContext) marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BugWrapper) graphql.Marshaler {
2252	ret := make(graphql.Array, len(v))
2253	var wg sync.WaitGroup
2254	isLen1 := len(v) == 1
2255	if !isLen1 {
2256		wg.Add(len(v))
2257	}
2258	for i := range v {
2259		i := i
2260		fc := &graphql.FieldContext{
2261			Index:  &i,
2262			Result: &v[i],
2263		}
2264		ctx := graphql.WithFieldContext(ctx, fc)
2265		f := func(i int) {
2266			defer func() {
2267				if r := recover(); r != nil {
2268					ec.Error(ctx, ec.Recover(ctx, r))
2269					ret = nil
2270				}
2271			}()
2272			if !isLen1 {
2273				defer wg.Done()
2274			}
2275			ret[i] = ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, sel, v[i])
2276		}
2277		if isLen1 {
2278			f(i)
2279		} else {
2280			go f(i)
2281		}
2282
2283	}
2284	wg.Wait()
2285
2286	for _, e := range ret {
2287		if e == graphql.Null {
2288			return graphql.Null
2289		}
2290	}
2291
2292	return ret
2293}
2294
2295func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
2296	return ec._BugConnection(ctx, sel, &v)
2297}
2298
2299func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
2300	if v == nil {
2301		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2302			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2303		}
2304		return graphql.Null
2305	}
2306	return ec._BugConnection(ctx, sel, v)
2307}
2308
2309func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
2310	ret := make(graphql.Array, len(v))
2311	var wg sync.WaitGroup
2312	isLen1 := len(v) == 1
2313	if !isLen1 {
2314		wg.Add(len(v))
2315	}
2316	for i := range v {
2317		i := i
2318		fc := &graphql.FieldContext{
2319			Index:  &i,
2320			Result: &v[i],
2321		}
2322		ctx := graphql.WithFieldContext(ctx, fc)
2323		f := func(i int) {
2324			defer func() {
2325				if r := recover(); r != nil {
2326					ec.Error(ctx, ec.Recover(ctx, r))
2327					ret = nil
2328				}
2329			}()
2330			if !isLen1 {
2331				defer wg.Done()
2332			}
2333			ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
2334		}
2335		if isLen1 {
2336			f(i)
2337		} else {
2338			go f(i)
2339		}
2340
2341	}
2342	wg.Wait()
2343
2344	for _, e := range ret {
2345		if e == graphql.Null {
2346			return graphql.Null
2347		}
2348	}
2349
2350	return ret
2351}
2352
2353func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
2354	if v == nil {
2355		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2356			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2357		}
2358		return graphql.Null
2359	}
2360	return ec._BugEdge(ctx, sel, v)
2361}
2362
2363func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
2364	ret := make(graphql.Array, len(v))
2365	var wg sync.WaitGroup
2366	isLen1 := len(v) == 1
2367	if !isLen1 {
2368		wg.Add(len(v))
2369	}
2370	for i := range v {
2371		i := i
2372		fc := &graphql.FieldContext{
2373			Index:  &i,
2374			Result: &v[i],
2375		}
2376		ctx := graphql.WithFieldContext(ctx, fc)
2377		f := func(i int) {
2378			defer func() {
2379				if r := recover(); r != nil {
2380					ec.Error(ctx, ec.Recover(ctx, r))
2381					ret = nil
2382				}
2383			}()
2384			if !isLen1 {
2385				defer wg.Done()
2386			}
2387			ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐComment(ctx, sel, v[i])
2388		}
2389		if isLen1 {
2390			f(i)
2391		} else {
2392			go f(i)
2393		}
2394
2395	}
2396	wg.Wait()
2397
2398	for _, e := range ret {
2399		if e == graphql.Null {
2400			return graphql.Null
2401		}
2402	}
2403
2404	return ret
2405}
2406
2407func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
2408	if v == nil {
2409		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2410			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2411		}
2412		return graphql.Null
2413	}
2414	return ec._Comment(ctx, sel, v)
2415}
2416
2417func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
2418	return ec._CommentConnection(ctx, sel, &v)
2419}
2420
2421func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
2422	if v == nil {
2423		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2424			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2425		}
2426		return graphql.Null
2427	}
2428	return ec._CommentConnection(ctx, sel, v)
2429}
2430
2431func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
2432	ret := make(graphql.Array, len(v))
2433	var wg sync.WaitGroup
2434	isLen1 := len(v) == 1
2435	if !isLen1 {
2436		wg.Add(len(v))
2437	}
2438	for i := range v {
2439		i := i
2440		fc := &graphql.FieldContext{
2441			Index:  &i,
2442			Result: &v[i],
2443		}
2444		ctx := graphql.WithFieldContext(ctx, fc)
2445		f := func(i int) {
2446			defer func() {
2447				if r := recover(); r != nil {
2448					ec.Error(ctx, ec.Recover(ctx, r))
2449					ret = nil
2450				}
2451			}()
2452			if !isLen1 {
2453				defer wg.Done()
2454			}
2455			ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
2456		}
2457		if isLen1 {
2458			f(i)
2459		} else {
2460			go f(i)
2461		}
2462
2463	}
2464	wg.Wait()
2465
2466	for _, e := range ret {
2467		if e == graphql.Null {
2468			return graphql.Null
2469		}
2470	}
2471
2472	return ret
2473}
2474
2475func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
2476	if v == nil {
2477		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2478			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2479		}
2480		return graphql.Null
2481	}
2482	return ec._CommentEdge(ctx, sel, v)
2483}
2484
2485func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋcommonᚐStatus(ctx context.Context, v interface{}) (common.Status, error) {
2486	var res common.Status
2487	err := res.UnmarshalGQL(v)
2488	return res, graphql.ErrorOnPath(ctx, err)
2489}
2490
2491func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋcommonᚐStatus(ctx context.Context, sel ast.SelectionSet, v common.Status) graphql.Marshaler {
2492	return v
2493}
2494
2495func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
2496	if v == nil {
2497		return graphql.Null
2498	}
2499	return ec._Bug(ctx, sel, v)
2500}
2501
2502// endregion ***************************** type.gotpl *****************************