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