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