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