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