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