graphql: properly namespace Bug to make space for other entities (#1254)

Michael Muré created 1 year ago

Also: use gqlgen directives to help the type auto-binding

Missing:
- namespace mutations
- adapt the webUI queries

Change summary

api/graphql/graph/bug.generated.go                                           |  966 
api/graphql/graph/bug_comment.generated.go                                   |  854 
api/graphql/graph/bug_mutations.generated.go                                 |  468 
api/graphql/graph/bug_operations.generated.go                                |  533 
api/graphql/graph/bug_timeline.generated.go                                  |  339 
api/graphql/graph/label.generated.go                                         |  194 
api/graphql/graph/operation.generated.go                                     |  589 
api/graphql/graph/root.generated.go                                          |  312 
api/graphql/graph/root_.generated.go                                         | 1606 
api/graphql/graph/status.generated.go                                        |   53 
api/graphql/graph/types.generated.go                                         |   34 
api/graphql/graphql_test.go                                                  |   16 
api/graphql/models/edges.go                                                  |    4 
api/graphql/models/gen_models.go                                             |  224 
api/graphql/models/models.go                                                 |    5 
api/graphql/resolvers/bug.go                                                 |   24 
api/graphql/resolvers/bug_operations.go                                      |   61 
api/graphql/resolvers/bug_root.go                                            |   59 
api/graphql/resolvers/bug_timeline.go                                        |   94 
api/graphql/resolvers/comment.go                                             |   22 
api/graphql/resolvers/identity.go                                            |    4 
api/graphql/resolvers/mutation.go                                            |   36 
api/graphql/resolvers/operations.go                                          |   92 
api/graphql/resolvers/root.go                                                |   65 
api/graphql/resolvers/timeline.go                                            |  115 
api/graphql/schema/bug.graphql                                               |   35 
api/graphql/schema/bug_comment.graphql                                       |   26 
api/graphql/schema/bug_mutations.graphql                                     |   94 
api/graphql/schema/bug_operations.graphql                                    |   58 
api/graphql/schema/bug_timeline.graphql                                      |   93 
api/graphql/schema/directives.graphql                                        |   18 
api/graphql/schema/identity.graphql                                          |    2 
api/graphql/schema/label.graphql                                             |   17 
api/graphql/schema/operation.graphql                                         |   25 
api/graphql/schema/repository.graphql                                        |    1 
api/graphql/schema/root.graphql                                              |   21 
api/graphql/schema/status.graphql                                            |    4 
api/graphql/schema/timeline.graphql                                          |   86 
api/graphql/tracer.go                                                        |   28 
go.mod                                                                       |    2 
go.sum                                                                       |    4 
tools.go                                                                     |    2 
webui/packed_assets.go                                                       |    9 
webui/src/components/BugTitleForm/SetTitle.graphql                           |    4 
webui/src/components/CloseBugButton/CloseBug.graphql                         |    4 
webui/src/components/CloseBugWithCommentButton/CloseBugWithComment.graphql   |    4 
webui/src/components/ReopenBugButton/OpenBug.graphql                         |    4 
webui/src/components/ReopenBugWithCommentButton/ReopenBugWithComment.graphql |    4 
webui/src/pages/bug/CommentForm.graphql                                      |    4 
webui/src/pages/bug/EditCommentForm.graphql                                  |    4 
webui/src/pages/bug/EditCommentForm.tsx                                      |    2 
webui/src/pages/bug/LabelChangeFragment.graphql                              |    2 
webui/src/pages/bug/MessageCommentFragment.graphql                           |    2 
webui/src/pages/bug/MessageCreateFragment.graphql                            |    2 
webui/src/pages/bug/SetStatusFragment.graphql                                |    2 
webui/src/pages/bug/SetTitleFragment.graphql                                 |    2 
webui/src/pages/bug/Timeline.tsx                                             |   10 
webui/src/pages/bug/TimelineQuery.graphql                                    |   12 
webui/src/pages/bug/labels/SetLabel.graphql                                  |    4 
webui/src/pages/new/NewBug.graphql                                           |    4 
webui/src/pages/new/NewBugPage.tsx                                           |    2 
61 files changed, 3,895 insertions(+), 3,471 deletions(-)

Detailed changes

api/graphql/graph/bug.generated.go

@@ -13,10 +13,8 @@ import (
 
 	"github.com/99designs/gqlgen/graphql"
 	"github.com/git-bug/git-bug/api/graphql/models"
-	"github.com/git-bug/git-bug/entities/bug"
 	"github.com/git-bug/git-bug/entities/common"
 	"github.com/git-bug/git-bug/entity"
-	"github.com/git-bug/git-bug/repository"
 	"github.com/vektah/gqlparser/v2/ast"
 )
 
@@ -27,14 +25,10 @@ type BugResolver interface {
 
 	Actors(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
 	Participants(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
-	Comments(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
-	Timeline(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
+	Comments(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.BugCommentConnection, error)
+	Timeline(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.BugTimelineItemConnection, error)
 	Operations(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
 }
-type CommentResolver interface {
-	ID(ctx context.Context, obj *bug.Comment) (entity.CombinedId, error)
-	Author(ctx context.Context, obj *bug.Comment) (models.IdentityWrapper, error)
-}
 
 // endregion ************************** generated!.gotpl **************************
 
@@ -790,9 +784,9 @@ func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.Col
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*models.CommentConnection)
+	res := resTmp.(*models.BugCommentConnection)
 	fc.Result = res
-	return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
+	return ec.marshalNBugCommentConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugCommentConnection(ctx, field.Selections, res)
 }
 
 func (ec *executionContext) fieldContext_Bug_comments(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
@@ -804,15 +798,15 @@ func (ec *executionContext) fieldContext_Bug_comments(ctx context.Context, field
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "edges":
-				return ec.fieldContext_CommentConnection_edges(ctx, field)
+				return ec.fieldContext_BugCommentConnection_edges(ctx, field)
 			case "nodes":
-				return ec.fieldContext_CommentConnection_nodes(ctx, field)
+				return ec.fieldContext_BugCommentConnection_nodes(ctx, field)
 			case "pageInfo":
-				return ec.fieldContext_CommentConnection_pageInfo(ctx, field)
+				return ec.fieldContext_BugCommentConnection_pageInfo(ctx, field)
 			case "totalCount":
-				return ec.fieldContext_CommentConnection_totalCount(ctx, field)
+				return ec.fieldContext_BugCommentConnection_totalCount(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type CommentConnection", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugCommentConnection", field.Name)
 		},
 	}
 	defer func() {
@@ -855,9 +849,9 @@ func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.Col
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*models.TimelineItemConnection)
+	res := resTmp.(*models.BugTimelineItemConnection)
 	fc.Result = res
-	return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
+	return ec.marshalNBugTimelineItemConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugTimelineItemConnection(ctx, field.Selections, res)
 }
 
 func (ec *executionContext) fieldContext_Bug_timeline(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
@@ -869,15 +863,15 @@ func (ec *executionContext) fieldContext_Bug_timeline(ctx context.Context, field
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "edges":
-				return ec.fieldContext_TimelineItemConnection_edges(ctx, field)
+				return ec.fieldContext_BugTimelineItemConnection_edges(ctx, field)
 			case "nodes":
-				return ec.fieldContext_TimelineItemConnection_nodes(ctx, field)
+				return ec.fieldContext_BugTimelineItemConnection_nodes(ctx, field)
 			case "pageInfo":
-				return ec.fieldContext_TimelineItemConnection_pageInfo(ctx, field)
+				return ec.fieldContext_BugTimelineItemConnection_pageInfo(ctx, field)
 			case "totalCount":
-				return ec.fieldContext_TimelineItemConnection_totalCount(ctx, field)
+				return ec.fieldContext_BugTimelineItemConnection_totalCount(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type TimelineItemConnection", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugTimelineItemConnection", field.Name)
 		},
 	}
 	defer func() {
@@ -1295,542 +1289,48 @@ func (ec *executionContext) fieldContext_BugEdge_node(_ context.Context, field g
 	return fc, nil
 }
 
-func (ec *executionContext) _Comment_id(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_Comment_id(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.Comment().ID(rctx, obj)
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(entity.CombinedId)
-	fc.Result = res
-	return ec.marshalNCombinedId2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚐCombinedId(ctx, field.Selections, res)
-}
+// endregion **************************** field.gotpl *****************************
 
-func (ec *executionContext) fieldContext_Comment_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "Comment",
-		Field:      field,
-		IsMethod:   true,
-		IsResolver: true,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			return nil, errors.New("field of type CombinedId does not have child fields")
-		},
-	}
-	return fc, nil
-}
+// region    **************************** input.gotpl *****************************
 
-func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_Comment_author(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.Comment().Author(rctx, obj)
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(models.IdentityWrapper)
-	fc.Result = res
-	return ec.marshalNIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
-}
+// endregion **************************** input.gotpl *****************************
 
-func (ec *executionContext) fieldContext_Comment_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "Comment",
-		Field:      field,
-		IsMethod:   true,
-		IsResolver: true,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			switch field.Name {
-			case "id":
-				return ec.fieldContext_Identity_id(ctx, field)
-			case "humanId":
-				return ec.fieldContext_Identity_humanId(ctx, field)
-			case "name":
-				return ec.fieldContext_Identity_name(ctx, field)
-			case "email":
-				return ec.fieldContext_Identity_email(ctx, field)
-			case "login":
-				return ec.fieldContext_Identity_login(ctx, field)
-			case "displayName":
-				return ec.fieldContext_Identity_displayName(ctx, field)
-			case "avatarUrl":
-				return ec.fieldContext_Identity_avatarUrl(ctx, field)
-			case "isProtected":
-				return ec.fieldContext_Identity_isProtected(ctx, field)
-			}
-			return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
-		},
-	}
-	return fc, nil
-}
+// region    ************************** interface.gotpl ***************************
 
-func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_Comment_message(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.Message, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(string)
-	fc.Result = res
-	return ec.marshalNString2string(ctx, field.Selections, res)
-}
+// endregion ************************** interface.gotpl ***************************
 
-func (ec *executionContext) fieldContext_Comment_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "Comment",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			return nil, errors.New("field of type String does not have child fields")
-		},
-	}
-	return fc, nil
-}
+// region    **************************** object.gotpl ****************************
 
-func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_Comment_files(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.Files, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.([]repository.Hash)
-	fc.Result = res
-	return ec.marshalNHash2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
-}
+var bugImplementors = []string{"Bug", "Authored"}
 
-func (ec *executionContext) fieldContext_Comment_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "Comment",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			return nil, errors.New("field of type Hash does not have child fields")
-		},
-	}
-	return fc, nil
-}
+func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
+	fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
 
-func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CommentConnection_edges(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.Edges, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.([]*models.CommentEdge)
-	fc.Result = res
-	return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx, field.Selections, res)
-}
+	out := graphql.NewFieldSet(fields)
+	deferred := make(map[string]*graphql.FieldSet)
+	for i, field := range fields {
+		switch field.Name {
+		case "__typename":
+			out.Values[i] = graphql.MarshalString("Bug")
+		case "id":
+			out.Values[i] = ec._Bug_id(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				atomic.AddUint32(&out.Invalids, 1)
+			}
+		case "humanId":
+			field := field
 
-func (ec *executionContext) fieldContext_CommentConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "CommentConnection",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			switch field.Name {
-			case "cursor":
-				return ec.fieldContext_CommentEdge_cursor(ctx, field)
-			case "node":
-				return ec.fieldContext_CommentEdge_node(ctx, field)
-			}
-			return nil, fmt.Errorf("no field named %q was found under type CommentEdge", field.Name)
-		},
-	}
-	return fc, nil
-}
-
-func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CommentConnection_nodes(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.Nodes, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.([]*bug.Comment)
-	fc.Result = res
-	return ec.marshalNComment2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐCommentᚄ(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_CommentConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "CommentConnection",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			switch field.Name {
-			case "id":
-				return ec.fieldContext_Comment_id(ctx, field)
-			case "author":
-				return ec.fieldContext_Comment_author(ctx, field)
-			case "message":
-				return ec.fieldContext_Comment_message(ctx, field)
-			case "files":
-				return ec.fieldContext_Comment_files(ctx, field)
-			}
-			return nil, fmt.Errorf("no field named %q was found under type Comment", field.Name)
-		},
-	}
-	return fc, nil
-}
-
-func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CommentConnection_pageInfo(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.PageInfo, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(*models.PageInfo)
-	fc.Result = res
-	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_CommentConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "CommentConnection",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			switch field.Name {
-			case "hasNextPage":
-				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
-			case "hasPreviousPage":
-				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
-			case "startCursor":
-				return ec.fieldContext_PageInfo_startCursor(ctx, field)
-			case "endCursor":
-				return ec.fieldContext_PageInfo_endCursor(ctx, field)
-			}
-			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
-		},
-	}
-	return fc, nil
-}
-
-func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CommentConnection_totalCount(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.TotalCount, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(int)
-	fc.Result = res
-	return ec.marshalNInt2int(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_CommentConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "CommentConnection",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			return nil, errors.New("field of type Int does not have child fields")
-		},
-	}
-	return fc, nil
-}
-
-func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CommentEdge_cursor(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.Cursor, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(string)
-	fc.Result = res
-	return ec.marshalNString2string(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_CommentEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "CommentEdge",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			return nil, errors.New("field of type String does not have child fields")
-		},
-	}
-	return fc, nil
-}
-
-func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CommentEdge_node(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.Node, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(*bug.Comment)
-	fc.Result = res
-	return ec.marshalNComment2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐComment(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_CommentEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "CommentEdge",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			switch field.Name {
-			case "id":
-				return ec.fieldContext_Comment_id(ctx, field)
-			case "author":
-				return ec.fieldContext_Comment_author(ctx, field)
-			case "message":
-				return ec.fieldContext_Comment_message(ctx, field)
-			case "files":
-				return ec.fieldContext_Comment_files(ctx, field)
-			}
-			return nil, fmt.Errorf("no field named %q was found under type Comment", field.Name)
-		},
-	}
-	return fc, nil
-}
-
-// endregion **************************** field.gotpl *****************************
-
-// region    **************************** input.gotpl *****************************
-
-// endregion **************************** input.gotpl *****************************
-
-// region    ************************** interface.gotpl ***************************
-
-// endregion ************************** interface.gotpl ***************************
-
-// region    **************************** object.gotpl ****************************
-
-var bugImplementors = []string{"Bug", "Authored"}
-
-func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
-	fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
-
-	out := graphql.NewFieldSet(fields)
-	deferred := make(map[string]*graphql.FieldSet)
-	for i, field := range fields {
-		switch field.Name {
-		case "__typename":
-			out.Values[i] = graphql.MarshalString("Bug")
-		case "id":
-			out.Values[i] = ec._Bug_id(ctx, field, obj)
-			if out.Values[i] == graphql.Null {
-				atomic.AddUint32(&out.Invalids, 1)
-			}
-		case "humanId":
-			field := field
-
-			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
-				defer func() {
-					if r := recover(); r != nil {
-						ec.Error(ctx, ec.Recover(ctx, r))
-					}
-				}()
-				res = ec._Bug_humanId(ctx, field, obj)
-				if res == graphql.Null {
-					atomic.AddUint32(&fs.Invalids, 1)
-				}
-				return res
+			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
+				defer func() {
+					if r := recover(); r != nil {
+						ec.Error(ctx, ec.Recover(ctx, r))
+					}
+				}()
+				res = ec._Bug_humanId(ctx, field, obj)
+				if res == graphql.Null {
+					atomic.AddUint32(&fs.Invalids, 1)
+				}
+				return res
 			}
 
 			if field.Deferrable != nil {
@@ -2184,233 +1684,19 @@ func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet,
 	return out
 }
 
-var commentImplementors = []string{"Comment", "Authored"}
+// endregion **************************** object.gotpl ****************************
 
-func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
-	fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
+// region    ***************************** type.gotpl *****************************
 
-	out := graphql.NewFieldSet(fields)
-	deferred := make(map[string]*graphql.FieldSet)
-	for i, field := range fields {
-		switch field.Name {
-		case "__typename":
-			out.Values[i] = graphql.MarshalString("Comment")
-		case "id":
-			field := field
-
-			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
-				defer func() {
-					if r := recover(); r != nil {
-						ec.Error(ctx, ec.Recover(ctx, r))
-					}
-				}()
-				res = ec._Comment_id(ctx, field, obj)
-				if res == graphql.Null {
-					atomic.AddUint32(&fs.Invalids, 1)
-				}
-				return res
-			}
-
-			if field.Deferrable != nil {
-				dfs, ok := deferred[field.Deferrable.Label]
-				di := 0
-				if ok {
-					dfs.AddField(field)
-					di = len(dfs.Values) - 1
-				} else {
-					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
-					deferred[field.Deferrable.Label] = dfs
-				}
-				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
-					return innerFunc(ctx, dfs)
-				})
-
-				// don't run the out.Concurrently() call below
-				out.Values[i] = graphql.Null
-				continue
-			}
-
-			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
-		case "author":
-			field := field
-
-			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
-				defer func() {
-					if r := recover(); r != nil {
-						ec.Error(ctx, ec.Recover(ctx, r))
-					}
-				}()
-				res = ec._Comment_author(ctx, field, obj)
-				if res == graphql.Null {
-					atomic.AddUint32(&fs.Invalids, 1)
-				}
-				return res
-			}
-
-			if field.Deferrable != nil {
-				dfs, ok := deferred[field.Deferrable.Label]
-				di := 0
-				if ok {
-					dfs.AddField(field)
-					di = len(dfs.Values) - 1
-				} else {
-					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
-					deferred[field.Deferrable.Label] = dfs
-				}
-				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
-					return innerFunc(ctx, dfs)
-				})
-
-				// don't run the out.Concurrently() call below
-				out.Values[i] = graphql.Null
-				continue
-			}
-
-			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
-		case "message":
-			out.Values[i] = ec._Comment_message(ctx, field, obj)
-			if out.Values[i] == graphql.Null {
-				atomic.AddUint32(&out.Invalids, 1)
-			}
-		case "files":
-			out.Values[i] = ec._Comment_files(ctx, field, obj)
-			if out.Values[i] == graphql.Null {
-				atomic.AddUint32(&out.Invalids, 1)
-			}
-		default:
-			panic("unknown field " + strconv.Quote(field.Name))
-		}
-	}
-	out.Dispatch(ctx)
-	if out.Invalids > 0 {
-		return graphql.Null
-	}
-
-	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
-
-	for label, dfs := range deferred {
-		ec.processDeferredGroup(graphql.DeferredGroup{
-			Label:    label,
-			Path:     graphql.GetPath(ctx),
-			FieldSet: dfs,
-			Context:  ctx,
-		})
-	}
-
-	return out
-}
-
-var commentConnectionImplementors = []string{"CommentConnection"}
-
-func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
-	fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
-
-	out := graphql.NewFieldSet(fields)
-	deferred := make(map[string]*graphql.FieldSet)
-	for i, field := range fields {
-		switch field.Name {
-		case "__typename":
-			out.Values[i] = graphql.MarshalString("CommentConnection")
-		case "edges":
-			out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
-			if out.Values[i] == graphql.Null {
-				out.Invalids++
-			}
-		case "nodes":
-			out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
-			if out.Values[i] == graphql.Null {
-				out.Invalids++
-			}
-		case "pageInfo":
-			out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
-			if out.Values[i] == graphql.Null {
-				out.Invalids++
-			}
-		case "totalCount":
-			out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
-			if out.Values[i] == graphql.Null {
-				out.Invalids++
-			}
-		default:
-			panic("unknown field " + strconv.Quote(field.Name))
-		}
-	}
-	out.Dispatch(ctx)
-	if out.Invalids > 0 {
-		return graphql.Null
-	}
-
-	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
-
-	for label, dfs := range deferred {
-		ec.processDeferredGroup(graphql.DeferredGroup{
-			Label:    label,
-			Path:     graphql.GetPath(ctx),
-			FieldSet: dfs,
-			Context:  ctx,
-		})
-	}
-
-	return out
-}
-
-var commentEdgeImplementors = []string{"CommentEdge"}
-
-func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
-	fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
-
-	out := graphql.NewFieldSet(fields)
-	deferred := make(map[string]*graphql.FieldSet)
-	for i, field := range fields {
-		switch field.Name {
-		case "__typename":
-			out.Values[i] = graphql.MarshalString("CommentEdge")
-		case "cursor":
-			out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
-			if out.Values[i] == graphql.Null {
-				out.Invalids++
-			}
-		case "node":
-			out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
-			if out.Values[i] == graphql.Null {
-				out.Invalids++
-			}
-		default:
-			panic("unknown field " + strconv.Quote(field.Name))
-		}
-	}
-	out.Dispatch(ctx)
-	if out.Invalids > 0 {
-		return graphql.Null
-	}
-
-	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
-
-	for label, dfs := range deferred {
-		ec.processDeferredGroup(graphql.DeferredGroup{
-			Label:    label,
-			Path:     graphql.GetPath(ctx),
-			FieldSet: dfs,
-			Context:  ctx,
-		})
-	}
-
-	return out
-}
-
-// endregion **************************** object.gotpl ****************************
-
-// region    ***************************** type.gotpl *****************************
-
-func (ec *executionContext) marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
-	if v == nil {
-		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
-			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
-		}
-		return graphql.Null
-	}
-	return ec._Bug(ctx, sel, v)
-}
+func (ec *executionContext) marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
+	if v == nil {
+		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
+		}
+		return graphql.Null
+	}
+	return ec._Bug(ctx, sel, v)
+}
 
 func (ec *executionContext) marshalNBug2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BugWrapper) graphql.Marshaler {
 	ret := make(graphql.Array, len(v))
@@ -2524,138 +1810,6 @@ func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑ
 	return ec._BugEdge(ctx, sel, v)
 }
 
-func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
-	ret := make(graphql.Array, len(v))
-	var wg sync.WaitGroup
-	isLen1 := len(v) == 1
-	if !isLen1 {
-		wg.Add(len(v))
-	}
-	for i := range v {
-		i := i
-		fc := &graphql.FieldContext{
-			Index:  &i,
-			Result: &v[i],
-		}
-		ctx := graphql.WithFieldContext(ctx, fc)
-		f := func(i int) {
-			defer func() {
-				if r := recover(); r != nil {
-					ec.Error(ctx, ec.Recover(ctx, r))
-					ret = nil
-				}
-			}()
-			if !isLen1 {
-				defer wg.Done()
-			}
-			ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐComment(ctx, sel, v[i])
-		}
-		if isLen1 {
-			f(i)
-		} else {
-			go f(i)
-		}
-
-	}
-	wg.Wait()
-
-	for _, e := range ret {
-		if e == graphql.Null {
-			return graphql.Null
-		}
-	}
-
-	return ret
-}
-
-func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
-	if v == nil {
-		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
-			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
-		}
-		return graphql.Null
-	}
-	return ec._Comment(ctx, sel, v)
-}
-
-func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
-	return ec._CommentConnection(ctx, sel, &v)
-}
-
-func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
-	if v == nil {
-		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
-			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
-		}
-		return graphql.Null
-	}
-	return ec._CommentConnection(ctx, sel, v)
-}
-
-func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
-	ret := make(graphql.Array, len(v))
-	var wg sync.WaitGroup
-	isLen1 := len(v) == 1
-	if !isLen1 {
-		wg.Add(len(v))
-	}
-	for i := range v {
-		i := i
-		fc := &graphql.FieldContext{
-			Index:  &i,
-			Result: &v[i],
-		}
-		ctx := graphql.WithFieldContext(ctx, fc)
-		f := func(i int) {
-			defer func() {
-				if r := recover(); r != nil {
-					ec.Error(ctx, ec.Recover(ctx, r))
-					ret = nil
-				}
-			}()
-			if !isLen1 {
-				defer wg.Done()
-			}
-			ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
-		}
-		if isLen1 {
-			f(i)
-		} else {
-			go f(i)
-		}
-
-	}
-	wg.Wait()
-
-	for _, e := range ret {
-		if e == graphql.Null {
-			return graphql.Null
-		}
-	}
-
-	return ret
-}
-
-func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
-	if v == nil {
-		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
-			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
-		}
-		return graphql.Null
-	}
-	return ec._CommentEdge(ctx, sel, v)
-}
-
-func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋcommonᚐStatus(ctx context.Context, v interface{}) (common.Status, error) {
-	var res common.Status
-	err := res.UnmarshalGQL(v)
-	return res, graphql.ErrorOnPath(ctx, err)
-}
-
-func (ec *executionContext) marshalNStatus2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋcommonᚐStatus(ctx context.Context, sel ast.SelectionSet, v common.Status) graphql.Marshaler {
-	return v
-}
-
 func (ec *executionContext) marshalOBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
 	if v == nil {
 		return graphql.Null

api/graphql/graph/bug_comment.generated.go

@@ -0,0 +1,854 @@
+// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
+
+package graph
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strconv"
+	"sync"
+	"sync/atomic"
+
+	"github.com/99designs/gqlgen/graphql"
+	"github.com/git-bug/git-bug/api/graphql/models"
+	"github.com/git-bug/git-bug/entities/bug"
+	"github.com/git-bug/git-bug/entity"
+	"github.com/git-bug/git-bug/repository"
+	"github.com/vektah/gqlparser/v2/ast"
+)
+
+// region    ************************** generated!.gotpl **************************
+
+type BugCommentResolver interface {
+	Author(ctx context.Context, obj *bug.Comment) (models.IdentityWrapper, error)
+}
+
+// endregion ************************** generated!.gotpl **************************
+
+// region    ***************************** args.gotpl *****************************
+
+// endregion ***************************** args.gotpl *****************************
+
+// region    ************************** directives.gotpl **************************
+
+// endregion ************************** directives.gotpl **************************
+
+// region    **************************** field.gotpl *****************************
+
+func (ec *executionContext) _BugComment_id(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugComment_id(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.CombinedId(), nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(entity.CombinedId)
+	fc.Result = res
+	return ec.marshalNCombinedId2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚐCombinedId(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_BugComment_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "BugComment",
+		Field:      field,
+		IsMethod:   true,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type CombinedId does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _BugComment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugComment_author(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return ec.resolvers.BugComment().Author(rctx, obj)
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(models.IdentityWrapper)
+	fc.Result = res
+	return ec.marshalNIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_BugComment_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "BugComment",
+		Field:      field,
+		IsMethod:   true,
+		IsResolver: true,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			switch field.Name {
+			case "id":
+				return ec.fieldContext_Identity_id(ctx, field)
+			case "humanId":
+				return ec.fieldContext_Identity_humanId(ctx, field)
+			case "name":
+				return ec.fieldContext_Identity_name(ctx, field)
+			case "email":
+				return ec.fieldContext_Identity_email(ctx, field)
+			case "login":
+				return ec.fieldContext_Identity_login(ctx, field)
+			case "displayName":
+				return ec.fieldContext_Identity_displayName(ctx, field)
+			case "avatarUrl":
+				return ec.fieldContext_Identity_avatarUrl(ctx, field)
+			case "isProtected":
+				return ec.fieldContext_Identity_isProtected(ctx, field)
+			}
+			return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _BugComment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugComment_message(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Message, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(string)
+	fc.Result = res
+	return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_BugComment_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "BugComment",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type String does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _BugComment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugComment_files(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Files, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.([]repository.Hash)
+	fc.Result = res
+	return ec.marshalNHash2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_BugComment_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "BugComment",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type Hash does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _BugCommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugCommentConnection) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCommentConnection_edges(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Edges, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.([]*models.BugCommentEdge)
+	fc.Result = res
+	return ec.marshalNBugCommentEdge2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugCommentEdgeᚄ(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_BugCommentConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "BugCommentConnection",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			switch field.Name {
+			case "cursor":
+				return ec.fieldContext_BugCommentEdge_cursor(ctx, field)
+			case "node":
+				return ec.fieldContext_BugCommentEdge_node(ctx, field)
+			}
+			return nil, fmt.Errorf("no field named %q was found under type BugCommentEdge", field.Name)
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _BugCommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugCommentConnection) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCommentConnection_nodes(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Nodes, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.([]*bug.Comment)
+	fc.Result = res
+	return ec.marshalNBugComment2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐCommentᚄ(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_BugCommentConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "BugCommentConnection",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			switch field.Name {
+			case "id":
+				return ec.fieldContext_BugComment_id(ctx, field)
+			case "author":
+				return ec.fieldContext_BugComment_author(ctx, field)
+			case "message":
+				return ec.fieldContext_BugComment_message(ctx, field)
+			case "files":
+				return ec.fieldContext_BugComment_files(ctx, field)
+			}
+			return nil, fmt.Errorf("no field named %q was found under type BugComment", field.Name)
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _BugCommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugCommentConnection) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCommentConnection_pageInfo(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.PageInfo, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(*models.PageInfo)
+	fc.Result = res
+	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_BugCommentConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "BugCommentConnection",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			switch field.Name {
+			case "hasNextPage":
+				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
+			case "hasPreviousPage":
+				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
+			case "startCursor":
+				return ec.fieldContext_PageInfo_startCursor(ctx, field)
+			case "endCursor":
+				return ec.fieldContext_PageInfo_endCursor(ctx, field)
+			}
+			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _BugCommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugCommentConnection) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCommentConnection_totalCount(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.TotalCount, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(int)
+	fc.Result = res
+	return ec.marshalNInt2int(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_BugCommentConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "BugCommentConnection",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type Int does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _BugCommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugCommentEdge) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCommentEdge_cursor(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Cursor, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(string)
+	fc.Result = res
+	return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_BugCommentEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "BugCommentEdge",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type String does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _BugCommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugCommentEdge) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCommentEdge_node(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Node, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(*bug.Comment)
+	fc.Result = res
+	return ec.marshalNBugComment2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐComment(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_BugCommentEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "BugCommentEdge",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			switch field.Name {
+			case "id":
+				return ec.fieldContext_BugComment_id(ctx, field)
+			case "author":
+				return ec.fieldContext_BugComment_author(ctx, field)
+			case "message":
+				return ec.fieldContext_BugComment_message(ctx, field)
+			case "files":
+				return ec.fieldContext_BugComment_files(ctx, field)
+			}
+			return nil, fmt.Errorf("no field named %q was found under type BugComment", field.Name)
+		},
+	}
+	return fc, nil
+}
+
+// endregion **************************** field.gotpl *****************************
+
+// region    **************************** input.gotpl *****************************
+
+// endregion **************************** input.gotpl *****************************
+
+// region    ************************** interface.gotpl ***************************
+
+// endregion ************************** interface.gotpl ***************************
+
+// region    **************************** object.gotpl ****************************
+
+var bugCommentImplementors = []string{"BugComment", "Authored"}
+
+func (ec *executionContext) _BugComment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
+	fields := graphql.CollectFields(ec.OperationContext, sel, bugCommentImplementors)
+
+	out := graphql.NewFieldSet(fields)
+	deferred := make(map[string]*graphql.FieldSet)
+	for i, field := range fields {
+		switch field.Name {
+		case "__typename":
+			out.Values[i] = graphql.MarshalString("BugComment")
+		case "id":
+			out.Values[i] = ec._BugComment_id(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				atomic.AddUint32(&out.Invalids, 1)
+			}
+		case "author":
+			field := field
+
+			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
+				defer func() {
+					if r := recover(); r != nil {
+						ec.Error(ctx, ec.Recover(ctx, r))
+					}
+				}()
+				res = ec._BugComment_author(ctx, field, obj)
+				if res == graphql.Null {
+					atomic.AddUint32(&fs.Invalids, 1)
+				}
+				return res
+			}
+
+			if field.Deferrable != nil {
+				dfs, ok := deferred[field.Deferrable.Label]
+				di := 0
+				if ok {
+					dfs.AddField(field)
+					di = len(dfs.Values) - 1
+				} else {
+					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+					deferred[field.Deferrable.Label] = dfs
+				}
+				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+					return innerFunc(ctx, dfs)
+				})
+
+				// don't run the out.Concurrently() call below
+				out.Values[i] = graphql.Null
+				continue
+			}
+
+			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+		case "message":
+			out.Values[i] = ec._BugComment_message(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				atomic.AddUint32(&out.Invalids, 1)
+			}
+		case "files":
+			out.Values[i] = ec._BugComment_files(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				atomic.AddUint32(&out.Invalids, 1)
+			}
+		default:
+			panic("unknown field " + strconv.Quote(field.Name))
+		}
+	}
+	out.Dispatch(ctx)
+	if out.Invalids > 0 {
+		return graphql.Null
+	}
+
+	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+	for label, dfs := range deferred {
+		ec.processDeferredGroup(graphql.DeferredGroup{
+			Label:    label,
+			Path:     graphql.GetPath(ctx),
+			FieldSet: dfs,
+			Context:  ctx,
+		})
+	}
+
+	return out
+}
+
+var bugCommentConnectionImplementors = []string{"BugCommentConnection"}
+
+func (ec *executionContext) _BugCommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugCommentConnection) graphql.Marshaler {
+	fields := graphql.CollectFields(ec.OperationContext, sel, bugCommentConnectionImplementors)
+
+	out := graphql.NewFieldSet(fields)
+	deferred := make(map[string]*graphql.FieldSet)
+	for i, field := range fields {
+		switch field.Name {
+		case "__typename":
+			out.Values[i] = graphql.MarshalString("BugCommentConnection")
+		case "edges":
+			out.Values[i] = ec._BugCommentConnection_edges(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				out.Invalids++
+			}
+		case "nodes":
+			out.Values[i] = ec._BugCommentConnection_nodes(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				out.Invalids++
+			}
+		case "pageInfo":
+			out.Values[i] = ec._BugCommentConnection_pageInfo(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				out.Invalids++
+			}
+		case "totalCount":
+			out.Values[i] = ec._BugCommentConnection_totalCount(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				out.Invalids++
+			}
+		default:
+			panic("unknown field " + strconv.Quote(field.Name))
+		}
+	}
+	out.Dispatch(ctx)
+	if out.Invalids > 0 {
+		return graphql.Null
+	}
+
+	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+	for label, dfs := range deferred {
+		ec.processDeferredGroup(graphql.DeferredGroup{
+			Label:    label,
+			Path:     graphql.GetPath(ctx),
+			FieldSet: dfs,
+			Context:  ctx,
+		})
+	}
+
+	return out
+}
+
+var bugCommentEdgeImplementors = []string{"BugCommentEdge"}
+
+func (ec *executionContext) _BugCommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugCommentEdge) graphql.Marshaler {
+	fields := graphql.CollectFields(ec.OperationContext, sel, bugCommentEdgeImplementors)
+
+	out := graphql.NewFieldSet(fields)
+	deferred := make(map[string]*graphql.FieldSet)
+	for i, field := range fields {
+		switch field.Name {
+		case "__typename":
+			out.Values[i] = graphql.MarshalString("BugCommentEdge")
+		case "cursor":
+			out.Values[i] = ec._BugCommentEdge_cursor(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				out.Invalids++
+			}
+		case "node":
+			out.Values[i] = ec._BugCommentEdge_node(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				out.Invalids++
+			}
+		default:
+			panic("unknown field " + strconv.Quote(field.Name))
+		}
+	}
+	out.Dispatch(ctx)
+	if out.Invalids > 0 {
+		return graphql.Null
+	}
+
+	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+	for label, dfs := range deferred {
+		ec.processDeferredGroup(graphql.DeferredGroup{
+			Label:    label,
+			Path:     graphql.GetPath(ctx),
+			FieldSet: dfs,
+			Context:  ctx,
+		})
+	}
+
+	return out
+}
+
+// endregion **************************** object.gotpl ****************************
+
+// region    ***************************** type.gotpl *****************************
+
+func (ec *executionContext) marshalNBugComment2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐCommentᚄ(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
+	ret := make(graphql.Array, len(v))
+	var wg sync.WaitGroup
+	isLen1 := len(v) == 1
+	if !isLen1 {
+		wg.Add(len(v))
+	}
+	for i := range v {
+		i := i
+		fc := &graphql.FieldContext{
+			Index:  &i,
+			Result: &v[i],
+		}
+		ctx := graphql.WithFieldContext(ctx, fc)
+		f := func(i int) {
+			defer func() {
+				if r := recover(); r != nil {
+					ec.Error(ctx, ec.Recover(ctx, r))
+					ret = nil
+				}
+			}()
+			if !isLen1 {
+				defer wg.Done()
+			}
+			ret[i] = ec.marshalNBugComment2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐComment(ctx, sel, v[i])
+		}
+		if isLen1 {
+			f(i)
+		} else {
+			go f(i)
+		}
+
+	}
+	wg.Wait()
+
+	for _, e := range ret {
+		if e == graphql.Null {
+			return graphql.Null
+		}
+	}
+
+	return ret
+}
+
+func (ec *executionContext) marshalNBugComment2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
+	if v == nil {
+		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
+		}
+		return graphql.Null
+	}
+	return ec._BugComment(ctx, sel, v)
+}
+
+func (ec *executionContext) marshalNBugCommentConnection2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.BugCommentConnection) graphql.Marshaler {
+	return ec._BugCommentConnection(ctx, sel, &v)
+}
+
+func (ec *executionContext) marshalNBugCommentConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugCommentConnection) graphql.Marshaler {
+	if v == nil {
+		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
+		}
+		return graphql.Null
+	}
+	return ec._BugCommentConnection(ctx, sel, v)
+}
+
+func (ec *executionContext) marshalNBugCommentEdge2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugCommentEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugCommentEdge) graphql.Marshaler {
+	ret := make(graphql.Array, len(v))
+	var wg sync.WaitGroup
+	isLen1 := len(v) == 1
+	if !isLen1 {
+		wg.Add(len(v))
+	}
+	for i := range v {
+		i := i
+		fc := &graphql.FieldContext{
+			Index:  &i,
+			Result: &v[i],
+		}
+		ctx := graphql.WithFieldContext(ctx, fc)
+		f := func(i int) {
+			defer func() {
+				if r := recover(); r != nil {
+					ec.Error(ctx, ec.Recover(ctx, r))
+					ret = nil
+				}
+			}()
+			if !isLen1 {
+				defer wg.Done()
+			}
+			ret[i] = ec.marshalNBugCommentEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugCommentEdge(ctx, sel, v[i])
+		}
+		if isLen1 {
+			f(i)
+		} else {
+			go f(i)
+		}
+
+	}
+	wg.Wait()
+
+	for _, e := range ret {
+		if e == graphql.Null {
+			return graphql.Null
+		}
+	}
+
+	return ret
+}
+
+func (ec *executionContext) marshalNBugCommentEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugCommentEdge) graphql.Marshaler {
+	if v == nil {
+		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
+		}
+		return graphql.Null
+	}
+	return ec._BugCommentEdge(ctx, sel, v)
+}
+
+// endregion ***************************** type.gotpl *****************************

api/graphql/graph/mutations.generated.go → api/graphql/graph/bug_mutations.generated.go

@@ -7,13 +7,11 @@ import (
 	"errors"
 	"fmt"
 	"strconv"
-	"sync"
 	"sync/atomic"
 
 	"github.com/99designs/gqlgen/graphql"
 	"github.com/git-bug/git-bug/api/graphql/models"
 	"github.com/git-bug/git-bug/entities/bug"
-	"github.com/git-bug/git-bug/entities/common"
 	"github.com/vektah/gqlparser/v2/ast"
 )
 
@@ -31,8 +29,8 @@ import (
 
 // region    **************************** field.gotpl *****************************
 
-func (ec *executionContext) _AddCommentAndCloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentAndCloseBugPayload_clientMutationId(ctx, field)
+func (ec *executionContext) _BugAddCommentAndClosePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndClosePayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentAndClosePayload_clientMutationId(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -59,9 +57,9 @@ func (ec *executionContext) _AddCommentAndCloseBugPayload_clientMutationId(ctx c
 	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentAndCloseBugPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentAndClosePayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentAndCloseBugPayload",
+		Object:     "BugAddCommentAndClosePayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -72,8 +70,8 @@ func (ec *executionContext) fieldContext_AddCommentAndCloseBugPayload_clientMuta
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentAndCloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentAndCloseBugPayload_bug(ctx, field)
+func (ec *executionContext) _BugAddCommentAndClosePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndClosePayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentAndClosePayload_bug(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -103,9 +101,9 @@ func (ec *executionContext) _AddCommentAndCloseBugPayload_bug(ctx context.Contex
 	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentAndCloseBugPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentAndClosePayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentAndCloseBugPayload",
+		Object:     "BugAddCommentAndClosePayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -144,8 +142,8 @@ func (ec *executionContext) fieldContext_AddCommentAndCloseBugPayload_bug(_ cont
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentAndCloseBugPayload_commentOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentAndCloseBugPayload_commentOperation(ctx, field)
+func (ec *executionContext) _BugAddCommentAndClosePayload_commentOperation(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndClosePayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentAndClosePayload_commentOperation(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -172,36 +170,36 @@ func (ec *executionContext) _AddCommentAndCloseBugPayload_commentOperation(ctx c
 	}
 	res := resTmp.(*bug.AddCommentOperation)
 	fc.Result = res
-	return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
+	return ec.marshalNBugAddCommentOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentAndCloseBugPayload_commentOperation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentAndClosePayload_commentOperation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentAndCloseBugPayload",
+		Object:     "BugAddCommentAndClosePayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "id":
-				return ec.fieldContext_AddCommentOperation_id(ctx, field)
+				return ec.fieldContext_BugAddCommentOperation_id(ctx, field)
 			case "author":
-				return ec.fieldContext_AddCommentOperation_author(ctx, field)
+				return ec.fieldContext_BugAddCommentOperation_author(ctx, field)
 			case "date":
-				return ec.fieldContext_AddCommentOperation_date(ctx, field)
+				return ec.fieldContext_BugAddCommentOperation_date(ctx, field)
 			case "message":
-				return ec.fieldContext_AddCommentOperation_message(ctx, field)
+				return ec.fieldContext_BugAddCommentOperation_message(ctx, field)
 			case "files":
-				return ec.fieldContext_AddCommentOperation_files(ctx, field)
+				return ec.fieldContext_BugAddCommentOperation_files(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type AddCommentOperation", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugAddCommentOperation", field.Name)
 		},
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentAndCloseBugPayload_statusOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentAndCloseBugPayload_statusOperation(ctx, field)
+func (ec *executionContext) _BugAddCommentAndClosePayload_statusOperation(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndClosePayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentAndClosePayload_statusOperation(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -228,34 +226,34 @@ func (ec *executionContext) _AddCommentAndCloseBugPayload_statusOperation(ctx co
 	}
 	res := resTmp.(*bug.SetStatusOperation)
 	fc.Result = res
-	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
+	return ec.marshalNBugSetStatusOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentAndCloseBugPayload_statusOperation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentAndClosePayload_statusOperation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentAndCloseBugPayload",
+		Object:     "BugAddCommentAndClosePayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "id":
-				return ec.fieldContext_SetStatusOperation_id(ctx, field)
+				return ec.fieldContext_BugSetStatusOperation_id(ctx, field)
 			case "author":
-				return ec.fieldContext_SetStatusOperation_author(ctx, field)
+				return ec.fieldContext_BugSetStatusOperation_author(ctx, field)
 			case "date":
-				return ec.fieldContext_SetStatusOperation_date(ctx, field)
+				return ec.fieldContext_BugSetStatusOperation_date(ctx, field)
 			case "status":
-				return ec.fieldContext_SetStatusOperation_status(ctx, field)
+				return ec.fieldContext_BugSetStatusOperation_status(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type SetStatusOperation", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugSetStatusOperation", field.Name)
 		},
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentAndReopenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentAndReopenBugPayload_clientMutationId(ctx, field)
+func (ec *executionContext) _BugAddCommentAndReopenPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndReopenPayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentAndReopenPayload_clientMutationId(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -282,9 +280,9 @@ func (ec *executionContext) _AddCommentAndReopenBugPayload_clientMutationId(ctx
 	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentAndReopenBugPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentAndReopenPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentAndReopenBugPayload",
+		Object:     "BugAddCommentAndReopenPayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -295,8 +293,8 @@ func (ec *executionContext) fieldContext_AddCommentAndReopenBugPayload_clientMut
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentAndReopenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentAndReopenBugPayload_bug(ctx, field)
+func (ec *executionContext) _BugAddCommentAndReopenPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndReopenPayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentAndReopenPayload_bug(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -326,9 +324,9 @@ func (ec *executionContext) _AddCommentAndReopenBugPayload_bug(ctx context.Conte
 	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentAndReopenBugPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentAndReopenPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentAndReopenBugPayload",
+		Object:     "BugAddCommentAndReopenPayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -367,8 +365,8 @@ func (ec *executionContext) fieldContext_AddCommentAndReopenBugPayload_bug(_ con
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentAndReopenBugPayload_commentOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentAndReopenBugPayload_commentOperation(ctx, field)
+func (ec *executionContext) _BugAddCommentAndReopenPayload_commentOperation(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndReopenPayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentAndReopenPayload_commentOperation(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -395,36 +393,36 @@ func (ec *executionContext) _AddCommentAndReopenBugPayload_commentOperation(ctx
 	}
 	res := resTmp.(*bug.AddCommentOperation)
 	fc.Result = res
-	return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
+	return ec.marshalNBugAddCommentOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentAndReopenBugPayload_commentOperation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentAndReopenPayload_commentOperation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentAndReopenBugPayload",
+		Object:     "BugAddCommentAndReopenPayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "id":
-				return ec.fieldContext_AddCommentOperation_id(ctx, field)
+				return ec.fieldContext_BugAddCommentOperation_id(ctx, field)
 			case "author":
-				return ec.fieldContext_AddCommentOperation_author(ctx, field)
+				return ec.fieldContext_BugAddCommentOperation_author(ctx, field)
 			case "date":
-				return ec.fieldContext_AddCommentOperation_date(ctx, field)
+				return ec.fieldContext_BugAddCommentOperation_date(ctx, field)
 			case "message":
-				return ec.fieldContext_AddCommentOperation_message(ctx, field)
+				return ec.fieldContext_BugAddCommentOperation_message(ctx, field)
 			case "files":
-				return ec.fieldContext_AddCommentOperation_files(ctx, field)
+				return ec.fieldContext_BugAddCommentOperation_files(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type AddCommentOperation", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugAddCommentOperation", field.Name)
 		},
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentAndReopenBugPayload_statusOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentAndReopenBugPayload_statusOperation(ctx, field)
+func (ec *executionContext) _BugAddCommentAndReopenPayload_statusOperation(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndReopenPayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentAndReopenPayload_statusOperation(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -451,34 +449,34 @@ func (ec *executionContext) _AddCommentAndReopenBugPayload_statusOperation(ctx c
 	}
 	res := resTmp.(*bug.SetStatusOperation)
 	fc.Result = res
-	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
+	return ec.marshalNBugSetStatusOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentAndReopenBugPayload_statusOperation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentAndReopenPayload_statusOperation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentAndReopenBugPayload",
+		Object:     "BugAddCommentAndReopenPayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "id":
-				return ec.fieldContext_SetStatusOperation_id(ctx, field)
+				return ec.fieldContext_BugSetStatusOperation_id(ctx, field)
 			case "author":
-				return ec.fieldContext_SetStatusOperation_author(ctx, field)
+				return ec.fieldContext_BugSetStatusOperation_author(ctx, field)
 			case "date":
-				return ec.fieldContext_SetStatusOperation_date(ctx, field)
+				return ec.fieldContext_BugSetStatusOperation_date(ctx, field)
 			case "status":
-				return ec.fieldContext_SetStatusOperation_status(ctx, field)
+				return ec.fieldContext_BugSetStatusOperation_status(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type SetStatusOperation", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugSetStatusOperation", field.Name)
 		},
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentPayload_clientMutationId(ctx, field)
+func (ec *executionContext) _BugAddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentPayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentPayload_clientMutationId(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -505,9 +503,9 @@ func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Cont
 	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentPayload",
+		Object:     "BugAddCommentPayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -518,8 +516,8 @@ func (ec *executionContext) fieldContext_AddCommentPayload_clientMutationId(_ co
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentPayload_bug(ctx, field)
+func (ec *executionContext) _BugAddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentPayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentPayload_bug(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -549,9 +547,9 @@ func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field gr
 	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentPayload",
+		Object:     "BugAddCommentPayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -590,8 +588,8 @@ func (ec *executionContext) fieldContext_AddCommentPayload_bug(_ context.Context
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentPayload_operation(ctx, field)
+func (ec *executionContext) _BugAddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentPayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentPayload_operation(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -618,36 +616,36 @@ func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, fi
 	}
 	res := resTmp.(*bug.AddCommentOperation)
 	fc.Result = res
-	return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
+	return ec.marshalNBugAddCommentOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentPayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentPayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentPayload",
+		Object:     "BugAddCommentPayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "id":
-				return ec.fieldContext_AddCommentOperation_id(ctx, field)
+				return ec.fieldContext_BugAddCommentOperation_id(ctx, field)
 			case "author":
-				return ec.fieldContext_AddCommentOperation_author(ctx, field)
+				return ec.fieldContext_BugAddCommentOperation_author(ctx, field)
 			case "date":
-				return ec.fieldContext_AddCommentOperation_date(ctx, field)
+				return ec.fieldContext_BugAddCommentOperation_date(ctx, field)
 			case "message":
-				return ec.fieldContext_AddCommentOperation_message(ctx, field)
+				return ec.fieldContext_BugAddCommentOperation_message(ctx, field)
 			case "files":
-				return ec.fieldContext_AddCommentOperation_files(ctx, field)
+				return ec.fieldContext_BugAddCommentOperation_files(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type AddCommentOperation", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugAddCommentOperation", field.Name)
 		},
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_ChangeLabelPayload_clientMutationId(ctx, field)
+func (ec *executionContext) _BugChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugChangeLabelPayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugChangeLabelPayload_clientMutationId(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -674,9 +672,9 @@ func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Con
 	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_ChangeLabelPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugChangeLabelPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "ChangeLabelPayload",
+		Object:     "BugChangeLabelPayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -687,8 +685,8 @@ func (ec *executionContext) fieldContext_ChangeLabelPayload_clientMutationId(_ c
 	return fc, nil
 }
 
-func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_ChangeLabelPayload_bug(ctx, field)
+func (ec *executionContext) _BugChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugChangeLabelPayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugChangeLabelPayload_bug(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -718,9 +716,9 @@ func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field g
 	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_ChangeLabelPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugChangeLabelPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "ChangeLabelPayload",
+		Object:     "BugChangeLabelPayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -759,8 +757,8 @@ func (ec *executionContext) fieldContext_ChangeLabelPayload_bug(_ context.Contex
 	return fc, nil
 }
 
-func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_ChangeLabelPayload_operation(ctx, field)
+func (ec *executionContext) _BugChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.BugChangeLabelPayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugChangeLabelPayload_operation(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -787,36 +785,36 @@ func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, f
 	}
 	res := resTmp.(*bug.LabelChangeOperation)
 	fc.Result = res
-	return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
+	return ec.marshalNBugLabelChangeOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_ChangeLabelPayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugChangeLabelPayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "ChangeLabelPayload",
+		Object:     "BugChangeLabelPayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "id":
-				return ec.fieldContext_LabelChangeOperation_id(ctx, field)
+				return ec.fieldContext_BugLabelChangeOperation_id(ctx, field)
 			case "author":
-				return ec.fieldContext_LabelChangeOperation_author(ctx, field)
+				return ec.fieldContext_BugLabelChangeOperation_author(ctx, field)
 			case "date":
-				return ec.fieldContext_LabelChangeOperation_date(ctx, field)
+				return ec.fieldContext_BugLabelChangeOperation_date(ctx, field)
 			case "added":
-				return ec.fieldContext_LabelChangeOperation_added(ctx, field)
+				return ec.fieldContext_BugLabelChangeOperation_added(ctx, field)
 			case "removed":
-				return ec.fieldContext_LabelChangeOperation_removed(ctx, field)
+				return ec.fieldContext_BugLabelChangeOperation_removed(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type LabelChangeOperation", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugLabelChangeOperation", field.Name)
 		},
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_ChangeLabelPayload_results(ctx, field)
+func (ec *executionContext) _BugChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.BugChangeLabelPayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugChangeLabelPayload_results(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -846,9 +844,9 @@ func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, fie
 	return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_ChangeLabelPayload_results(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugChangeLabelPayload_results(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "ChangeLabelPayload",
+		Object:     "BugChangeLabelPayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -865,8 +863,8 @@ func (ec *executionContext) fieldContext_ChangeLabelPayload_results(_ context.Co
 	return fc, nil
 }
 
-func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CloseBugPayload_clientMutationId(ctx, field)
+func (ec *executionContext) _BugCreatePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugCreatePayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreatePayload_clientMutationId(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -893,9 +891,9 @@ func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Contex
 	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CloseBugPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreatePayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CloseBugPayload",
+		Object:     "BugCreatePayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -906,8 +904,8 @@ func (ec *executionContext) fieldContext_CloseBugPayload_clientMutationId(_ cont
 	return fc, nil
 }
 
-func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CloseBugPayload_bug(ctx, field)
+func (ec *executionContext) _BugCreatePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugCreatePayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreatePayload_bug(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -937,9 +935,9 @@ func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field grap
 	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CloseBugPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreatePayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CloseBugPayload",
+		Object:     "BugCreatePayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -978,8 +976,8 @@ func (ec *executionContext) fieldContext_CloseBugPayload_bug(_ context.Context,
 	return fc, nil
 }
 
-func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CloseBugPayload_operation(ctx, field)
+func (ec *executionContext) _BugCreatePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.BugCreatePayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreatePayload_operation(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1004,36 +1002,40 @@ func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, fiel
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*bug.SetStatusOperation)
+	res := resTmp.(*bug.CreateOperation)
 	fc.Result = res
-	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
+	return ec.marshalNBugCreateOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐCreateOperation(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CloseBugPayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreatePayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CloseBugPayload",
+		Object:     "BugCreatePayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "id":
-				return ec.fieldContext_SetStatusOperation_id(ctx, field)
+				return ec.fieldContext_BugCreateOperation_id(ctx, field)
 			case "author":
-				return ec.fieldContext_SetStatusOperation_author(ctx, field)
+				return ec.fieldContext_BugCreateOperation_author(ctx, field)
 			case "date":
-				return ec.fieldContext_SetStatusOperation_date(ctx, field)
-			case "status":
-				return ec.fieldContext_SetStatusOperation_status(ctx, field)
+				return ec.fieldContext_BugCreateOperation_date(ctx, field)
+			case "title":
+				return ec.fieldContext_BugCreateOperation_title(ctx, field)
+			case "message":
+				return ec.fieldContext_BugCreateOperation_message(ctx, field)
+			case "files":
+				return ec.fieldContext_BugCreateOperation_files(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type SetStatusOperation", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugCreateOperation", field.Name)
 		},
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _EditCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_EditCommentPayload_clientMutationId(ctx, field)
+func (ec *executionContext) _BugEditCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugEditCommentPayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugEditCommentPayload_clientMutationId(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1060,9 +1062,9 @@ func (ec *executionContext) _EditCommentPayload_clientMutationId(ctx context.Con
 	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_EditCommentPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugEditCommentPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "EditCommentPayload",
+		Object:     "BugEditCommentPayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -1073,8 +1075,8 @@ func (ec *executionContext) fieldContext_EditCommentPayload_clientMutationId(_ c
 	return fc, nil
 }
 
-func (ec *executionContext) _EditCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_EditCommentPayload_bug(ctx, field)
+func (ec *executionContext) _BugEditCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugEditCommentPayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugEditCommentPayload_bug(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1104,9 +1106,9 @@ func (ec *executionContext) _EditCommentPayload_bug(ctx context.Context, field g
 	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_EditCommentPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugEditCommentPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "EditCommentPayload",
+		Object:     "BugEditCommentPayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -1145,8 +1147,8 @@ func (ec *executionContext) fieldContext_EditCommentPayload_bug(_ context.Contex
 	return fc, nil
 }
 
-func (ec *executionContext) _EditCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_EditCommentPayload_operation(ctx, field)
+func (ec *executionContext) _BugEditCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.BugEditCommentPayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugEditCommentPayload_operation(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1173,132 +1175,38 @@ func (ec *executionContext) _EditCommentPayload_operation(ctx context.Context, f
 	}
 	res := resTmp.(*bug.EditCommentOperation)
 	fc.Result = res
-	return ec.marshalNEditCommentOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐEditCommentOperation(ctx, field.Selections, res)
+	return ec.marshalNBugEditCommentOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐEditCommentOperation(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_EditCommentPayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugEditCommentPayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "EditCommentPayload",
+		Object:     "BugEditCommentPayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "id":
-				return ec.fieldContext_EditCommentOperation_id(ctx, field)
+				return ec.fieldContext_BugEditCommentOperation_id(ctx, field)
 			case "author":
-				return ec.fieldContext_EditCommentOperation_author(ctx, field)
+				return ec.fieldContext_BugEditCommentOperation_author(ctx, field)
 			case "date":
-				return ec.fieldContext_EditCommentOperation_date(ctx, field)
+				return ec.fieldContext_BugEditCommentOperation_date(ctx, field)
 			case "target":
-				return ec.fieldContext_EditCommentOperation_target(ctx, field)
+				return ec.fieldContext_BugEditCommentOperation_target(ctx, field)
 			case "message":
-				return ec.fieldContext_EditCommentOperation_message(ctx, field)
+				return ec.fieldContext_BugEditCommentOperation_message(ctx, field)
 			case "files":
-				return ec.fieldContext_EditCommentOperation_files(ctx, field)
-			}
-			return nil, fmt.Errorf("no field named %q was found under type EditCommentOperation", field.Name)
-		},
-	}
-	return fc, nil
-}
-
-func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_LabelChangeResult_label(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.Label, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(common.Label)
-	fc.Result = res
-	return ec.marshalNLabel2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋcommonᚐLabel(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_LabelChangeResult_label(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "LabelChangeResult",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			switch field.Name {
-			case "name":
-				return ec.fieldContext_Label_name(ctx, field)
-			case "color":
-				return ec.fieldContext_Label_color(ctx, field)
+				return ec.fieldContext_BugEditCommentOperation_files(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugEditCommentOperation", field.Name)
 		},
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_LabelChangeResult_status(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.Status, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(bug.LabelChangeStatus)
-	fc.Result = res
-	return ec.marshalNLabelChangeStatus2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeStatus(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_LabelChangeResult_status(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "LabelChangeResult",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			return nil, errors.New("field of type LabelChangeStatus does not have child fields")
-		},
-	}
-	return fc, nil
-}
-
-func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_NewBugPayload_clientMutationId(ctx, field)
+func (ec *executionContext) _BugSetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugSetTitlePayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugSetTitlePayload_clientMutationId(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1325,9 +1233,9 @@ func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context,
 	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_NewBugPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugSetTitlePayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "NewBugPayload",
+		Object:     "BugSetTitlePayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -1338,8 +1246,8 @@ func (ec *executionContext) fieldContext_NewBugPayload_clientMutationId(_ contex
 	return fc, nil
 }
 
-func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_NewBugPayload_bug(ctx, field)
+func (ec *executionContext) _BugSetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugSetTitlePayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugSetTitlePayload_bug(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1369,9 +1277,9 @@ func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphq
 	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_NewBugPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugSetTitlePayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "NewBugPayload",
+		Object:     "BugSetTitlePayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -1410,8 +1318,8 @@ func (ec *executionContext) fieldContext_NewBugPayload_bug(_ context.Context, fi
 	return fc, nil
 }
 
-func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_NewBugPayload_operation(ctx, field)
+func (ec *executionContext) _BugSetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.BugSetTitlePayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugSetTitlePayload_operation(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1436,40 +1344,38 @@ func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*bug.CreateOperation)
+	res := resTmp.(*bug.SetTitleOperation)
 	fc.Result = res
-	return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐCreateOperation(ctx, field.Selections, res)
+	return ec.marshalNBugSetTitleOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_NewBugPayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugSetTitlePayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "NewBugPayload",
+		Object:     "BugSetTitlePayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "id":
-				return ec.fieldContext_CreateOperation_id(ctx, field)
+				return ec.fieldContext_BugSetTitleOperation_id(ctx, field)
 			case "author":
-				return ec.fieldContext_CreateOperation_author(ctx, field)
+				return ec.fieldContext_BugSetTitleOperation_author(ctx, field)
 			case "date":
-				return ec.fieldContext_CreateOperation_date(ctx, field)
+				return ec.fieldContext_BugSetTitleOperation_date(ctx, field)
 			case "title":
-				return ec.fieldContext_CreateOperation_title(ctx, field)
-			case "message":
-				return ec.fieldContext_CreateOperation_message(ctx, field)
-			case "files":
-				return ec.fieldContext_CreateOperation_files(ctx, field)
+				return ec.fieldContext_BugSetTitleOperation_title(ctx, field)
+			case "was":
+				return ec.fieldContext_BugSetTitleOperation_was(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type CreateOperation", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugSetTitleOperation", field.Name)
 		},
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_OpenBugPayload_clientMutationId(ctx, field)
+func (ec *executionContext) _BugStatusClosePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugStatusClosePayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugStatusClosePayload_clientMutationId(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1496,9 +1402,9 @@ func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context
 	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_OpenBugPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugStatusClosePayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "OpenBugPayload",
+		Object:     "BugStatusClosePayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -1509,8 +1415,8 @@ func (ec *executionContext) fieldContext_OpenBugPayload_clientMutationId(_ conte
 	return fc, nil
 }
 
-func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_OpenBugPayload_bug(ctx, field)
+func (ec *executionContext) _BugStatusClosePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugStatusClosePayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugStatusClosePayload_bug(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1540,9 +1446,9 @@ func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graph
 	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_OpenBugPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugStatusClosePayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "OpenBugPayload",
+		Object:     "BugStatusClosePayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -1581,8 +1487,8 @@ func (ec *executionContext) fieldContext_OpenBugPayload_bug(_ context.Context, f
 	return fc, nil
 }
 
-func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_OpenBugPayload_operation(ctx, field)
+func (ec *executionContext) _BugStatusClosePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.BugStatusClosePayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugStatusClosePayload_operation(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1609,34 +1515,34 @@ func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field
 	}
 	res := resTmp.(*bug.SetStatusOperation)
 	fc.Result = res
-	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
+	return ec.marshalNBugSetStatusOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_OpenBugPayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugStatusClosePayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "OpenBugPayload",
+		Object:     "BugStatusClosePayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "id":
-				return ec.fieldContext_SetStatusOperation_id(ctx, field)
+				return ec.fieldContext_BugSetStatusOperation_id(ctx, field)
 			case "author":
-				return ec.fieldContext_SetStatusOperation_author(ctx, field)
+				return ec.fieldContext_BugSetStatusOperation_author(ctx, field)
 			case "date":
-				return ec.fieldContext_SetStatusOperation_date(ctx, field)
+				return ec.fieldContext_BugSetStatusOperation_date(ctx, field)
 			case "status":
-				return ec.fieldContext_SetStatusOperation_status(ctx, field)
+				return ec.fieldContext_BugSetStatusOperation_status(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type SetStatusOperation", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugSetStatusOperation", field.Name)
 		},
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_SetTitlePayload_clientMutationId(ctx, field)
+func (ec *executionContext) _BugStatusOpenPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugStatusOpenPayload) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugStatusOpenPayload_clientMutationId(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1663,9 +1569,9 @@ func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Contex
 	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_SetTitlePayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugStatusOpenPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "SetTitlePayload",
+		Object:     "BugStatusOpenPayload",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,

api/graphql/graph/operations.generated.go → api/graphql/graph/bug_operations.generated.go

@@ -7,7 +7,6 @@ import (
 	"errors"
 	"fmt"
 	"strconv"
-	"sync"
 	"sync/atomic"
 	"time"
 
@@ -16,37 +15,31 @@ import (
 	"github.com/git-bug/git-bug/entities/bug"
 	"github.com/git-bug/git-bug/entities/common"
 	"github.com/git-bug/git-bug/entity"
-	"github.com/git-bug/git-bug/entity/dag"
 	"github.com/git-bug/git-bug/repository"
 	"github.com/vektah/gqlparser/v2/ast"
 )
 
 // region    ************************** generated!.gotpl **************************
 
-type AddCommentOperationResolver interface {
+type BugAddCommentOperationResolver interface {
 	Author(ctx context.Context, obj *bug.AddCommentOperation) (models.IdentityWrapper, error)
-	Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
 }
-type CreateOperationResolver interface {
+type BugCreateOperationResolver interface {
 	Author(ctx context.Context, obj *bug.CreateOperation) (models.IdentityWrapper, error)
-	Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
 }
-type EditCommentOperationResolver interface {
+type BugEditCommentOperationResolver interface {
 	Author(ctx context.Context, obj *bug.EditCommentOperation) (models.IdentityWrapper, error)
-	Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
+
 	Target(ctx context.Context, obj *bug.EditCommentOperation) (string, error)
 }
-type LabelChangeOperationResolver interface {
+type BugLabelChangeOperationResolver interface {
 	Author(ctx context.Context, obj *bug.LabelChangeOperation) (models.IdentityWrapper, error)
-	Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
 }
-type SetStatusOperationResolver interface {
+type BugSetStatusOperationResolver interface {
 	Author(ctx context.Context, obj *bug.SetStatusOperation) (models.IdentityWrapper, error)
-	Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
 }
-type SetTitleOperationResolver interface {
+type BugSetTitleOperationResolver interface {
 	Author(ctx context.Context, obj *bug.SetTitleOperation) (models.IdentityWrapper, error)
-	Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
 }
 
 // endregion ************************** generated!.gotpl **************************
@@ -61,8 +54,8 @@ type SetTitleOperationResolver interface {
 
 // region    **************************** field.gotpl *****************************
 
-func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentOperation_id(ctx, field)
+func (ec *executionContext) _BugAddCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentOperation_id(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -92,9 +85,9 @@ func (ec *executionContext) _AddCommentOperation_id(ctx context.Context, field g
 	return ec.marshalNID2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚐId(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentOperation",
+		Object:     "BugAddCommentOperation",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: false,
@@ -105,8 +98,8 @@ func (ec *executionContext) fieldContext_AddCommentOperation_id(_ context.Contex
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentOperation_author(ctx, field)
+func (ec *executionContext) _BugAddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentOperation_author(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -119,7 +112,7 @@ func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, fie
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.AddCommentOperation().Author(rctx, obj)
+		return ec.resolvers.BugAddCommentOperation().Author(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -136,9 +129,9 @@ func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, fie
 	return ec.marshalNIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentOperation",
+		Object:     "BugAddCommentOperation",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -167,8 +160,8 @@ func (ec *executionContext) fieldContext_AddCommentOperation_author(_ context.Co
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentOperation_date(ctx, field)
+func (ec *executionContext) _BugAddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentOperation_date(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -181,7 +174,7 @@ func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.AddCommentOperation().Date(rctx, obj)
+		return obj.Time(), nil
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -193,17 +186,17 @@ func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*time.Time)
+	res := resTmp.(time.Time)
 	fc.Result = res
-	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
+	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentOperation",
+		Object:     "BugAddCommentOperation",
 		Field:      field,
 		IsMethod:   true,
-		IsResolver: true,
+		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			return nil, errors.New("field of type Time does not have child fields")
 		},
@@ -211,8 +204,8 @@ func (ec *executionContext) fieldContext_AddCommentOperation_date(_ context.Cont
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentOperation_message(ctx, field)
+func (ec *executionContext) _BugAddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentOperation_message(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -242,9 +235,9 @@ func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, fi
 	return ec.marshalNString2string(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentOperation_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentOperation_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentOperation",
+		Object:     "BugAddCommentOperation",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -255,8 +248,8 @@ func (ec *executionContext) fieldContext_AddCommentOperation_message(_ context.C
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentOperation_files(ctx, field)
+func (ec *executionContext) _BugAddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentOperation_files(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -286,9 +279,9 @@ func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, fiel
 	return ec.marshalNHash2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentOperation_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentOperation_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentOperation",
+		Object:     "BugAddCommentOperation",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -299,8 +292,8 @@ func (ec *executionContext) fieldContext_AddCommentOperation_files(_ context.Con
 	return fc, nil
 }
 
-func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CreateOperation_id(ctx, field)
+func (ec *executionContext) _BugCreateOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreateOperation_id(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -330,9 +323,9 @@ func (ec *executionContext) _CreateOperation_id(ctx context.Context, field graph
 	return ec.marshalNID2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚐId(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CreateOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreateOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CreateOperation",
+		Object:     "BugCreateOperation",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: false,
@@ -343,8 +336,8 @@ func (ec *executionContext) fieldContext_CreateOperation_id(_ context.Context, f
 	return fc, nil
 }
 
-func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CreateOperation_author(ctx, field)
+func (ec *executionContext) _BugCreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreateOperation_author(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -357,7 +350,7 @@ func (ec *executionContext) _CreateOperation_author(ctx context.Context, field g
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.CreateOperation().Author(rctx, obj)
+		return ec.resolvers.BugCreateOperation().Author(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -374,9 +367,9 @@ func (ec *executionContext) _CreateOperation_author(ctx context.Context, field g
 	return ec.marshalNIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CreateOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreateOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CreateOperation",
+		Object:     "BugCreateOperation",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -405,8 +398,8 @@ func (ec *executionContext) fieldContext_CreateOperation_author(_ context.Contex
 	return fc, nil
 }
 
-func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CreateOperation_date(ctx, field)
+func (ec *executionContext) _BugCreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreateOperation_date(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -419,7 +412,7 @@ func (ec *executionContext) _CreateOperation_date(ctx context.Context, field gra
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.CreateOperation().Date(rctx, obj)
+		return obj.Time(), nil
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -431,17 +424,17 @@ func (ec *executionContext) _CreateOperation_date(ctx context.Context, field gra
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*time.Time)
+	res := resTmp.(time.Time)
 	fc.Result = res
-	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
+	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CreateOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreateOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CreateOperation",
+		Object:     "BugCreateOperation",
 		Field:      field,
 		IsMethod:   true,
-		IsResolver: true,
+		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			return nil, errors.New("field of type Time does not have child fields")
 		},
@@ -449,8 +442,8 @@ func (ec *executionContext) fieldContext_CreateOperation_date(_ context.Context,
 	return fc, nil
 }
 
-func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CreateOperation_title(ctx, field)
+func (ec *executionContext) _BugCreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreateOperation_title(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -480,9 +473,9 @@ func (ec *executionContext) _CreateOperation_title(ctx context.Context, field gr
 	return ec.marshalNString2string(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CreateOperation_title(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreateOperation_title(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CreateOperation",
+		Object:     "BugCreateOperation",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -493,8 +486,8 @@ func (ec *executionContext) fieldContext_CreateOperation_title(_ context.Context
 	return fc, nil
 }
 
-func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CreateOperation_message(ctx, field)
+func (ec *executionContext) _BugCreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreateOperation_message(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -524,9 +517,9 @@ func (ec *executionContext) _CreateOperation_message(ctx context.Context, field
 	return ec.marshalNString2string(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CreateOperation_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreateOperation_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CreateOperation",
+		Object:     "BugCreateOperation",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -537,8 +530,8 @@ func (ec *executionContext) fieldContext_CreateOperation_message(_ context.Conte
 	return fc, nil
 }
 
-func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CreateOperation_files(ctx, field)
+func (ec *executionContext) _BugCreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreateOperation_files(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -568,9 +561,9 @@ func (ec *executionContext) _CreateOperation_files(ctx context.Context, field gr
 	return ec.marshalNHash2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CreateOperation_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreateOperation_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CreateOperation",
+		Object:     "BugCreateOperation",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -581,8 +574,8 @@ func (ec *executionContext) fieldContext_CreateOperation_files(_ context.Context
 	return fc, nil
 }
 
-func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_EditCommentOperation_id(ctx, field)
+func (ec *executionContext) _BugEditCommentOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugEditCommentOperation_id(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -612,9 +605,9 @@ func (ec *executionContext) _EditCommentOperation_id(ctx context.Context, field
 	return ec.marshalNID2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚐId(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_EditCommentOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugEditCommentOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "EditCommentOperation",
+		Object:     "BugEditCommentOperation",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: false,
@@ -625,8 +618,8 @@ func (ec *executionContext) fieldContext_EditCommentOperation_id(_ context.Conte
 	return fc, nil
 }
 
-func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_EditCommentOperation_author(ctx, field)
+func (ec *executionContext) _BugEditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugEditCommentOperation_author(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -639,7 +632,7 @@ func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, fi
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.EditCommentOperation().Author(rctx, obj)
+		return ec.resolvers.BugEditCommentOperation().Author(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -656,9 +649,9 @@ func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, fi
 	return ec.marshalNIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_EditCommentOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugEditCommentOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "EditCommentOperation",
+		Object:     "BugEditCommentOperation",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -687,8 +680,8 @@ func (ec *executionContext) fieldContext_EditCommentOperation_author(_ context.C
 	return fc, nil
 }
 
-func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_EditCommentOperation_date(ctx, field)
+func (ec *executionContext) _BugEditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugEditCommentOperation_date(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -701,7 +694,7 @@ func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, fiel
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.EditCommentOperation().Date(rctx, obj)
+		return obj.Time(), nil
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -713,17 +706,17 @@ func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, fiel
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*time.Time)
+	res := resTmp.(time.Time)
 	fc.Result = res
-	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
+	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_EditCommentOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugEditCommentOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "EditCommentOperation",
+		Object:     "BugEditCommentOperation",
 		Field:      field,
 		IsMethod:   true,
-		IsResolver: true,
+		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			return nil, errors.New("field of type Time does not have child fields")
 		},
@@ -731,8 +724,8 @@ func (ec *executionContext) fieldContext_EditCommentOperation_date(_ context.Con
 	return fc, nil
 }
 
-func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_EditCommentOperation_target(ctx, field)
+func (ec *executionContext) _BugEditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugEditCommentOperation_target(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -745,7 +738,7 @@ func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, fi
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.EditCommentOperation().Target(rctx, obj)
+		return ec.resolvers.BugEditCommentOperation().Target(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -762,9 +755,9 @@ func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, fi
 	return ec.marshalNString2string(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_EditCommentOperation_target(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugEditCommentOperation_target(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "EditCommentOperation",
+		Object:     "BugEditCommentOperation",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -775,8 +768,8 @@ func (ec *executionContext) fieldContext_EditCommentOperation_target(_ context.C
 	return fc, nil
 }
 
-func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_EditCommentOperation_message(ctx, field)
+func (ec *executionContext) _BugEditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugEditCommentOperation_message(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -806,9 +799,9 @@ func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, f
 	return ec.marshalNString2string(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_EditCommentOperation_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugEditCommentOperation_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "EditCommentOperation",
+		Object:     "BugEditCommentOperation",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -819,8 +812,8 @@ func (ec *executionContext) fieldContext_EditCommentOperation_message(_ context.
 	return fc, nil
 }
 
-func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_EditCommentOperation_files(ctx, field)
+func (ec *executionContext) _BugEditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugEditCommentOperation_files(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -850,9 +843,9 @@ func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, fie
 	return ec.marshalNHash2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_EditCommentOperation_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugEditCommentOperation_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "EditCommentOperation",
+		Object:     "BugEditCommentOperation",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -863,8 +856,8 @@ func (ec *executionContext) fieldContext_EditCommentOperation_files(_ context.Co
 	return fc, nil
 }
 
-func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_LabelChangeOperation_id(ctx, field)
+func (ec *executionContext) _BugLabelChangeOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugLabelChangeOperation_id(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -894,9 +887,9 @@ func (ec *executionContext) _LabelChangeOperation_id(ctx context.Context, field
 	return ec.marshalNID2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚐId(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_LabelChangeOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugLabelChangeOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "LabelChangeOperation",
+		Object:     "BugLabelChangeOperation",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: false,
@@ -907,8 +900,8 @@ func (ec *executionContext) fieldContext_LabelChangeOperation_id(_ context.Conte
 	return fc, nil
 }
 
-func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_LabelChangeOperation_author(ctx, field)
+func (ec *executionContext) _BugLabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugLabelChangeOperation_author(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -921,7 +914,7 @@ func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, fi
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.LabelChangeOperation().Author(rctx, obj)
+		return ec.resolvers.BugLabelChangeOperation().Author(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -938,9 +931,9 @@ func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, fi
 	return ec.marshalNIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_LabelChangeOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugLabelChangeOperation_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "LabelChangeOperation",
+		Object:     "BugLabelChangeOperation",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -969,8 +962,8 @@ func (ec *executionContext) fieldContext_LabelChangeOperation_author(_ context.C
 	return fc, nil
 }
 
-func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_LabelChangeOperation_date(ctx, field)
+func (ec *executionContext) _BugLabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugLabelChangeOperation_date(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -983,7 +976,7 @@ func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, fiel
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
+		return obj.Time(), nil
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -995,17 +988,17 @@ func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, fiel
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*time.Time)
+	res := resTmp.(time.Time)
 	fc.Result = res
-	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
+	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_LabelChangeOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugLabelChangeOperation_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "LabelChangeOperation",
+		Object:     "BugLabelChangeOperation",
 		Field:      field,
 		IsMethod:   true,
-		IsResolver: true,
+		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			return nil, errors.New("field of type Time does not have child fields")
 		},
@@ -1013,8 +1006,8 @@ func (ec *executionContext) fieldContext_LabelChangeOperation_date(_ context.Con
 	return fc, nil
 }
 
-func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_LabelChangeOperation_added(ctx, field)
+func (ec *executionContext) _BugLabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugLabelChangeOperation_added(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1044,9 +1037,9 @@ func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, fie
 	return ec.marshalNLabel2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋcommonᚐLabelᚄ(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_LabelChangeOperation_added(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugLabelChangeOperation_added(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "LabelChangeOperation",
+		Object:     "BugLabelChangeOperation",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -1063,8 +1056,8 @@ func (ec *executionContext) fieldContext_LabelChangeOperation_added(_ context.Co
 	return fc, nil
 }
 
-func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_LabelChangeOperation_removed(ctx, field)
+func (ec *executionContext) _BugLabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugLabelChangeOperation_removed(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1094,9 +1087,9 @@ func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, f
 	return ec.marshalNLabel2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋcommonᚐLabelᚄ(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_LabelChangeOperation_removed(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugLabelChangeOperation_removed(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "LabelChangeOperation",
+		Object:     "BugLabelChangeOperation",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -1113,288 +1106,8 @@ func (ec *executionContext) fieldContext_LabelChangeOperation_removed(_ context.
 	return fc, nil
 }
 
-func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_OperationConnection_edges(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.Edges, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.([]*models.OperationEdge)
-	fc.Result = res
-	return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_OperationConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "OperationConnection",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			switch field.Name {
-			case "cursor":
-				return ec.fieldContext_OperationEdge_cursor(ctx, field)
-			case "node":
-				return ec.fieldContext_OperationEdge_node(ctx, field)
-			}
-			return nil, fmt.Errorf("no field named %q was found under type OperationEdge", field.Name)
-		},
-	}
-	return fc, nil
-}
-
-func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_OperationConnection_nodes(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.Nodes, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.([]dag.Operation)
-	fc.Result = res
-	return ec.marshalNOperation2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚋdagᚐOperationᚄ(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_OperationConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "OperationConnection",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
-		},
-	}
-	return fc, nil
-}
-
-func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_OperationConnection_pageInfo(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.PageInfo, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(*models.PageInfo)
-	fc.Result = res
-	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_OperationConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "OperationConnection",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			switch field.Name {
-			case "hasNextPage":
-				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
-			case "hasPreviousPage":
-				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
-			case "startCursor":
-				return ec.fieldContext_PageInfo_startCursor(ctx, field)
-			case "endCursor":
-				return ec.fieldContext_PageInfo_endCursor(ctx, field)
-			}
-			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
-		},
-	}
-	return fc, nil
-}
-
-func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_OperationConnection_totalCount(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.TotalCount, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(int)
-	fc.Result = res
-	return ec.marshalNInt2int(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_OperationConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "OperationConnection",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			return nil, errors.New("field of type Int does not have child fields")
-		},
-	}
-	return fc, nil
-}
-
-func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_OperationEdge_cursor(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.Cursor, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(string)
-	fc.Result = res
-	return ec.marshalNString2string(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_OperationEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "OperationEdge",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			return nil, errors.New("field of type String does not have child fields")
-		},
-	}
-	return fc, nil
-}
-
-func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_OperationEdge_node(ctx, field)
-	if err != nil {
-		return graphql.Null
-	}
-	ctx = graphql.WithFieldContext(ctx, fc)
-	defer func() {
-		if r := recover(); r != nil {
-			ec.Error(ctx, ec.Recover(ctx, r))
-			ret = graphql.Null
-		}
-	}()
-	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
-		ctx = rctx // use context from middleware stack in children
-		return obj.Node, nil
-	})
-	if err != nil {
-		ec.Error(ctx, err)
-		return graphql.Null
-	}
-	if resTmp == nil {
-		if !graphql.HasFieldError(ctx, fc) {
-			ec.Errorf(ctx, "must not be null")
-		}
-		return graphql.Null
-	}
-	res := resTmp.(dag.Operation)
-	fc.Result = res
-	return ec.marshalNOperation2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚋdagᚐOperation(ctx, field.Selections, res)
-}
-
-func (ec *executionContext) fieldContext_OperationEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
-	fc = &graphql.FieldContext{
-		Object:     "OperationEdge",
-		Field:      field,
-		IsMethod:   false,
-		IsResolver: false,
-		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
-			return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
-		},
-	}
-	return fc, nil
-}
-
-func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_SetStatusOperation_id(ctx, field)
+func (ec *executionContext) _BugSetStatusOperation_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugSetStatusOperation_id(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1424,9 +1137,9 @@ func (ec *executionContext) _SetStatusOperation_id(ctx context.Context, field gr
 	return ec.marshalNID2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚐId(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_SetStatusOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugSetStatusOperation_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "SetStatusOperation",
+		Object:     "BugSetStatusOperation",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: false,
@@ -1437,8 +1150,8 @@ func (ec *executionContext) fieldContext_SetStatusOperation_id(_ context.Context
 	return fc, nil
 }
 
-func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_SetStatusOperation_author(ctx, field)
+func (ec *executionContext) _BugSetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugSetStatusOperation_author(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1451,7 +1164,7 @@ func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, fiel
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.SetStatusOperation().Author(rctx, obj)
+		return ec.resolvers.BugSetStatusOperation().Author(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)

api/graphql/graph/timeline.generated.go → api/graphql/graph/bug_timeline.generated.go

@@ -22,35 +22,30 @@ import (
 
 // region    ************************** generated!.gotpl **************************
 
-type AddCommentTimelineItemResolver interface {
-	ID(ctx context.Context, obj *bug.AddCommentTimelineItem) (entity.CombinedId, error)
+type BugAddCommentTimelineItemResolver interface {
 	Author(ctx context.Context, obj *bug.AddCommentTimelineItem) (models.IdentityWrapper, error)
 
 	CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
 	LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
 }
-type CommentHistoryStepResolver interface {
+type BugCommentHistoryStepResolver interface {
 	Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
 }
-type CreateTimelineItemResolver interface {
-	ID(ctx context.Context, obj *bug.CreateTimelineItem) (entity.CombinedId, error)
+type BugCreateTimelineItemResolver interface {
 	Author(ctx context.Context, obj *bug.CreateTimelineItem) (models.IdentityWrapper, error)
 
 	CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
 	LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
 }
-type LabelChangeTimelineItemResolver interface {
-	ID(ctx context.Context, obj *bug.LabelChangeTimelineItem) (entity.CombinedId, error)
+type BugLabelChangeTimelineItemResolver interface {
 	Author(ctx context.Context, obj *bug.LabelChangeTimelineItem) (models.IdentityWrapper, error)
 	Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
 }
-type SetStatusTimelineItemResolver interface {
-	ID(ctx context.Context, obj *bug.SetStatusTimelineItem) (entity.CombinedId, error)
+type BugSetStatusTimelineItemResolver interface {
 	Author(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.IdentityWrapper, error)
 	Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
 }
-type SetTitleTimelineItemResolver interface {
-	ID(ctx context.Context, obj *bug.SetTitleTimelineItem) (entity.CombinedId, error)
+type BugSetTitleTimelineItemResolver interface {
 	Author(ctx context.Context, obj *bug.SetTitleTimelineItem) (models.IdentityWrapper, error)
 	Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
 }
@@ -67,8 +62,8 @@ type SetTitleTimelineItemResolver interface {
 
 // region    **************************** field.gotpl *****************************
 
-func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentTimelineItem_id(ctx, field)
+func (ec *executionContext) _BugAddCommentTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentTimelineItem_id(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -81,7 +76,7 @@ func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, fiel
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.AddCommentTimelineItem().ID(rctx, obj)
+		return obj.CombinedId(), nil
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -98,12 +93,12 @@ func (ec *executionContext) _AddCommentTimelineItem_id(ctx context.Context, fiel
 	return ec.marshalNCombinedId2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚐCombinedId(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentTimelineItem_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentTimelineItem_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentTimelineItem",
+		Object:     "BugAddCommentTimelineItem",
 		Field:      field,
 		IsMethod:   true,
-		IsResolver: true,
+		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			return nil, errors.New("field of type CombinedId does not have child fields")
 		},
@@ -111,8 +106,8 @@ func (ec *executionContext) fieldContext_AddCommentTimelineItem_id(_ context.Con
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentTimelineItem_author(ctx, field)
+func (ec *executionContext) _BugAddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentTimelineItem_author(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -125,7 +120,7 @@ func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context,
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.AddCommentTimelineItem().Author(rctx, obj)
+		return ec.resolvers.BugAddCommentTimelineItem().Author(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -142,9 +137,9 @@ func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context,
 	return ec.marshalNIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentTimelineItem_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentTimelineItem_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentTimelineItem",
+		Object:     "BugAddCommentTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -173,8 +168,8 @@ func (ec *executionContext) fieldContext_AddCommentTimelineItem_author(_ context
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentTimelineItem_message(ctx, field)
+func (ec *executionContext) _BugAddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentTimelineItem_message(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -204,9 +199,9 @@ func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context,
 	return ec.marshalNString2string(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentTimelineItem_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentTimelineItem_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentTimelineItem",
+		Object:     "BugAddCommentTimelineItem",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -217,8 +212,8 @@ func (ec *executionContext) fieldContext_AddCommentTimelineItem_message(_ contex
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentTimelineItem_messageIsEmpty(ctx, field)
+func (ec *executionContext) _BugAddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentTimelineItem_messageIsEmpty(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -248,9 +243,9 @@ func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.C
 	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentTimelineItem_messageIsEmpty(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentTimelineItem_messageIsEmpty(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentTimelineItem",
+		Object:     "BugAddCommentTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: false,
@@ -261,8 +256,8 @@ func (ec *executionContext) fieldContext_AddCommentTimelineItem_messageIsEmpty(_
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentTimelineItem_files(ctx, field)
+func (ec *executionContext) _BugAddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentTimelineItem_files(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -292,9 +287,9 @@ func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, f
 	return ec.marshalNHash2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentTimelineItem_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentTimelineItem_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentTimelineItem",
+		Object:     "BugAddCommentTimelineItem",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -305,8 +300,8 @@ func (ec *executionContext) fieldContext_AddCommentTimelineItem_files(_ context.
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentTimelineItem_createdAt(ctx, field)
+func (ec *executionContext) _BugAddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentTimelineItem_createdAt(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -319,7 +314,7 @@ func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Contex
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
+		return ec.resolvers.BugAddCommentTimelineItem().CreatedAt(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -336,9 +331,9 @@ func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Contex
 	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentTimelineItem_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentTimelineItem_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentTimelineItem",
+		Object:     "BugAddCommentTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -349,8 +344,8 @@ func (ec *executionContext) fieldContext_AddCommentTimelineItem_createdAt(_ cont
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentTimelineItem_lastEdit(ctx, field)
+func (ec *executionContext) _BugAddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentTimelineItem_lastEdit(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -363,7 +358,7 @@ func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
+		return ec.resolvers.BugAddCommentTimelineItem().LastEdit(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -380,9 +375,9 @@ func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context
 	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentTimelineItem_lastEdit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentTimelineItem_lastEdit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentTimelineItem",
+		Object:     "BugAddCommentTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -393,8 +388,8 @@ func (ec *executionContext) fieldContext_AddCommentTimelineItem_lastEdit(_ conte
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentTimelineItem_edited(ctx, field)
+func (ec *executionContext) _BugAddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentTimelineItem_edited(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -424,9 +419,9 @@ func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context,
 	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentTimelineItem_edited(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentTimelineItem_edited(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentTimelineItem",
+		Object:     "BugAddCommentTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: false,
@@ -437,8 +432,8 @@ func (ec *executionContext) fieldContext_AddCommentTimelineItem_edited(_ context
 	return fc, nil
 }
 
-func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_AddCommentTimelineItem_history(ctx, field)
+func (ec *executionContext) _BugAddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugAddCommentTimelineItem_history(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -465,30 +460,30 @@ func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context,
 	}
 	res := resTmp.([]bug.CommentHistoryStep)
 	fc.Result = res
-	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
+	return ec.marshalNBugCommentHistoryStep2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_AddCommentTimelineItem_history(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugAddCommentTimelineItem_history(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "AddCommentTimelineItem",
+		Object:     "BugAddCommentTimelineItem",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "message":
-				return ec.fieldContext_CommentHistoryStep_message(ctx, field)
+				return ec.fieldContext_BugCommentHistoryStep_message(ctx, field)
 			case "date":
-				return ec.fieldContext_CommentHistoryStep_date(ctx, field)
+				return ec.fieldContext_BugCommentHistoryStep_date(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type CommentHistoryStep", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugCommentHistoryStep", field.Name)
 		},
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CommentHistoryStep_message(ctx, field)
+func (ec *executionContext) _BugCommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCommentHistoryStep_message(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -518,9 +513,9 @@ func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, fie
 	return ec.marshalNString2string(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CommentHistoryStep_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCommentHistoryStep_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CommentHistoryStep",
+		Object:     "BugCommentHistoryStep",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -531,8 +526,8 @@ func (ec *executionContext) fieldContext_CommentHistoryStep_message(_ context.Co
 	return fc, nil
 }
 
-func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CommentHistoryStep_date(ctx, field)
+func (ec *executionContext) _BugCommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCommentHistoryStep_date(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -545,7 +540,7 @@ func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
+		return ec.resolvers.BugCommentHistoryStep().Date(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -562,9 +557,9 @@ func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field
 	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CommentHistoryStep_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCommentHistoryStep_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CommentHistoryStep",
+		Object:     "BugCommentHistoryStep",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -575,8 +570,8 @@ func (ec *executionContext) fieldContext_CommentHistoryStep_date(_ context.Conte
 	return fc, nil
 }
 
-func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CreateTimelineItem_id(ctx, field)
+func (ec *executionContext) _BugCreateTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreateTimelineItem_id(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -589,7 +584,7 @@ func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field gr
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.CreateTimelineItem().ID(rctx, obj)
+		return obj.CombinedId(), nil
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -606,12 +601,12 @@ func (ec *executionContext) _CreateTimelineItem_id(ctx context.Context, field gr
 	return ec.marshalNCombinedId2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚐCombinedId(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CreateTimelineItem_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreateTimelineItem_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CreateTimelineItem",
+		Object:     "BugCreateTimelineItem",
 		Field:      field,
 		IsMethod:   true,
-		IsResolver: true,
+		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			return nil, errors.New("field of type CombinedId does not have child fields")
 		},
@@ -619,8 +614,8 @@ func (ec *executionContext) fieldContext_CreateTimelineItem_id(_ context.Context
 	return fc, nil
 }
 
-func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CreateTimelineItem_author(ctx, field)
+func (ec *executionContext) _BugCreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreateTimelineItem_author(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -633,7 +628,7 @@ func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, fiel
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.CreateTimelineItem().Author(rctx, obj)
+		return ec.resolvers.BugCreateTimelineItem().Author(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -650,9 +645,9 @@ func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, fiel
 	return ec.marshalNIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CreateTimelineItem_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreateTimelineItem_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CreateTimelineItem",
+		Object:     "BugCreateTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -681,8 +676,8 @@ func (ec *executionContext) fieldContext_CreateTimelineItem_author(_ context.Con
 	return fc, nil
 }
 
-func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CreateTimelineItem_message(ctx, field)
+func (ec *executionContext) _BugCreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreateTimelineItem_message(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -712,9 +707,9 @@ func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, fie
 	return ec.marshalNString2string(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CreateTimelineItem_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreateTimelineItem_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CreateTimelineItem",
+		Object:     "BugCreateTimelineItem",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -725,8 +720,8 @@ func (ec *executionContext) fieldContext_CreateTimelineItem_message(_ context.Co
 	return fc, nil
 }
 
-func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CreateTimelineItem_messageIsEmpty(ctx, field)
+func (ec *executionContext) _BugCreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreateTimelineItem_messageIsEmpty(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -756,9 +751,9 @@ func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Conte
 	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CreateTimelineItem_messageIsEmpty(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreateTimelineItem_messageIsEmpty(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CreateTimelineItem",
+		Object:     "BugCreateTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: false,
@@ -769,8 +764,8 @@ func (ec *executionContext) fieldContext_CreateTimelineItem_messageIsEmpty(_ con
 	return fc, nil
 }
 
-func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CreateTimelineItem_files(ctx, field)
+func (ec *executionContext) _BugCreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreateTimelineItem_files(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -800,9 +795,9 @@ func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field
 	return ec.marshalNHash2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CreateTimelineItem_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreateTimelineItem_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CreateTimelineItem",
+		Object:     "BugCreateTimelineItem",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -813,8 +808,8 @@ func (ec *executionContext) fieldContext_CreateTimelineItem_files(_ context.Cont
 	return fc, nil
 }
 
-func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CreateTimelineItem_createdAt(ctx, field)
+func (ec *executionContext) _BugCreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreateTimelineItem_createdAt(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -827,7 +822,7 @@ func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, f
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
+		return ec.resolvers.BugCreateTimelineItem().CreatedAt(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -844,9 +839,9 @@ func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, f
 	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CreateTimelineItem_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreateTimelineItem_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CreateTimelineItem",
+		Object:     "BugCreateTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -857,8 +852,8 @@ func (ec *executionContext) fieldContext_CreateTimelineItem_createdAt(_ context.
 	return fc, nil
 }
 
-func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CreateTimelineItem_lastEdit(ctx, field)
+func (ec *executionContext) _BugCreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreateTimelineItem_lastEdit(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -871,7 +866,7 @@ func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, fi
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
+		return ec.resolvers.BugCreateTimelineItem().LastEdit(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -888,9 +883,9 @@ func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, fi
 	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CreateTimelineItem_lastEdit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreateTimelineItem_lastEdit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CreateTimelineItem",
+		Object:     "BugCreateTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -901,8 +896,8 @@ func (ec *executionContext) fieldContext_CreateTimelineItem_lastEdit(_ context.C
 	return fc, nil
 }
 
-func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CreateTimelineItem_edited(ctx, field)
+func (ec *executionContext) _BugCreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreateTimelineItem_edited(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -932,9 +927,9 @@ func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, fiel
 	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CreateTimelineItem_edited(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreateTimelineItem_edited(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CreateTimelineItem",
+		Object:     "BugCreateTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: false,
@@ -945,8 +940,8 @@ func (ec *executionContext) fieldContext_CreateTimelineItem_edited(_ context.Con
 	return fc, nil
 }
 
-func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_CreateTimelineItem_history(ctx, field)
+func (ec *executionContext) _BugCreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugCreateTimelineItem_history(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -973,30 +968,30 @@ func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, fie
 	}
 	res := resTmp.([]bug.CommentHistoryStep)
 	fc.Result = res
-	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
+	return ec.marshalNBugCommentHistoryStep2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐCommentHistoryStepᚄ(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_CreateTimelineItem_history(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugCreateTimelineItem_history(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "CreateTimelineItem",
+		Object:     "BugCreateTimelineItem",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "message":
-				return ec.fieldContext_CommentHistoryStep_message(ctx, field)
+				return ec.fieldContext_BugCommentHistoryStep_message(ctx, field)
 			case "date":
-				return ec.fieldContext_CommentHistoryStep_date(ctx, field)
+				return ec.fieldContext_BugCommentHistoryStep_date(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type CommentHistoryStep", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugCommentHistoryStep", field.Name)
 		},
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_LabelChangeTimelineItem_id(ctx, field)
+func (ec *executionContext) _BugLabelChangeTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugLabelChangeTimelineItem_id(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1009,7 +1004,7 @@ func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, fie
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.LabelChangeTimelineItem().ID(rctx, obj)
+		return obj.CombinedId(), nil
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -1026,12 +1021,12 @@ func (ec *executionContext) _LabelChangeTimelineItem_id(ctx context.Context, fie
 	return ec.marshalNCombinedId2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚐCombinedId(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_LabelChangeTimelineItem_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugLabelChangeTimelineItem_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "LabelChangeTimelineItem",
+		Object:     "BugLabelChangeTimelineItem",
 		Field:      field,
 		IsMethod:   true,
-		IsResolver: true,
+		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			return nil, errors.New("field of type CombinedId does not have child fields")
 		},
@@ -1039,8 +1034,8 @@ func (ec *executionContext) fieldContext_LabelChangeTimelineItem_id(_ context.Co
 	return fc, nil
 }
 
-func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_LabelChangeTimelineItem_author(ctx, field)
+func (ec *executionContext) _BugLabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugLabelChangeTimelineItem_author(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1053,7 +1048,7 @@ func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context,
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.LabelChangeTimelineItem().Author(rctx, obj)
+		return ec.resolvers.BugLabelChangeTimelineItem().Author(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -1070,9 +1065,9 @@ func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context,
 	return ec.marshalNIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_LabelChangeTimelineItem_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugLabelChangeTimelineItem_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "LabelChangeTimelineItem",
+		Object:     "BugLabelChangeTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -1101,8 +1096,8 @@ func (ec *executionContext) fieldContext_LabelChangeTimelineItem_author(_ contex
 	return fc, nil
 }
 
-func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_LabelChangeTimelineItem_date(ctx, field)
+func (ec *executionContext) _BugLabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugLabelChangeTimelineItem_date(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1115,7 +1110,7 @@ func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, f
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
+		return ec.resolvers.BugLabelChangeTimelineItem().Date(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -1132,9 +1127,9 @@ func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, f
 	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_LabelChangeTimelineItem_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugLabelChangeTimelineItem_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "LabelChangeTimelineItem",
+		Object:     "BugLabelChangeTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -1145,8 +1140,8 @@ func (ec *executionContext) fieldContext_LabelChangeTimelineItem_date(_ context.
 	return fc, nil
 }
 
-func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_LabelChangeTimelineItem_added(ctx, field)
+func (ec *executionContext) _BugLabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugLabelChangeTimelineItem_added(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1176,9 +1171,9 @@ func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context,
 	return ec.marshalNLabel2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋcommonᚐLabelᚄ(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_LabelChangeTimelineItem_added(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugLabelChangeTimelineItem_added(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "LabelChangeTimelineItem",
+		Object:     "BugLabelChangeTimelineItem",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -1195,8 +1190,8 @@ func (ec *executionContext) fieldContext_LabelChangeTimelineItem_added(_ context
 	return fc, nil
 }
 
-func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_LabelChangeTimelineItem_removed(ctx, field)
+func (ec *executionContext) _BugLabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugLabelChangeTimelineItem_removed(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1226,9 +1221,9 @@ func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context
 	return ec.marshalNLabel2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋcommonᚐLabelᚄ(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_LabelChangeTimelineItem_removed(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugLabelChangeTimelineItem_removed(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "LabelChangeTimelineItem",
+		Object:     "BugLabelChangeTimelineItem",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -1245,8 +1240,8 @@ func (ec *executionContext) fieldContext_LabelChangeTimelineItem_removed(_ conte
 	return fc, nil
 }
 
-func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_SetStatusTimelineItem_id(ctx, field)
+func (ec *executionContext) _BugSetStatusTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugSetStatusTimelineItem_id(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1259,7 +1254,7 @@ func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.SetStatusTimelineItem().ID(rctx, obj)
+		return obj.CombinedId(), nil
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -1276,12 +1271,12 @@ func (ec *executionContext) _SetStatusTimelineItem_id(ctx context.Context, field
 	return ec.marshalNCombinedId2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚐCombinedId(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_SetStatusTimelineItem_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugSetStatusTimelineItem_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "SetStatusTimelineItem",
+		Object:     "BugSetStatusTimelineItem",
 		Field:      field,
 		IsMethod:   true,
-		IsResolver: true,
+		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			return nil, errors.New("field of type CombinedId does not have child fields")
 		},
@@ -1289,8 +1284,8 @@ func (ec *executionContext) fieldContext_SetStatusTimelineItem_id(_ context.Cont
 	return fc, nil
 }
 
-func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_SetStatusTimelineItem_author(ctx, field)
+func (ec *executionContext) _BugSetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugSetStatusTimelineItem_author(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1303,7 +1298,7 @@ func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, f
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.SetStatusTimelineItem().Author(rctx, obj)
+		return ec.resolvers.BugSetStatusTimelineItem().Author(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -1320,9 +1315,9 @@ func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, f
 	return ec.marshalNIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_SetStatusTimelineItem_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugSetStatusTimelineItem_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "SetStatusTimelineItem",
+		Object:     "BugSetStatusTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -1351,8 +1346,8 @@ func (ec *executionContext) fieldContext_SetStatusTimelineItem_author(_ context.
 	return fc, nil
 }
 
-func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_SetStatusTimelineItem_date(ctx, field)
+func (ec *executionContext) _BugSetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugSetStatusTimelineItem_date(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1365,7 +1360,7 @@ func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, fie
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
+		return ec.resolvers.BugSetStatusTimelineItem().Date(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -1382,9 +1377,9 @@ func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, fie
 	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_SetStatusTimelineItem_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugSetStatusTimelineItem_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "SetStatusTimelineItem",
+		Object:     "BugSetStatusTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -1395,8 +1390,8 @@ func (ec *executionContext) fieldContext_SetStatusTimelineItem_date(_ context.Co
 	return fc, nil
 }
 
-func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_SetStatusTimelineItem_status(ctx, field)
+func (ec *executionContext) _BugSetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugSetStatusTimelineItem_status(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1426,9 +1421,9 @@ func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, f
 	return ec.marshalNStatus2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋcommonᚐStatus(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_SetStatusTimelineItem_status(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugSetStatusTimelineItem_status(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "SetStatusTimelineItem",
+		Object:     "BugSetStatusTimelineItem",
 		Field:      field,
 		IsMethod:   false,
 		IsResolver: false,
@@ -1439,8 +1434,8 @@ func (ec *executionContext) fieldContext_SetStatusTimelineItem_status(_ context.
 	return fc, nil
 }
 
-func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_SetTitleTimelineItem_id(ctx, field)
+func (ec *executionContext) _BugSetTitleTimelineItem_id(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugSetTitleTimelineItem_id(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1453,7 +1448,7 @@ func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.SetTitleTimelineItem().ID(rctx, obj)
+		return obj.CombinedId(), nil
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -1470,12 +1465,12 @@ func (ec *executionContext) _SetTitleTimelineItem_id(ctx context.Context, field
 	return ec.marshalNCombinedId2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚐCombinedId(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_SetTitleTimelineItem_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugSetTitleTimelineItem_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "SetTitleTimelineItem",
+		Object:     "BugSetTitleTimelineItem",
 		Field:      field,
 		IsMethod:   true,
-		IsResolver: true,
+		IsResolver: false,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			return nil, errors.New("field of type CombinedId does not have child fields")
 		},
@@ -1483,8 +1478,8 @@ func (ec *executionContext) fieldContext_SetTitleTimelineItem_id(_ context.Conte
 	return fc, nil
 }
 
-func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_SetTitleTimelineItem_author(ctx, field)
+func (ec *executionContext) _BugSetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugSetTitleTimelineItem_author(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1497,7 +1492,7 @@ func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, fi
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.SetTitleTimelineItem().Author(rctx, obj)
+		return ec.resolvers.BugSetTitleTimelineItem().Author(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -1514,9 +1509,9 @@ func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, fi
 	return ec.marshalNIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_SetTitleTimelineItem_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugSetTitleTimelineItem_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "SetTitleTimelineItem",
+		Object:     "BugSetTitleTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -1545,8 +1540,8 @@ func (ec *executionContext) fieldContext_SetTitleTimelineItem_author(_ context.C
 	return fc, nil
 }
 
-func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_SetTitleTimelineItem_date(ctx, field)
+func (ec *executionContext) _BugSetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugSetTitleTimelineItem_date(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -1559,7 +1554,7 @@ func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, fiel
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
+		return ec.resolvers.BugSetTitleTimelineItem().Date(rctx, obj)
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -1576,9 +1571,9 @@ func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, fiel
 	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_SetTitleTimelineItem_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_BugSetTitleTimelineItem_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
-		Object:     "SetTitleTimelineItem",
+		Object:     "BugSetTitleTimelineItem",
 		Field:      field,
 		IsMethod:   true,
 		IsResolver: true,
@@ -1589,8 +1584,8 @@ func (ec *executionContext) fieldContext_SetTitleTimelineItem_date(_ context.Con
 	return fc, nil
 }
 
-func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_SetTitleTimelineItem_title(ctx, field)
+func (ec *executionContext) _BugSetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_BugSetTitleTimelineItem_title(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}

api/graphql/graph/label.generated.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/99designs/gqlgen/graphql"
 	"github.com/git-bug/git-bug/api/graphql/models"
+	"github.com/git-bug/git-bug/entities/bug"
 	"github.com/git-bug/git-bug/entities/common"
 	"github.com/vektah/gqlparser/v2/ast"
 )
@@ -132,6 +133,100 @@ func (ec *executionContext) fieldContext_Label_color(_ context.Context, field gr
 	return fc, nil
 }
 
+func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_LabelChangeResult_label(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Label, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(common.Label)
+	fc.Result = res
+	return ec.marshalNLabel2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋcommonᚐLabel(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_LabelChangeResult_label(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "LabelChangeResult",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			switch field.Name {
+			case "name":
+				return ec.fieldContext_Label_name(ctx, field)
+			case "color":
+				return ec.fieldContext_Label_color(ctx, field)
+			}
+			return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_LabelChangeResult_status(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Status, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(bug.LabelChangeStatus)
+	fc.Result = res
+	return ec.marshalNLabelChangeStatus2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeStatus(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_LabelChangeResult_status(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "LabelChangeResult",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type LabelChangeStatus does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
 func (ec *executionContext) _LabelConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.LabelConnection) (ret graphql.Marshaler) {
 	fc, err := ec.fieldContext_LabelConnection_edges(ctx, field)
 	if err != nil {
@@ -542,6 +637,50 @@ func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, ob
 	return out
 }
 
+var labelChangeResultImplementors = []string{"LabelChangeResult"}
+
+func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
+	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
+
+	out := graphql.NewFieldSet(fields)
+	deferred := make(map[string]*graphql.FieldSet)
+	for i, field := range fields {
+		switch field.Name {
+		case "__typename":
+			out.Values[i] = graphql.MarshalString("LabelChangeResult")
+		case "label":
+			out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				out.Invalids++
+			}
+		case "status":
+			out.Values[i] = ec._LabelChangeResult_status(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				out.Invalids++
+			}
+		default:
+			panic("unknown field " + strconv.Quote(field.Name))
+		}
+	}
+	out.Dispatch(ctx)
+	if out.Invalids > 0 {
+		return graphql.Null
+	}
+
+	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+	for label, dfs := range deferred {
+		ec.processDeferredGroup(graphql.DeferredGroup{
+			Label:    label,
+			Path:     graphql.GetPath(ctx),
+			FieldSet: dfs,
+			Context:  ctx,
+		})
+	}
+
+	return out
+}
+
 var labelConnectionImplementors = []string{"LabelConnection"}
 
 func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
@@ -692,6 +831,54 @@ func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbu
 	return ret
 }
 
+func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
+	ret := make(graphql.Array, len(v))
+	var wg sync.WaitGroup
+	isLen1 := len(v) == 1
+	if !isLen1 {
+		wg.Add(len(v))
+	}
+	for i := range v {
+		i := i
+		fc := &graphql.FieldContext{
+			Index:  &i,
+			Result: &v[i],
+		}
+		ctx := graphql.WithFieldContext(ctx, fc)
+		f := func(i int) {
+			defer func() {
+				if r := recover(); r != nil {
+					ec.Error(ctx, ec.Recover(ctx, r))
+					ret = nil
+				}
+			}()
+			if !isLen1 {
+				defer wg.Done()
+			}
+			ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeResult(ctx, sel, v[i])
+		}
+		if isLen1 {
+			f(i)
+		} else {
+			go f(i)
+		}
+
+	}
+	wg.Wait()
+
+	return ret
+}
+
+func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeStatus(ctx context.Context, v interface{}) (bug.LabelChangeStatus, error) {
+	var res bug.LabelChangeStatus
+	err := res.UnmarshalGQL(v)
+	return res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeStatus) graphql.Marshaler {
+	return v
+}
+
 func (ec *executionContext) marshalNLabelConnection2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐLabelConnection(ctx context.Context, sel ast.SelectionSet, v models.LabelConnection) graphql.Marshaler {
 	return ec._LabelConnection(ctx, sel, &v)
 }
@@ -760,4 +947,11 @@ func (ec *executionContext) marshalNLabelEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgit
 	return ec._LabelEdge(ctx, sel, v)
 }
 
+func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
+	if v == nil {
+		return graphql.Null
+	}
+	return ec._LabelChangeResult(ctx, sel, v)
+}
+
 // endregion ***************************** type.gotpl *****************************

api/graphql/graph/operation.generated.go

@@ -0,0 +1,589 @@
+// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
+
+package graph
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strconv"
+	"sync"
+	"sync/atomic"
+
+	"github.com/99designs/gqlgen/graphql"
+	"github.com/git-bug/git-bug/api/graphql/models"
+	"github.com/git-bug/git-bug/entities/bug"
+	"github.com/git-bug/git-bug/entity/dag"
+	"github.com/vektah/gqlparser/v2/ast"
+)
+
+// region    ************************** generated!.gotpl **************************
+
+// endregion ************************** generated!.gotpl **************************
+
+// region    ***************************** args.gotpl *****************************
+
+// endregion ***************************** args.gotpl *****************************
+
+// region    ************************** directives.gotpl **************************
+
+// endregion ************************** directives.gotpl **************************
+
+// region    **************************** field.gotpl *****************************
+
+func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_OperationConnection_edges(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Edges, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.([]*models.OperationEdge)
+	fc.Result = res
+	return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_OperationConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "OperationConnection",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			switch field.Name {
+			case "cursor":
+				return ec.fieldContext_OperationEdge_cursor(ctx, field)
+			case "node":
+				return ec.fieldContext_OperationEdge_node(ctx, field)
+			}
+			return nil, fmt.Errorf("no field named %q was found under type OperationEdge", field.Name)
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_OperationConnection_nodes(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Nodes, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.([]dag.Operation)
+	fc.Result = res
+	return ec.marshalNOperation2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚋdagᚐOperationᚄ(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_OperationConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "OperationConnection",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_OperationConnection_pageInfo(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.PageInfo, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(*models.PageInfo)
+	fc.Result = res
+	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_OperationConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "OperationConnection",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			switch field.Name {
+			case "hasNextPage":
+				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
+			case "hasPreviousPage":
+				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
+			case "startCursor":
+				return ec.fieldContext_PageInfo_startCursor(ctx, field)
+			case "endCursor":
+				return ec.fieldContext_PageInfo_endCursor(ctx, field)
+			}
+			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_OperationConnection_totalCount(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.TotalCount, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(int)
+	fc.Result = res
+	return ec.marshalNInt2int(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_OperationConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "OperationConnection",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type Int does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_OperationEdge_cursor(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Cursor, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(string)
+	fc.Result = res
+	return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_OperationEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "OperationEdge",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("field of type String does not have child fields")
+		},
+	}
+	return fc, nil
+}
+
+func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_OperationEdge_node(ctx, field)
+	if err != nil {
+		return graphql.Null
+	}
+	ctx = graphql.WithFieldContext(ctx, fc)
+	defer func() {
+		if r := recover(); r != nil {
+			ec.Error(ctx, ec.Recover(ctx, r))
+			ret = graphql.Null
+		}
+	}()
+	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Node, nil
+	})
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	if resTmp == nil {
+		if !graphql.HasFieldError(ctx, fc) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(dag.Operation)
+	fc.Result = res
+	return ec.marshalNOperation2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚋdagᚐOperation(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) fieldContext_OperationEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+	fc = &graphql.FieldContext{
+		Object:     "OperationEdge",
+		Field:      field,
+		IsMethod:   false,
+		IsResolver: false,
+		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+			return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE")
+		},
+	}
+	return fc, nil
+}
+
+// endregion **************************** field.gotpl *****************************
+
+// region    **************************** input.gotpl *****************************
+
+// endregion **************************** input.gotpl *****************************
+
+// region    ************************** interface.gotpl ***************************
+
+func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj dag.Operation) graphql.Marshaler {
+	switch obj := (obj).(type) {
+	case nil:
+		return graphql.Null
+	case *bug.CreateOperation:
+		if obj == nil {
+			return graphql.Null
+		}
+		return ec._BugCreateOperation(ctx, sel, obj)
+	case *bug.SetTitleOperation:
+		if obj == nil {
+			return graphql.Null
+		}
+		return ec._BugSetTitleOperation(ctx, sel, obj)
+	case *bug.AddCommentOperation:
+		if obj == nil {
+			return graphql.Null
+		}
+		return ec._BugAddCommentOperation(ctx, sel, obj)
+	case *bug.EditCommentOperation:
+		if obj == nil {
+			return graphql.Null
+		}
+		return ec._BugEditCommentOperation(ctx, sel, obj)
+	case *bug.SetStatusOperation:
+		if obj == nil {
+			return graphql.Null
+		}
+		return ec._BugSetStatusOperation(ctx, sel, obj)
+	case *bug.LabelChangeOperation:
+		if obj == nil {
+			return graphql.Null
+		}
+		return ec._BugLabelChangeOperation(ctx, sel, obj)
+	default:
+		panic(fmt.Errorf("unexpected type %T", obj))
+	}
+}
+
+// endregion ************************** interface.gotpl ***************************
+
+// region    **************************** object.gotpl ****************************
+
+var operationConnectionImplementors = []string{"OperationConnection"}
+
+func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
+	fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
+
+	out := graphql.NewFieldSet(fields)
+	deferred := make(map[string]*graphql.FieldSet)
+	for i, field := range fields {
+		switch field.Name {
+		case "__typename":
+			out.Values[i] = graphql.MarshalString("OperationConnection")
+		case "edges":
+			out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				out.Invalids++
+			}
+		case "nodes":
+			out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				out.Invalids++
+			}
+		case "pageInfo":
+			out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				out.Invalids++
+			}
+		case "totalCount":
+			out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				out.Invalids++
+			}
+		default:
+			panic("unknown field " + strconv.Quote(field.Name))
+		}
+	}
+	out.Dispatch(ctx)
+	if out.Invalids > 0 {
+		return graphql.Null
+	}
+
+	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+	for label, dfs := range deferred {
+		ec.processDeferredGroup(graphql.DeferredGroup{
+			Label:    label,
+			Path:     graphql.GetPath(ctx),
+			FieldSet: dfs,
+			Context:  ctx,
+		})
+	}
+
+	return out
+}
+
+var operationEdgeImplementors = []string{"OperationEdge"}
+
+func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
+	fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
+
+	out := graphql.NewFieldSet(fields)
+	deferred := make(map[string]*graphql.FieldSet)
+	for i, field := range fields {
+		switch field.Name {
+		case "__typename":
+			out.Values[i] = graphql.MarshalString("OperationEdge")
+		case "cursor":
+			out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				out.Invalids++
+			}
+		case "node":
+			out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				out.Invalids++
+			}
+		default:
+			panic("unknown field " + strconv.Quote(field.Name))
+		}
+	}
+	out.Dispatch(ctx)
+	if out.Invalids > 0 {
+		return graphql.Null
+	}
+
+	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+	for label, dfs := range deferred {
+		ec.processDeferredGroup(graphql.DeferredGroup{
+			Label:    label,
+			Path:     graphql.GetPath(ctx),
+			FieldSet: dfs,
+			Context:  ctx,
+		})
+	}
+
+	return out
+}
+
+// endregion **************************** object.gotpl ****************************
+
+// region    ***************************** type.gotpl *****************************
+
+func (ec *executionContext) marshalNOperation2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚋdagᚐOperation(ctx context.Context, sel ast.SelectionSet, v dag.Operation) graphql.Marshaler {
+	if v == nil {
+		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
+		}
+		return graphql.Null
+	}
+	return ec._Operation(ctx, sel, v)
+}
+
+func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚋdagᚐOperationᚄ(ctx context.Context, sel ast.SelectionSet, v []dag.Operation) graphql.Marshaler {
+	ret := make(graphql.Array, len(v))
+	var wg sync.WaitGroup
+	isLen1 := len(v) == 1
+	if !isLen1 {
+		wg.Add(len(v))
+	}
+	for i := range v {
+		i := i
+		fc := &graphql.FieldContext{
+			Index:  &i,
+			Result: &v[i],
+		}
+		ctx := graphql.WithFieldContext(ctx, fc)
+		f := func(i int) {
+			defer func() {
+				if r := recover(); r != nil {
+					ec.Error(ctx, ec.Recover(ctx, r))
+					ret = nil
+				}
+			}()
+			if !isLen1 {
+				defer wg.Done()
+			}
+			ret[i] = ec.marshalNOperation2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚋdagᚐOperation(ctx, sel, v[i])
+		}
+		if isLen1 {
+			f(i)
+		} else {
+			go f(i)
+		}
+
+	}
+	wg.Wait()
+
+	for _, e := range ret {
+		if e == graphql.Null {
+			return graphql.Null
+		}
+	}
+
+	return ret
+}
+
+func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
+	return ec._OperationConnection(ctx, sel, &v)
+}
+
+func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
+	if v == nil {
+		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
+		}
+		return graphql.Null
+	}
+	return ec._OperationConnection(ctx, sel, v)
+}
+
+func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
+	ret := make(graphql.Array, len(v))
+	var wg sync.WaitGroup
+	isLen1 := len(v) == 1
+	if !isLen1 {
+		wg.Add(len(v))
+	}
+	for i := range v {
+		i := i
+		fc := &graphql.FieldContext{
+			Index:  &i,
+			Result: &v[i],
+		}
+		ctx := graphql.WithFieldContext(ctx, fc)
+		f := func(i int) {
+			defer func() {
+				if r := recover(); r != nil {
+					ec.Error(ctx, ec.Recover(ctx, r))
+					ret = nil
+				}
+			}()
+			if !isLen1 {
+				defer wg.Done()
+			}
+			ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
+		}
+		if isLen1 {
+			f(i)
+		} else {
+			go f(i)
+		}
+
+	}
+	wg.Wait()
+
+	for _, e := range ret {
+		if e == graphql.Null {
+			return graphql.Null
+		}
+	}
+
+	return ret
+}
+
+func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
+	if v == nil {
+		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
+		}
+		return graphql.Null
+	}
+	return ec._OperationEdge(ctx, sel, v)
+}
+
+// endregion ***************************** type.gotpl *****************************

api/graphql/graph/root.generated.go

@@ -17,15 +17,15 @@ import (
 // region    ************************** generated!.gotpl **************************
 
 type MutationResolver interface {
-	NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
-	AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
-	AddCommentAndClose(ctx context.Context, input models.AddCommentAndCloseBugInput) (*models.AddCommentAndCloseBugPayload, error)
-	AddCommentAndReopen(ctx context.Context, input models.AddCommentAndReopenBugInput) (*models.AddCommentAndReopenBugPayload, error)
-	EditComment(ctx context.Context, input models.EditCommentInput) (*models.EditCommentPayload, error)
-	ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
-	OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
-	CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
-	SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
+	BugCreate(ctx context.Context, input models.BugCreateInput) (*models.BugCreatePayload, error)
+	BugAddComment(ctx context.Context, input models.BugAddCommentInput) (*models.BugAddCommentPayload, error)
+	BugAddCommentAndClose(ctx context.Context, input models.BugAddCommentAndCloseInput) (*models.BugAddCommentAndClosePayload, error)
+	BugAddCommentAndReopen(ctx context.Context, input models.BugAddCommentAndReopenInput) (*models.BugAddCommentAndReopenPayload, error)
+	BugEditComment(ctx context.Context, input models.BugEditCommentInput) (*models.BugEditCommentPayload, error)
+	BugChangeLabels(ctx context.Context, input *models.BugChangeLabelInput) (*models.BugChangeLabelPayload, error)
+	BugStatusOpen(ctx context.Context, input models.BugStatusOpenInput) (*models.BugStatusOpenPayload, error)
+	BugStatusClose(ctx context.Context, input models.BugStatusCloseInput) (*models.BugStatusClosePayload, error)
+	BugSetTitle(ctx context.Context, input models.BugSetTitleInput) (*models.BugSetTitlePayload, error)
 }
 type QueryResolver interface {
 	Repository(ctx context.Context, ref *string) (*models.Repository, error)
@@ -35,13 +35,13 @@ type QueryResolver interface {
 
 // region    ***************************** args.gotpl *****************************
 
-func (ec *executionContext) field_Mutation_addCommentAndClose_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+func (ec *executionContext) field_Mutation_bugAddCommentAndClose_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 	var err error
 	args := map[string]interface{}{}
-	var arg0 models.AddCommentAndCloseBugInput
+	var arg0 models.BugAddCommentAndCloseInput
 	if tmp, ok := rawArgs["input"]; ok {
 		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
-		arg0, err = ec.unmarshalNAddCommentAndCloseBugInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugInput(ctx, tmp)
+		arg0, err = ec.unmarshalNBugAddCommentAndCloseInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentAndCloseInput(ctx, tmp)
 		if err != nil {
 			return nil, err
 		}
@@ -50,13 +50,13 @@ func (ec *executionContext) field_Mutation_addCommentAndClose_args(ctx context.C
 	return args, nil
 }
 
-func (ec *executionContext) field_Mutation_addCommentAndReopen_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+func (ec *executionContext) field_Mutation_bugAddCommentAndReopen_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 	var err error
 	args := map[string]interface{}{}
-	var arg0 models.AddCommentAndReopenBugInput
+	var arg0 models.BugAddCommentAndReopenInput
 	if tmp, ok := rawArgs["input"]; ok {
 		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
-		arg0, err = ec.unmarshalNAddCommentAndReopenBugInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugInput(ctx, tmp)
+		arg0, err = ec.unmarshalNBugAddCommentAndReopenInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentAndReopenInput(ctx, tmp)
 		if err != nil {
 			return nil, err
 		}
@@ -65,13 +65,13 @@ func (ec *executionContext) field_Mutation_addCommentAndReopen_args(ctx context.
 	return args, nil
 }
 
-func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+func (ec *executionContext) field_Mutation_bugAddComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 	var err error
 	args := map[string]interface{}{}
-	var arg0 models.AddCommentInput
+	var arg0 models.BugAddCommentInput
 	if tmp, ok := rawArgs["input"]; ok {
 		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
-		arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
+		arg0, err = ec.unmarshalNBugAddCommentInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentInput(ctx, tmp)
 		if err != nil {
 			return nil, err
 		}
@@ -80,13 +80,13 @@ func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context,
 	return args, nil
 }
 
-func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+func (ec *executionContext) field_Mutation_bugChangeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 	var err error
 	args := map[string]interface{}{}
-	var arg0 *models.ChangeLabelInput
+	var arg0 *models.BugChangeLabelInput
 	if tmp, ok := rawArgs["input"]; ok {
 		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
-		arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
+		arg0, err = ec.unmarshalOBugChangeLabelInput2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugChangeLabelInput(ctx, tmp)
 		if err != nil {
 			return nil, err
 		}
@@ -95,13 +95,13 @@ func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context
 	return args, nil
 }
 
-func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+func (ec *executionContext) field_Mutation_bugCreate_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 	var err error
 	args := map[string]interface{}{}
-	var arg0 models.CloseBugInput
+	var arg0 models.BugCreateInput
 	if tmp, ok := rawArgs["input"]; ok {
 		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
-		arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
+		arg0, err = ec.unmarshalNBugCreateInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugCreateInput(ctx, tmp)
 		if err != nil {
 			return nil, err
 		}
@@ -110,13 +110,13 @@ func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, ra
 	return args, nil
 }
 
-func (ec *executionContext) field_Mutation_editComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+func (ec *executionContext) field_Mutation_bugEditComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 	var err error
 	args := map[string]interface{}{}
-	var arg0 models.EditCommentInput
+	var arg0 models.BugEditCommentInput
 	if tmp, ok := rawArgs["input"]; ok {
 		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
-		arg0, err = ec.unmarshalNEditCommentInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentInput(ctx, tmp)
+		arg0, err = ec.unmarshalNBugEditCommentInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEditCommentInput(ctx, tmp)
 		if err != nil {
 			return nil, err
 		}
@@ -125,13 +125,13 @@ func (ec *executionContext) field_Mutation_editComment_args(ctx context.Context,
 	return args, nil
 }
 
-func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+func (ec *executionContext) field_Mutation_bugSetTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 	var err error
 	args := map[string]interface{}{}
-	var arg0 models.NewBugInput
+	var arg0 models.BugSetTitleInput
 	if tmp, ok := rawArgs["input"]; ok {
 		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
-		arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
+		arg0, err = ec.unmarshalNBugSetTitleInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugSetTitleInput(ctx, tmp)
 		if err != nil {
 			return nil, err
 		}
@@ -140,13 +140,13 @@ func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawA
 	return args, nil
 }
 
-func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+func (ec *executionContext) field_Mutation_bugStatusClose_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 	var err error
 	args := map[string]interface{}{}
-	var arg0 models.OpenBugInput
+	var arg0 models.BugStatusCloseInput
 	if tmp, ok := rawArgs["input"]; ok {
 		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
-		arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
+		arg0, err = ec.unmarshalNBugStatusCloseInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugStatusCloseInput(ctx, tmp)
 		if err != nil {
 			return nil, err
 		}
@@ -155,13 +155,13 @@ func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, raw
 	return args, nil
 }
 
-func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+func (ec *executionContext) field_Mutation_bugStatusOpen_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 	var err error
 	args := map[string]interface{}{}
-	var arg0 models.SetTitleInput
+	var arg0 models.BugStatusOpenInput
 	if tmp, ok := rawArgs["input"]; ok {
 		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("input"))
-		arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
+		arg0, err = ec.unmarshalNBugStatusOpenInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugStatusOpenInput(ctx, tmp)
 		if err != nil {
 			return nil, err
 		}
@@ -208,8 +208,8 @@ func (ec *executionContext) field_Query_repository_args(ctx context.Context, raw
 
 // region    **************************** field.gotpl *****************************
 
-func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_Mutation_newBug(ctx, field)
+func (ec *executionContext) _Mutation_bugCreate(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_Mutation_bugCreate(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -222,7 +222,7 @@ func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.Mutation().NewBug(rctx, fc.Args["input"].(models.NewBugInput))
+		return ec.resolvers.Mutation().BugCreate(rctx, fc.Args["input"].(models.BugCreateInput))
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -234,12 +234,12 @@ func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*models.NewBugPayload)
+	res := resTmp.(*models.BugCreatePayload)
 	fc.Result = res
-	return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
+	return ec.marshalNBugCreatePayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugCreatePayload(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_Mutation_newBug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_Mutation_bugCreate(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
 		Object:     "Mutation",
 		Field:      field,
@@ -248,13 +248,13 @@ func (ec *executionContext) fieldContext_Mutation_newBug(ctx context.Context, fi
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "clientMutationId":
-				return ec.fieldContext_NewBugPayload_clientMutationId(ctx, field)
+				return ec.fieldContext_BugCreatePayload_clientMutationId(ctx, field)
 			case "bug":
-				return ec.fieldContext_NewBugPayload_bug(ctx, field)
+				return ec.fieldContext_BugCreatePayload_bug(ctx, field)
 			case "operation":
-				return ec.fieldContext_NewBugPayload_operation(ctx, field)
+				return ec.fieldContext_BugCreatePayload_operation(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type NewBugPayload", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugCreatePayload", field.Name)
 		},
 	}
 	defer func() {
@@ -264,15 +264,15 @@ func (ec *executionContext) fieldContext_Mutation_newBug(ctx context.Context, fi
 		}
 	}()
 	ctx = graphql.WithFieldContext(ctx, fc)
-	if fc.Args, err = ec.field_Mutation_newBug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+	if fc.Args, err = ec.field_Mutation_bugCreate_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 		ec.Error(ctx, err)
 		return fc, err
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_Mutation_addComment(ctx, field)
+func (ec *executionContext) _Mutation_bugAddComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_Mutation_bugAddComment(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -285,7 +285,7 @@ func (ec *executionContext) _Mutation_addComment(ctx context.Context, field grap
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.Mutation().AddComment(rctx, fc.Args["input"].(models.AddCommentInput))
+		return ec.resolvers.Mutation().BugAddComment(rctx, fc.Args["input"].(models.BugAddCommentInput))
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -297,12 +297,12 @@ func (ec *executionContext) _Mutation_addComment(ctx context.Context, field grap
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*models.AddCommentPayload)
+	res := resTmp.(*models.BugAddCommentPayload)
 	fc.Result = res
-	return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
+	return ec.marshalNBugAddCommentPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentPayload(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_Mutation_addComment(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_Mutation_bugAddComment(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
 		Object:     "Mutation",
 		Field:      field,
@@ -311,13 +311,13 @@ func (ec *executionContext) fieldContext_Mutation_addComment(ctx context.Context
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "clientMutationId":
-				return ec.fieldContext_AddCommentPayload_clientMutationId(ctx, field)
+				return ec.fieldContext_BugAddCommentPayload_clientMutationId(ctx, field)
 			case "bug":
-				return ec.fieldContext_AddCommentPayload_bug(ctx, field)
+				return ec.fieldContext_BugAddCommentPayload_bug(ctx, field)
 			case "operation":
-				return ec.fieldContext_AddCommentPayload_operation(ctx, field)
+				return ec.fieldContext_BugAddCommentPayload_operation(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type AddCommentPayload", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugAddCommentPayload", field.Name)
 		},
 	}
 	defer func() {
@@ -327,15 +327,15 @@ func (ec *executionContext) fieldContext_Mutation_addComment(ctx context.Context
 		}
 	}()
 	ctx = graphql.WithFieldContext(ctx, fc)
-	if fc.Args, err = ec.field_Mutation_addComment_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+	if fc.Args, err = ec.field_Mutation_bugAddComment_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 		ec.Error(ctx, err)
 		return fc, err
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _Mutation_addCommentAndClose(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_Mutation_addCommentAndClose(ctx, field)
+func (ec *executionContext) _Mutation_bugAddCommentAndClose(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_Mutation_bugAddCommentAndClose(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -348,7 +348,7 @@ func (ec *executionContext) _Mutation_addCommentAndClose(ctx context.Context, fi
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.Mutation().AddCommentAndClose(rctx, fc.Args["input"].(models.AddCommentAndCloseBugInput))
+		return ec.resolvers.Mutation().BugAddCommentAndClose(rctx, fc.Args["input"].(models.BugAddCommentAndCloseInput))
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -360,12 +360,12 @@ func (ec *executionContext) _Mutation_addCommentAndClose(ctx context.Context, fi
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*models.AddCommentAndCloseBugPayload)
+	res := resTmp.(*models.BugAddCommentAndClosePayload)
 	fc.Result = res
-	return ec.marshalNAddCommentAndCloseBugPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx, field.Selections, res)
+	return ec.marshalNBugAddCommentAndClosePayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentAndClosePayload(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_Mutation_addCommentAndClose(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_Mutation_bugAddCommentAndClose(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
 		Object:     "Mutation",
 		Field:      field,
@@ -374,15 +374,15 @@ func (ec *executionContext) fieldContext_Mutation_addCommentAndClose(ctx context
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "clientMutationId":
-				return ec.fieldContext_AddCommentAndCloseBugPayload_clientMutationId(ctx, field)
+				return ec.fieldContext_BugAddCommentAndClosePayload_clientMutationId(ctx, field)
 			case "bug":
-				return ec.fieldContext_AddCommentAndCloseBugPayload_bug(ctx, field)
+				return ec.fieldContext_BugAddCommentAndClosePayload_bug(ctx, field)
 			case "commentOperation":
-				return ec.fieldContext_AddCommentAndCloseBugPayload_commentOperation(ctx, field)
+				return ec.fieldContext_BugAddCommentAndClosePayload_commentOperation(ctx, field)
 			case "statusOperation":
-				return ec.fieldContext_AddCommentAndCloseBugPayload_statusOperation(ctx, field)
+				return ec.fieldContext_BugAddCommentAndClosePayload_statusOperation(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type AddCommentAndCloseBugPayload", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugAddCommentAndClosePayload", field.Name)
 		},
 	}
 	defer func() {
@@ -392,15 +392,15 @@ func (ec *executionContext) fieldContext_Mutation_addCommentAndClose(ctx context
 		}
 	}()
 	ctx = graphql.WithFieldContext(ctx, fc)
-	if fc.Args, err = ec.field_Mutation_addCommentAndClose_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+	if fc.Args, err = ec.field_Mutation_bugAddCommentAndClose_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 		ec.Error(ctx, err)
 		return fc, err
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _Mutation_addCommentAndReopen(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_Mutation_addCommentAndReopen(ctx, field)
+func (ec *executionContext) _Mutation_bugAddCommentAndReopen(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_Mutation_bugAddCommentAndReopen(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -413,7 +413,7 @@ func (ec *executionContext) _Mutation_addCommentAndReopen(ctx context.Context, f
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.Mutation().AddCommentAndReopen(rctx, fc.Args["input"].(models.AddCommentAndReopenBugInput))
+		return ec.resolvers.Mutation().BugAddCommentAndReopen(rctx, fc.Args["input"].(models.BugAddCommentAndReopenInput))
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -425,12 +425,12 @@ func (ec *executionContext) _Mutation_addCommentAndReopen(ctx context.Context, f
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*models.AddCommentAndReopenBugPayload)
+	res := resTmp.(*models.BugAddCommentAndReopenPayload)
 	fc.Result = res
-	return ec.marshalNAddCommentAndReopenBugPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugPayload(ctx, field.Selections, res)
+	return ec.marshalNBugAddCommentAndReopenPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentAndReopenPayload(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_Mutation_addCommentAndReopen(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_Mutation_bugAddCommentAndReopen(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
 		Object:     "Mutation",
 		Field:      field,
@@ -439,15 +439,15 @@ func (ec *executionContext) fieldContext_Mutation_addCommentAndReopen(ctx contex
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "clientMutationId":
-				return ec.fieldContext_AddCommentAndReopenBugPayload_clientMutationId(ctx, field)
+				return ec.fieldContext_BugAddCommentAndReopenPayload_clientMutationId(ctx, field)
 			case "bug":
-				return ec.fieldContext_AddCommentAndReopenBugPayload_bug(ctx, field)
+				return ec.fieldContext_BugAddCommentAndReopenPayload_bug(ctx, field)
 			case "commentOperation":
-				return ec.fieldContext_AddCommentAndReopenBugPayload_commentOperation(ctx, field)
+				return ec.fieldContext_BugAddCommentAndReopenPayload_commentOperation(ctx, field)
 			case "statusOperation":
-				return ec.fieldContext_AddCommentAndReopenBugPayload_statusOperation(ctx, field)
+				return ec.fieldContext_BugAddCommentAndReopenPayload_statusOperation(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type AddCommentAndReopenBugPayload", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugAddCommentAndReopenPayload", field.Name)
 		},
 	}
 	defer func() {
@@ -457,15 +457,15 @@ func (ec *executionContext) fieldContext_Mutation_addCommentAndReopen(ctx contex
 		}
 	}()
 	ctx = graphql.WithFieldContext(ctx, fc)
-	if fc.Args, err = ec.field_Mutation_addCommentAndReopen_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+	if fc.Args, err = ec.field_Mutation_bugAddCommentAndReopen_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 		ec.Error(ctx, err)
 		return fc, err
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _Mutation_editComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_Mutation_editComment(ctx, field)
+func (ec *executionContext) _Mutation_bugEditComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_Mutation_bugEditComment(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -478,7 +478,7 @@ func (ec *executionContext) _Mutation_editComment(ctx context.Context, field gra
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.Mutation().EditComment(rctx, fc.Args["input"].(models.EditCommentInput))
+		return ec.resolvers.Mutation().BugEditComment(rctx, fc.Args["input"].(models.BugEditCommentInput))
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -490,12 +490,12 @@ func (ec *executionContext) _Mutation_editComment(ctx context.Context, field gra
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*models.EditCommentPayload)
+	res := resTmp.(*models.BugEditCommentPayload)
 	fc.Result = res
-	return ec.marshalNEditCommentPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx, field.Selections, res)
+	return ec.marshalNBugEditCommentPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEditCommentPayload(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_Mutation_editComment(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_Mutation_bugEditComment(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
 		Object:     "Mutation",
 		Field:      field,
@@ -504,13 +504,13 @@ func (ec *executionContext) fieldContext_Mutation_editComment(ctx context.Contex
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "clientMutationId":
-				return ec.fieldContext_EditCommentPayload_clientMutationId(ctx, field)
+				return ec.fieldContext_BugEditCommentPayload_clientMutationId(ctx, field)
 			case "bug":
-				return ec.fieldContext_EditCommentPayload_bug(ctx, field)
+				return ec.fieldContext_BugEditCommentPayload_bug(ctx, field)
 			case "operation":
-				return ec.fieldContext_EditCommentPayload_operation(ctx, field)
+				return ec.fieldContext_BugEditCommentPayload_operation(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type EditCommentPayload", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugEditCommentPayload", field.Name)
 		},
 	}
 	defer func() {
@@ -520,15 +520,15 @@ func (ec *executionContext) fieldContext_Mutation_editComment(ctx context.Contex
 		}
 	}()
 	ctx = graphql.WithFieldContext(ctx, fc)
-	if fc.Args, err = ec.field_Mutation_editComment_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+	if fc.Args, err = ec.field_Mutation_bugEditComment_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 		ec.Error(ctx, err)
 		return fc, err
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_Mutation_changeLabels(ctx, field)
+func (ec *executionContext) _Mutation_bugChangeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_Mutation_bugChangeLabels(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -541,7 +541,7 @@ func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field gr
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.Mutation().ChangeLabels(rctx, fc.Args["input"].(*models.ChangeLabelInput))
+		return ec.resolvers.Mutation().BugChangeLabels(rctx, fc.Args["input"].(*models.BugChangeLabelInput))
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -553,12 +553,12 @@ func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field gr
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*models.ChangeLabelPayload)
+	res := resTmp.(*models.BugChangeLabelPayload)
 	fc.Result = res
-	return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
+	return ec.marshalNBugChangeLabelPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugChangeLabelPayload(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_Mutation_bugChangeLabels(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
 		Object:     "Mutation",
 		Field:      field,
@@ -567,15 +567,15 @@ func (ec *executionContext) fieldContext_Mutation_changeLabels(ctx context.Conte
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "clientMutationId":
-				return ec.fieldContext_ChangeLabelPayload_clientMutationId(ctx, field)
+				return ec.fieldContext_BugChangeLabelPayload_clientMutationId(ctx, field)
 			case "bug":
-				return ec.fieldContext_ChangeLabelPayload_bug(ctx, field)
+				return ec.fieldContext_BugChangeLabelPayload_bug(ctx, field)
 			case "operation":
-				return ec.fieldContext_ChangeLabelPayload_operation(ctx, field)
+				return ec.fieldContext_BugChangeLabelPayload_operation(ctx, field)
 			case "results":
-				return ec.fieldContext_ChangeLabelPayload_results(ctx, field)
+				return ec.fieldContext_BugChangeLabelPayload_results(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type ChangeLabelPayload", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugChangeLabelPayload", field.Name)
 		},
 	}
 	defer func() {
@@ -585,15 +585,15 @@ func (ec *executionContext) fieldContext_Mutation_changeLabels(ctx context.Conte
 		}
 	}()
 	ctx = graphql.WithFieldContext(ctx, fc)
-	if fc.Args, err = ec.field_Mutation_changeLabels_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+	if fc.Args, err = ec.field_Mutation_bugChangeLabels_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 		ec.Error(ctx, err)
 		return fc, err
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_Mutation_openBug(ctx, field)
+func (ec *executionContext) _Mutation_bugStatusOpen(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_Mutation_bugStatusOpen(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -606,7 +606,7 @@ func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.Mutation().OpenBug(rctx, fc.Args["input"].(models.OpenBugInput))
+		return ec.resolvers.Mutation().BugStatusOpen(rctx, fc.Args["input"].(models.BugStatusOpenInput))
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -618,12 +618,12 @@ func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*models.OpenBugPayload)
+	res := resTmp.(*models.BugStatusOpenPayload)
 	fc.Result = res
-	return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
+	return ec.marshalNBugStatusOpenPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugStatusOpenPayload(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_Mutation_openBug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_Mutation_bugStatusOpen(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
 		Object:     "Mutation",
 		Field:      field,
@@ -632,13 +632,13 @@ func (ec *executionContext) fieldContext_Mutation_openBug(ctx context.Context, f
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "clientMutationId":
-				return ec.fieldContext_OpenBugPayload_clientMutationId(ctx, field)
+				return ec.fieldContext_BugStatusOpenPayload_clientMutationId(ctx, field)
 			case "bug":
-				return ec.fieldContext_OpenBugPayload_bug(ctx, field)
+				return ec.fieldContext_BugStatusOpenPayload_bug(ctx, field)
 			case "operation":
-				return ec.fieldContext_OpenBugPayload_operation(ctx, field)
+				return ec.fieldContext_BugStatusOpenPayload_operation(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type OpenBugPayload", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugStatusOpenPayload", field.Name)
 		},
 	}
 	defer func() {
@@ -648,15 +648,15 @@ func (ec *executionContext) fieldContext_Mutation_openBug(ctx context.Context, f
 		}
 	}()
 	ctx = graphql.WithFieldContext(ctx, fc)
-	if fc.Args, err = ec.field_Mutation_openBug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+	if fc.Args, err = ec.field_Mutation_bugStatusOpen_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 		ec.Error(ctx, err)
 		return fc, err
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_Mutation_closeBug(ctx, field)
+func (ec *executionContext) _Mutation_bugStatusClose(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_Mutation_bugStatusClose(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -669,7 +669,7 @@ func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphq
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.Mutation().CloseBug(rctx, fc.Args["input"].(models.CloseBugInput))
+		return ec.resolvers.Mutation().BugStatusClose(rctx, fc.Args["input"].(models.BugStatusCloseInput))
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -681,12 +681,12 @@ func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphq
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*models.CloseBugPayload)
+	res := resTmp.(*models.BugStatusClosePayload)
 	fc.Result = res
-	return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
+	return ec.marshalNBugStatusClosePayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugStatusClosePayload(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_Mutation_bugStatusClose(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
 		Object:     "Mutation",
 		Field:      field,
@@ -695,13 +695,13 @@ func (ec *executionContext) fieldContext_Mutation_closeBug(ctx context.Context,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "clientMutationId":
-				return ec.fieldContext_CloseBugPayload_clientMutationId(ctx, field)
+				return ec.fieldContext_BugStatusClosePayload_clientMutationId(ctx, field)
 			case "bug":
-				return ec.fieldContext_CloseBugPayload_bug(ctx, field)
+				return ec.fieldContext_BugStatusClosePayload_bug(ctx, field)
 			case "operation":
-				return ec.fieldContext_CloseBugPayload_operation(ctx, field)
+				return ec.fieldContext_BugStatusClosePayload_operation(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type CloseBugPayload", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugStatusClosePayload", field.Name)
 		},
 	}
 	defer func() {
@@ -711,15 +711,15 @@ func (ec *executionContext) fieldContext_Mutation_closeBug(ctx context.Context,
 		}
 	}()
 	ctx = graphql.WithFieldContext(ctx, fc)
-	if fc.Args, err = ec.field_Mutation_closeBug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+	if fc.Args, err = ec.field_Mutation_bugStatusClose_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 		ec.Error(ctx, err)
 		return fc, err
 	}
 	return fc, nil
 }
 
-func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
-	fc, err := ec.fieldContext_Mutation_setTitle(ctx, field)
+func (ec *executionContext) _Mutation_bugSetTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+	fc, err := ec.fieldContext_Mutation_bugSetTitle(ctx, field)
 	if err != nil {
 		return graphql.Null
 	}
@@ -732,7 +732,7 @@ func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphq
 	}()
 	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 		ctx = rctx // use context from middleware stack in children
-		return ec.resolvers.Mutation().SetTitle(rctx, fc.Args["input"].(models.SetTitleInput))
+		return ec.resolvers.Mutation().BugSetTitle(rctx, fc.Args["input"].(models.BugSetTitleInput))
 	})
 	if err != nil {
 		ec.Error(ctx, err)
@@ -744,12 +744,12 @@ func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphq
 		}
 		return graphql.Null
 	}
-	res := resTmp.(*models.SetTitlePayload)
+	res := resTmp.(*models.BugSetTitlePayload)
 	fc.Result = res
-	return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
+	return ec.marshalNBugSetTitlePayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugSetTitlePayload(ctx, field.Selections, res)
 }
 
-func (ec *executionContext) fieldContext_Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+func (ec *executionContext) fieldContext_Mutation_bugSetTitle(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 	fc = &graphql.FieldContext{
 		Object:     "Mutation",
 		Field:      field,
@@ -758,13 +758,13 @@ func (ec *executionContext) fieldContext_Mutation_setTitle(ctx context.Context,
 		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 			switch field.Name {
 			case "clientMutationId":
-				return ec.fieldContext_SetTitlePayload_clientMutationId(ctx, field)
+				return ec.fieldContext_BugSetTitlePayload_clientMutationId(ctx, field)
 			case "bug":
-				return ec.fieldContext_SetTitlePayload_bug(ctx, field)
+				return ec.fieldContext_BugSetTitlePayload_bug(ctx, field)
 			case "operation":
-				return ec.fieldContext_SetTitlePayload_operation(ctx, field)
+				return ec.fieldContext_BugSetTitlePayload_operation(ctx, field)
 			}
-			return nil, fmt.Errorf("no field named %q was found under type SetTitlePayload", field.Name)
+			return nil, fmt.Errorf("no field named %q was found under type BugSetTitlePayload", field.Name)
 		},
 	}
 	defer func() {
@@ -774,7 +774,7 @@ func (ec *executionContext) fieldContext_Mutation_setTitle(ctx context.Context,
 		}
 	}()
 	ctx = graphql.WithFieldContext(ctx, fc)
-	if fc.Args, err = ec.field_Mutation_setTitle_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+	if fc.Args, err = ec.field_Mutation_bugSetTitle_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 		ec.Error(ctx, err)
 		return fc, err
 	}
@@ -1009,65 +1009,65 @@ func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet)
 		switch field.Name {
 		case "__typename":
 			out.Values[i] = graphql.MarshalString("Mutation")
-		case "newBug":
+		case "bugCreate":
 			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
-				return ec._Mutation_newBug(ctx, field)
+				return ec._Mutation_bugCreate(ctx, field)
 			})
 			if out.Values[i] == graphql.Null {
 				out.Invalids++
 			}
-		case "addComment":
+		case "bugAddComment":
 			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
-				return ec._Mutation_addComment(ctx, field)
+				return ec._Mutation_bugAddComment(ctx, field)
 			})
 			if out.Values[i] == graphql.Null {
 				out.Invalids++
 			}
-		case "addCommentAndClose":
+		case "bugAddCommentAndClose":
 			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
-				return ec._Mutation_addCommentAndClose(ctx, field)
+				return ec._Mutation_bugAddCommentAndClose(ctx, field)
 			})
 			if out.Values[i] == graphql.Null {
 				out.Invalids++
 			}
-		case "addCommentAndReopen":
+		case "bugAddCommentAndReopen":
 			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
-				return ec._Mutation_addCommentAndReopen(ctx, field)
+				return ec._Mutation_bugAddCommentAndReopen(ctx, field)
 			})
 			if out.Values[i] == graphql.Null {
 				out.Invalids++
 			}
-		case "editComment":
+		case "bugEditComment":
 			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
-				return ec._Mutation_editComment(ctx, field)
+				return ec._Mutation_bugEditComment(ctx, field)
 			})
 			if out.Values[i] == graphql.Null {
 				out.Invalids++
 			}
-		case "changeLabels":
+		case "bugChangeLabels":
 			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
-				return ec._Mutation_changeLabels(ctx, field)
+				return ec._Mutation_bugChangeLabels(ctx, field)
 			})
 			if out.Values[i] == graphql.Null {
 				out.Invalids++
 			}
-		case "openBug":
+		case "bugStatusOpen":
 			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
-				return ec._Mutation_openBug(ctx, field)
+				return ec._Mutation_bugStatusOpen(ctx, field)
 			})
 			if out.Values[i] == graphql.Null {
 				out.Invalids++
 			}
-		case "closeBug":
+		case "bugStatusClose":
 			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
-				return ec._Mutation_closeBug(ctx, field)
+				return ec._Mutation_bugStatusClose(ctx, field)
 			})
 			if out.Values[i] == graphql.Null {
 				out.Invalids++
 			}
-		case "setTitle":
+		case "bugSetTitle":
 			out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
-				return ec._Mutation_setTitle(ctx, field)
+				return ec._Mutation_bugSetTitle(ctx, field)
 			})
 			if out.Values[i] == graphql.Null {
 				out.Invalids++

api/graphql/graph/root_.generated.go

@@ -33,179 +33,255 @@ type Config struct {
 }
 
 type ResolverRoot interface {
-	AddCommentOperation() AddCommentOperationResolver
-	AddCommentTimelineItem() AddCommentTimelineItemResolver
 	Bug() BugResolver
+	BugAddCommentOperation() BugAddCommentOperationResolver
+	BugAddCommentTimelineItem() BugAddCommentTimelineItemResolver
+	BugComment() BugCommentResolver
+	BugCommentHistoryStep() BugCommentHistoryStepResolver
+	BugCreateOperation() BugCreateOperationResolver
+	BugCreateTimelineItem() BugCreateTimelineItemResolver
+	BugEditCommentOperation() BugEditCommentOperationResolver
+	BugLabelChangeOperation() BugLabelChangeOperationResolver
+	BugLabelChangeTimelineItem() BugLabelChangeTimelineItemResolver
+	BugSetStatusOperation() BugSetStatusOperationResolver
+	BugSetStatusTimelineItem() BugSetStatusTimelineItemResolver
+	BugSetTitleOperation() BugSetTitleOperationResolver
+	BugSetTitleTimelineItem() BugSetTitleTimelineItemResolver
 	Color() ColorResolver
-	Comment() CommentResolver
-	CommentHistoryStep() CommentHistoryStepResolver
-	CreateOperation() CreateOperationResolver
-	CreateTimelineItem() CreateTimelineItemResolver
-	EditCommentOperation() EditCommentOperationResolver
 	Identity() IdentityResolver
 	Label() LabelResolver
-	LabelChangeOperation() LabelChangeOperationResolver
-	LabelChangeTimelineItem() LabelChangeTimelineItemResolver
 	Mutation() MutationResolver
 	Query() QueryResolver
 	Repository() RepositoryResolver
-	SetStatusOperation() SetStatusOperationResolver
-	SetStatusTimelineItem() SetStatusTimelineItemResolver
-	SetTitleOperation() SetTitleOperationResolver
-	SetTitleTimelineItem() SetTitleTimelineItemResolver
 }
 
 type DirectiveRoot struct {
 }
 
 type ComplexityRoot struct {
-	AddCommentAndCloseBugPayload struct {
+	Bug struct {
+		Actors       func(childComplexity int, after *string, before *string, first *int, last *int) int
+		Author       func(childComplexity int) int
+		Comments     func(childComplexity int, after *string, before *string, first *int, last *int) int
+		CreatedAt    func(childComplexity int) int
+		HumanID      func(childComplexity int) int
+		Id           func(childComplexity int) int
+		Labels       func(childComplexity int) int
+		LastEdit     func(childComplexity int) int
+		Operations   func(childComplexity int, after *string, before *string, first *int, last *int) int
+		Participants func(childComplexity int, after *string, before *string, first *int, last *int) int
+		Status       func(childComplexity int) int
+		Timeline     func(childComplexity int, after *string, before *string, first *int, last *int) int
+		Title        func(childComplexity int) int
+	}
+
+	BugAddCommentAndClosePayload struct {
 		Bug              func(childComplexity int) int
 		ClientMutationID func(childComplexity int) int
 		CommentOperation func(childComplexity int) int
 		StatusOperation  func(childComplexity int) int
 	}
 
-	AddCommentAndReopenBugPayload struct {
+	BugAddCommentAndReopenPayload struct {
 		Bug              func(childComplexity int) int
 		ClientMutationID func(childComplexity int) int
 		CommentOperation func(childComplexity int) int
 		StatusOperation  func(childComplexity int) int
 	}
 
-	AddCommentOperation struct {
+	BugAddCommentOperation struct {
 		Author  func(childComplexity int) int
-		Date    func(childComplexity int) int
 		Files   func(childComplexity int) int
 		Id      func(childComplexity int) int
 		Message func(childComplexity int) int
+		Time    func(childComplexity int) int
 	}
 
-	AddCommentPayload struct {
+	BugAddCommentPayload struct {
 		Bug              func(childComplexity int) int
 		ClientMutationID func(childComplexity int) int
 		Operation        func(childComplexity int) int
 	}
 
-	AddCommentTimelineItem struct {
+	BugAddCommentTimelineItem struct {
 		Author         func(childComplexity int) int
+		CombinedId     func(childComplexity int) int
 		CreatedAt      func(childComplexity int) int
 		Edited         func(childComplexity int) int
 		Files          func(childComplexity int) int
 		History        func(childComplexity int) int
-		ID             func(childComplexity int) int
 		LastEdit       func(childComplexity int) int
 		Message        func(childComplexity int) int
 		MessageIsEmpty func(childComplexity int) int
 	}
 
-	Bug struct {
-		Actors       func(childComplexity int, after *string, before *string, first *int, last *int) int
-		Author       func(childComplexity int) int
-		Comments     func(childComplexity int, after *string, before *string, first *int, last *int) int
-		CreatedAt    func(childComplexity int) int
-		HumanID      func(childComplexity int) int
-		Id           func(childComplexity int) int
-		Labels       func(childComplexity int) int
-		LastEdit     func(childComplexity int) int
-		Operations   func(childComplexity int, after *string, before *string, first *int, last *int) int
-		Participants func(childComplexity int, after *string, before *string, first *int, last *int) int
-		Status       func(childComplexity int) int
-		Timeline     func(childComplexity int, after *string, before *string, first *int, last *int) int
-		Title        func(childComplexity int) int
-	}
-
-	BugConnection struct {
-		Edges      func(childComplexity int) int
-		Nodes      func(childComplexity int) int
-		PageInfo   func(childComplexity int) int
-		TotalCount func(childComplexity int) int
-	}
-
-	BugEdge struct {
-		Cursor func(childComplexity int) int
-		Node   func(childComplexity int) int
-	}
-
-	ChangeLabelPayload struct {
+	BugChangeLabelPayload struct {
 		Bug              func(childComplexity int) int
 		ClientMutationID func(childComplexity int) int
 		Operation        func(childComplexity int) int
 		Results          func(childComplexity int) int
 	}
 
-	CloseBugPayload struct {
-		Bug              func(childComplexity int) int
-		ClientMutationID func(childComplexity int) int
-		Operation        func(childComplexity int) int
-	}
-
-	Color struct {
-		B func(childComplexity int) int
-		G func(childComplexity int) int
-		R func(childComplexity int) int
-	}
-
-	Comment struct {
-		Author  func(childComplexity int) int
-		Files   func(childComplexity int) int
-		ID      func(childComplexity int) int
-		Message func(childComplexity int) int
+	BugComment struct {
+		Author     func(childComplexity int) int
+		CombinedId func(childComplexity int) int
+		Files      func(childComplexity int) int
+		Message    func(childComplexity int) int
 	}
 
-	CommentConnection struct {
+	BugCommentConnection struct {
 		Edges      func(childComplexity int) int
 		Nodes      func(childComplexity int) int
 		PageInfo   func(childComplexity int) int
 		TotalCount func(childComplexity int) int
 	}
 
-	CommentEdge struct {
+	BugCommentEdge struct {
 		Cursor func(childComplexity int) int
 		Node   func(childComplexity int) int
 	}
 
-	CommentHistoryStep struct {
+	BugCommentHistoryStep struct {
 		Date    func(childComplexity int) int
 		Message func(childComplexity int) int
 	}
 
-	CreateOperation struct {
+	BugConnection struct {
+		Edges      func(childComplexity int) int
+		Nodes      func(childComplexity int) int
+		PageInfo   func(childComplexity int) int
+		TotalCount func(childComplexity int) int
+	}
+
+	BugCreateOperation struct {
 		Author  func(childComplexity int) int
-		Date    func(childComplexity int) int
 		Files   func(childComplexity int) int
 		Id      func(childComplexity int) int
 		Message func(childComplexity int) int
+		Time    func(childComplexity int) int
 		Title   func(childComplexity int) int
 	}
 
-	CreateTimelineItem struct {
+	BugCreatePayload struct {
+		Bug              func(childComplexity int) int
+		ClientMutationID func(childComplexity int) int
+		Operation        func(childComplexity int) int
+	}
+
+	BugCreateTimelineItem struct {
 		Author         func(childComplexity int) int
+		CombinedId     func(childComplexity int) int
 		CreatedAt      func(childComplexity int) int
 		Edited         func(childComplexity int) int
 		Files          func(childComplexity int) int
 		History        func(childComplexity int) int
-		ID             func(childComplexity int) int
 		LastEdit       func(childComplexity int) int
 		Message        func(childComplexity int) int
 		MessageIsEmpty func(childComplexity int) int
 	}
 
-	EditCommentOperation struct {
+	BugEdge struct {
+		Cursor func(childComplexity int) int
+		Node   func(childComplexity int) int
+	}
+
+	BugEditCommentOperation struct {
 		Author  func(childComplexity int) int
-		Date    func(childComplexity int) int
 		Files   func(childComplexity int) int
 		Id      func(childComplexity int) int
 		Message func(childComplexity int) int
 		Target  func(childComplexity int) int
+		Time    func(childComplexity int) int
+	}
+
+	BugEditCommentPayload struct {
+		Bug              func(childComplexity int) int
+		ClientMutationID func(childComplexity int) int
+		Operation        func(childComplexity int) int
+	}
+
+	BugLabelChangeOperation struct {
+		Added   func(childComplexity int) int
+		Author  func(childComplexity int) int
+		Id      func(childComplexity int) int
+		Removed func(childComplexity int) int
+		Time    func(childComplexity int) int
+	}
+
+	BugLabelChangeTimelineItem struct {
+		Added      func(childComplexity int) int
+		Author     func(childComplexity int) int
+		CombinedId func(childComplexity int) int
+		Date       func(childComplexity int) int
+		Removed    func(childComplexity int) int
+	}
+
+	BugSetStatusOperation struct {
+		Author func(childComplexity int) int
+		Id     func(childComplexity int) int
+		Status func(childComplexity int) int
+		Time   func(childComplexity int) int
 	}
 
-	EditCommentPayload struct {
+	BugSetStatusTimelineItem struct {
+		Author     func(childComplexity int) int
+		CombinedId func(childComplexity int) int
+		Date       func(childComplexity int) int
+		Status     func(childComplexity int) int
+	}
+
+	BugSetTitleOperation struct {
+		Author func(childComplexity int) int
+		Id     func(childComplexity int) int
+		Time   func(childComplexity int) int
+		Title  func(childComplexity int) int
+		Was    func(childComplexity int) int
+	}
+
+	BugSetTitlePayload struct {
+		Bug              func(childComplexity int) int
+		ClientMutationID func(childComplexity int) int
+		Operation        func(childComplexity int) int
+	}
+
+	BugSetTitleTimelineItem struct {
+		Author     func(childComplexity int) int
+		CombinedId func(childComplexity int) int
+		Date       func(childComplexity int) int
+		Title      func(childComplexity int) int
+		Was        func(childComplexity int) int
+	}
+
+	BugStatusClosePayload struct {
+		Bug              func(childComplexity int) int
+		ClientMutationID func(childComplexity int) int
+		Operation        func(childComplexity int) int
+	}
+
+	BugStatusOpenPayload struct {
 		Bug              func(childComplexity int) int
 		ClientMutationID func(childComplexity int) int
 		Operation        func(childComplexity int) int
 	}
 
+	BugTimelineItemConnection struct {
+		Edges      func(childComplexity int) int
+		Nodes      func(childComplexity int) int
+		PageInfo   func(childComplexity int) int
+		TotalCount func(childComplexity int) int
+	}
+
+	BugTimelineItemEdge struct {
+		Cursor func(childComplexity int) int
+		Node   func(childComplexity int) int
+	}
+
+	Color struct {
+		B func(childComplexity int) int
+		G func(childComplexity int) int
+		R func(childComplexity int) int
+	}
+
 	Identity struct {
 		AvatarUrl   func(childComplexity int) int
 		DisplayName func(childComplexity int) int
@@ -234,27 +310,11 @@ type ComplexityRoot struct {
 		Name  func(childComplexity int) int
 	}
 
-	LabelChangeOperation struct {
-		Added   func(childComplexity int) int
-		Author  func(childComplexity int) int
-		Date    func(childComplexity int) int
-		Id      func(childComplexity int) int
-		Removed func(childComplexity int) int
-	}
-
 	LabelChangeResult struct {
 		Label  func(childComplexity int) int
 		Status func(childComplexity int) int
 	}
 
-	LabelChangeTimelineItem struct {
-		Added   func(childComplexity int) int
-		Author  func(childComplexity int) int
-		Date    func(childComplexity int) int
-		ID      func(childComplexity int) int
-		Removed func(childComplexity int) int
-	}
-
 	LabelConnection struct {
 		Edges      func(childComplexity int) int
 		Nodes      func(childComplexity int) int
@@ -268,27 +328,15 @@ type ComplexityRoot struct {
 	}
 
 	Mutation struct {
-		AddComment          func(childComplexity int, input models.AddCommentInput) int
-		AddCommentAndClose  func(childComplexity int, input models.AddCommentAndCloseBugInput) int
-		AddCommentAndReopen func(childComplexity int, input models.AddCommentAndReopenBugInput) int
-		ChangeLabels        func(childComplexity int, input *models.ChangeLabelInput) int
-		CloseBug            func(childComplexity int, input models.CloseBugInput) int
-		EditComment         func(childComplexity int, input models.EditCommentInput) int
-		NewBug              func(childComplexity int, input models.NewBugInput) int
-		OpenBug             func(childComplexity int, input models.OpenBugInput) int
-		SetTitle            func(childComplexity int, input models.SetTitleInput) int
-	}
-
-	NewBugPayload struct {
-		Bug              func(childComplexity int) int
-		ClientMutationID func(childComplexity int) int
-		Operation        func(childComplexity int) int
-	}
-
-	OpenBugPayload struct {
-		Bug              func(childComplexity int) int
-		ClientMutationID func(childComplexity int) int
-		Operation        func(childComplexity int) int
+		BugAddComment          func(childComplexity int, input models.BugAddCommentInput) int
+		BugAddCommentAndClose  func(childComplexity int, input models.BugAddCommentAndCloseInput) int
+		BugAddCommentAndReopen func(childComplexity int, input models.BugAddCommentAndReopenInput) int
+		BugChangeLabels        func(childComplexity int, input *models.BugChangeLabelInput) int
+		BugCreate              func(childComplexity int, input models.BugCreateInput) int
+		BugEditComment         func(childComplexity int, input models.BugEditCommentInput) int
+		BugSetTitle            func(childComplexity int, input models.BugSetTitleInput) int
+		BugStatusClose         func(childComplexity int, input models.BugStatusCloseInput) int
+		BugStatusOpen          func(childComplexity int, input models.BugStatusOpenInput) int
 	}
 
 	OperationConnection struct {
@@ -323,54 +371,6 @@ type ComplexityRoot struct {
 		UserIdentity  func(childComplexity int) int
 		ValidLabels   func(childComplexity int, after *string, before *string, first *int, last *int) int
 	}
-
-	SetStatusOperation struct {
-		Author func(childComplexity int) int
-		Date   func(childComplexity int) int
-		Id     func(childComplexity int) int
-		Status func(childComplexity int) int
-	}
-
-	SetStatusTimelineItem struct {
-		Author func(childComplexity int) int
-		Date   func(childComplexity int) int
-		ID     func(childComplexity int) int
-		Status func(childComplexity int) int
-	}
-
-	SetTitleOperation struct {
-		Author func(childComplexity int) int
-		Date   func(childComplexity int) int
-		Id     func(childComplexity int) int
-		Title  func(childComplexity int) int
-		Was    func(childComplexity int) int
-	}
-
-	SetTitlePayload struct {
-		Bug              func(childComplexity int) int
-		ClientMutationID func(childComplexity int) int
-		Operation        func(childComplexity int) int
-	}
-
-	SetTitleTimelineItem struct {
-		Author func(childComplexity int) int
-		Date   func(childComplexity int) int
-		ID     func(childComplexity int) int
-		Title  func(childComplexity int) int
-		Was    func(childComplexity int) int
-	}
-
-	TimelineItemConnection struct {
-		Edges      func(childComplexity int) int
-		Nodes      func(childComplexity int) int
-		PageInfo   func(childComplexity int) int
-		TotalCount func(childComplexity int) int
-	}
-
-	TimelineItemEdge struct {
-		Cursor func(childComplexity int) int
-		Node   func(childComplexity int) int
-	}
 }
 
 type executableSchema struct {
@@ -392,1393 +392,1393 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
 	_ = ec
 	switch typeName + "." + field {
 
-	case "AddCommentAndCloseBugPayload.bug":
-		if e.complexity.AddCommentAndCloseBugPayload.Bug == nil {
+	case "Bug.actors":
+		if e.complexity.Bug.Actors == nil {
 			break
 		}
 
-		return e.complexity.AddCommentAndCloseBugPayload.Bug(childComplexity), true
+		args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
+		}
 
-	case "AddCommentAndCloseBugPayload.clientMutationId":
-		if e.complexity.AddCommentAndCloseBugPayload.ClientMutationID == nil {
+		return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
+
+	case "Bug.author":
+		if e.complexity.Bug.Author == nil {
 			break
 		}
 
-		return e.complexity.AddCommentAndCloseBugPayload.ClientMutationID(childComplexity), true
+		return e.complexity.Bug.Author(childComplexity), true
 
-	case "AddCommentAndCloseBugPayload.commentOperation":
-		if e.complexity.AddCommentAndCloseBugPayload.CommentOperation == nil {
+	case "Bug.comments":
+		if e.complexity.Bug.Comments == nil {
 			break
 		}
 
-		return e.complexity.AddCommentAndCloseBugPayload.CommentOperation(childComplexity), true
+		args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
+		}
+
+		return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 
-	case "AddCommentAndCloseBugPayload.statusOperation":
-		if e.complexity.AddCommentAndCloseBugPayload.StatusOperation == nil {
+	case "Bug.createdAt":
+		if e.complexity.Bug.CreatedAt == nil {
 			break
 		}
 
-		return e.complexity.AddCommentAndCloseBugPayload.StatusOperation(childComplexity), true
+		return e.complexity.Bug.CreatedAt(childComplexity), true
 
-	case "AddCommentAndReopenBugPayload.bug":
-		if e.complexity.AddCommentAndReopenBugPayload.Bug == nil {
+	case "Bug.humanId":
+		if e.complexity.Bug.HumanID == nil {
 			break
 		}
 
-		return e.complexity.AddCommentAndReopenBugPayload.Bug(childComplexity), true
+		return e.complexity.Bug.HumanID(childComplexity), true
 
-	case "AddCommentAndReopenBugPayload.clientMutationId":
-		if e.complexity.AddCommentAndReopenBugPayload.ClientMutationID == nil {
+	case "Bug.id":
+		if e.complexity.Bug.Id == nil {
 			break
 		}
 
-		return e.complexity.AddCommentAndReopenBugPayload.ClientMutationID(childComplexity), true
+		return e.complexity.Bug.Id(childComplexity), true
 
-	case "AddCommentAndReopenBugPayload.commentOperation":
-		if e.complexity.AddCommentAndReopenBugPayload.CommentOperation == nil {
+	case "Bug.labels":
+		if e.complexity.Bug.Labels == nil {
 			break
 		}
 
-		return e.complexity.AddCommentAndReopenBugPayload.CommentOperation(childComplexity), true
+		return e.complexity.Bug.Labels(childComplexity), true
 
-	case "AddCommentAndReopenBugPayload.statusOperation":
-		if e.complexity.AddCommentAndReopenBugPayload.StatusOperation == nil {
+	case "Bug.lastEdit":
+		if e.complexity.Bug.LastEdit == nil {
 			break
 		}
 
-		return e.complexity.AddCommentAndReopenBugPayload.StatusOperation(childComplexity), true
+		return e.complexity.Bug.LastEdit(childComplexity), true
 
-	case "AddCommentOperation.author":
-		if e.complexity.AddCommentOperation.Author == nil {
+	case "Bug.operations":
+		if e.complexity.Bug.Operations == nil {
 			break
 		}
 
-		return e.complexity.AddCommentOperation.Author(childComplexity), true
+		args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
+		}
+
+		return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 
-	case "AddCommentOperation.date":
-		if e.complexity.AddCommentOperation.Date == nil {
+	case "Bug.participants":
+		if e.complexity.Bug.Participants == nil {
 			break
 		}
 
-		return e.complexity.AddCommentOperation.Date(childComplexity), true
+		args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
+		}
+
+		return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 
-	case "AddCommentOperation.files":
-		if e.complexity.AddCommentOperation.Files == nil {
+	case "Bug.status":
+		if e.complexity.Bug.Status == nil {
 			break
 		}
 
-		return e.complexity.AddCommentOperation.Files(childComplexity), true
+		return e.complexity.Bug.Status(childComplexity), true
 
-	case "AddCommentOperation.id":
-		if e.complexity.AddCommentOperation.Id == nil {
+	case "Bug.timeline":
+		if e.complexity.Bug.Timeline == nil {
 			break
 		}
 
-		return e.complexity.AddCommentOperation.Id(childComplexity), true
+		args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
+		}
+
+		return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 
-	case "AddCommentOperation.message":
-		if e.complexity.AddCommentOperation.Message == nil {
+	case "Bug.title":
+		if e.complexity.Bug.Title == nil {
 			break
 		}
 
-		return e.complexity.AddCommentOperation.Message(childComplexity), true
+		return e.complexity.Bug.Title(childComplexity), true
 
-	case "AddCommentPayload.bug":
-		if e.complexity.AddCommentPayload.Bug == nil {
+	case "BugAddCommentAndClosePayload.bug":
+		if e.complexity.BugAddCommentAndClosePayload.Bug == nil {
 			break
 		}
 
-		return e.complexity.AddCommentPayload.Bug(childComplexity), true
+		return e.complexity.BugAddCommentAndClosePayload.Bug(childComplexity), true
 
-	case "AddCommentPayload.clientMutationId":
-		if e.complexity.AddCommentPayload.ClientMutationID == nil {
+	case "BugAddCommentAndClosePayload.clientMutationId":
+		if e.complexity.BugAddCommentAndClosePayload.ClientMutationID == nil {
 			break
 		}
 
-		return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
+		return e.complexity.BugAddCommentAndClosePayload.ClientMutationID(childComplexity), true
 
-	case "AddCommentPayload.operation":
-		if e.complexity.AddCommentPayload.Operation == nil {
+	case "BugAddCommentAndClosePayload.commentOperation":
+		if e.complexity.BugAddCommentAndClosePayload.CommentOperation == nil {
 			break
 		}
 
-		return e.complexity.AddCommentPayload.Operation(childComplexity), true
+		return e.complexity.BugAddCommentAndClosePayload.CommentOperation(childComplexity), true
 
-	case "AddCommentTimelineItem.author":
-		if e.complexity.AddCommentTimelineItem.Author == nil {
+	case "BugAddCommentAndClosePayload.statusOperation":
+		if e.complexity.BugAddCommentAndClosePayload.StatusOperation == nil {
 			break
 		}
 
-		return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
+		return e.complexity.BugAddCommentAndClosePayload.StatusOperation(childComplexity), true
 
-	case "AddCommentTimelineItem.createdAt":
-		if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
+	case "BugAddCommentAndReopenPayload.bug":
+		if e.complexity.BugAddCommentAndReopenPayload.Bug == nil {
 			break
 		}
 
-		return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
+		return e.complexity.BugAddCommentAndReopenPayload.Bug(childComplexity), true
 
-	case "AddCommentTimelineItem.edited":
-		if e.complexity.AddCommentTimelineItem.Edited == nil {
+	case "BugAddCommentAndReopenPayload.clientMutationId":
+		if e.complexity.BugAddCommentAndReopenPayload.ClientMutationID == nil {
 			break
 		}
 
-		return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
+		return e.complexity.BugAddCommentAndReopenPayload.ClientMutationID(childComplexity), true
 
-	case "AddCommentTimelineItem.files":
-		if e.complexity.AddCommentTimelineItem.Files == nil {
+	case "BugAddCommentAndReopenPayload.commentOperation":
+		if e.complexity.BugAddCommentAndReopenPayload.CommentOperation == nil {
 			break
 		}
 
-		return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
+		return e.complexity.BugAddCommentAndReopenPayload.CommentOperation(childComplexity), true
 
-	case "AddCommentTimelineItem.history":
-		if e.complexity.AddCommentTimelineItem.History == nil {
+	case "BugAddCommentAndReopenPayload.statusOperation":
+		if e.complexity.BugAddCommentAndReopenPayload.StatusOperation == nil {
 			break
 		}
 
-		return e.complexity.AddCommentTimelineItem.History(childComplexity), true
+		return e.complexity.BugAddCommentAndReopenPayload.StatusOperation(childComplexity), true
 
-	case "AddCommentTimelineItem.id":
-		if e.complexity.AddCommentTimelineItem.ID == nil {
+	case "BugAddCommentOperation.author":
+		if e.complexity.BugAddCommentOperation.Author == nil {
 			break
 		}
 
-		return e.complexity.AddCommentTimelineItem.ID(childComplexity), true
+		return e.complexity.BugAddCommentOperation.Author(childComplexity), true
 
-	case "AddCommentTimelineItem.lastEdit":
-		if e.complexity.AddCommentTimelineItem.LastEdit == nil {
+	case "BugAddCommentOperation.files":
+		if e.complexity.BugAddCommentOperation.Files == nil {
 			break
 		}
 
-		return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
+		return e.complexity.BugAddCommentOperation.Files(childComplexity), true
 
-	case "AddCommentTimelineItem.message":
-		if e.complexity.AddCommentTimelineItem.Message == nil {
+	case "BugAddCommentOperation.id":
+		if e.complexity.BugAddCommentOperation.Id == nil {
 			break
 		}
 
-		return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
+		return e.complexity.BugAddCommentOperation.Id(childComplexity), true
 
-	case "AddCommentTimelineItem.messageIsEmpty":
-		if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
+	case "BugAddCommentOperation.message":
+		if e.complexity.BugAddCommentOperation.Message == nil {
 			break
 		}
 
-		return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
+		return e.complexity.BugAddCommentOperation.Message(childComplexity), true
 
-	case "Bug.actors":
-		if e.complexity.Bug.Actors == nil {
+	case "BugAddCommentOperation.date":
+		if e.complexity.BugAddCommentOperation.Time == nil {
 			break
 		}
 
-		args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
-		}
+		return e.complexity.BugAddCommentOperation.Time(childComplexity), true
 
-		return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
-
-	case "Bug.author":
-		if e.complexity.Bug.Author == nil {
+	case "BugAddCommentPayload.bug":
+		if e.complexity.BugAddCommentPayload.Bug == nil {
 			break
 		}
 
-		return e.complexity.Bug.Author(childComplexity), true
+		return e.complexity.BugAddCommentPayload.Bug(childComplexity), true
 
-	case "Bug.comments":
-		if e.complexity.Bug.Comments == nil {
+	case "BugAddCommentPayload.clientMutationId":
+		if e.complexity.BugAddCommentPayload.ClientMutationID == nil {
 			break
 		}
 
-		args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
-		}
-
-		return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
+		return e.complexity.BugAddCommentPayload.ClientMutationID(childComplexity), true
 
-	case "Bug.createdAt":
-		if e.complexity.Bug.CreatedAt == nil {
+	case "BugAddCommentPayload.operation":
+		if e.complexity.BugAddCommentPayload.Operation == nil {
 			break
 		}
 
-		return e.complexity.Bug.CreatedAt(childComplexity), true
+		return e.complexity.BugAddCommentPayload.Operation(childComplexity), true
 
-	case "Bug.humanId":
-		if e.complexity.Bug.HumanID == nil {
+	case "BugAddCommentTimelineItem.author":
+		if e.complexity.BugAddCommentTimelineItem.Author == nil {
 			break
 		}
 
-		return e.complexity.Bug.HumanID(childComplexity), true
+		return e.complexity.BugAddCommentTimelineItem.Author(childComplexity), true
 
-	case "Bug.id":
-		if e.complexity.Bug.Id == nil {
+	case "BugAddCommentTimelineItem.id":
+		if e.complexity.BugAddCommentTimelineItem.CombinedId == nil {
 			break
 		}
 
-		return e.complexity.Bug.Id(childComplexity), true
+		return e.complexity.BugAddCommentTimelineItem.CombinedId(childComplexity), true
 
-	case "Bug.labels":
-		if e.complexity.Bug.Labels == nil {
+	case "BugAddCommentTimelineItem.createdAt":
+		if e.complexity.BugAddCommentTimelineItem.CreatedAt == nil {
 			break
 		}
 
-		return e.complexity.Bug.Labels(childComplexity), true
+		return e.complexity.BugAddCommentTimelineItem.CreatedAt(childComplexity), true
 
-	case "Bug.lastEdit":
-		if e.complexity.Bug.LastEdit == nil {
+	case "BugAddCommentTimelineItem.edited":
+		if e.complexity.BugAddCommentTimelineItem.Edited == nil {
 			break
 		}
 
-		return e.complexity.Bug.LastEdit(childComplexity), true
+		return e.complexity.BugAddCommentTimelineItem.Edited(childComplexity), true
 
-	case "Bug.operations":
-		if e.complexity.Bug.Operations == nil {
+	case "BugAddCommentTimelineItem.files":
+		if e.complexity.BugAddCommentTimelineItem.Files == nil {
 			break
 		}
 
-		args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
-		}
-
-		return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
+		return e.complexity.BugAddCommentTimelineItem.Files(childComplexity), true
 
-	case "Bug.participants":
-		if e.complexity.Bug.Participants == nil {
+	case "BugAddCommentTimelineItem.history":
+		if e.complexity.BugAddCommentTimelineItem.History == nil {
 			break
 		}
 
-		args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
-		}
-
-		return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
+		return e.complexity.BugAddCommentTimelineItem.History(childComplexity), true
 
-	case "Bug.status":
-		if e.complexity.Bug.Status == nil {
+	case "BugAddCommentTimelineItem.lastEdit":
+		if e.complexity.BugAddCommentTimelineItem.LastEdit == nil {
 			break
 		}
 
-		return e.complexity.Bug.Status(childComplexity), true
+		return e.complexity.BugAddCommentTimelineItem.LastEdit(childComplexity), true
 
-	case "Bug.timeline":
-		if e.complexity.Bug.Timeline == nil {
+	case "BugAddCommentTimelineItem.message":
+		if e.complexity.BugAddCommentTimelineItem.Message == nil {
 			break
 		}
 
-		args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
-		}
-
-		return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
+		return e.complexity.BugAddCommentTimelineItem.Message(childComplexity), true
 
-	case "Bug.title":
-		if e.complexity.Bug.Title == nil {
+	case "BugAddCommentTimelineItem.messageIsEmpty":
+		if e.complexity.BugAddCommentTimelineItem.MessageIsEmpty == nil {
 			break
 		}
 
-		return e.complexity.Bug.Title(childComplexity), true
+		return e.complexity.BugAddCommentTimelineItem.MessageIsEmpty(childComplexity), true
 
-	case "BugConnection.edges":
-		if e.complexity.BugConnection.Edges == nil {
+	case "BugChangeLabelPayload.bug":
+		if e.complexity.BugChangeLabelPayload.Bug == nil {
 			break
 		}
 
-		return e.complexity.BugConnection.Edges(childComplexity), true
+		return e.complexity.BugChangeLabelPayload.Bug(childComplexity), true
 
-	case "BugConnection.nodes":
-		if e.complexity.BugConnection.Nodes == nil {
+	case "BugChangeLabelPayload.clientMutationId":
+		if e.complexity.BugChangeLabelPayload.ClientMutationID == nil {
 			break
 		}
 
-		return e.complexity.BugConnection.Nodes(childComplexity), true
+		return e.complexity.BugChangeLabelPayload.ClientMutationID(childComplexity), true
 
-	case "BugConnection.pageInfo":
-		if e.complexity.BugConnection.PageInfo == nil {
+	case "BugChangeLabelPayload.operation":
+		if e.complexity.BugChangeLabelPayload.Operation == nil {
 			break
 		}
 
-		return e.complexity.BugConnection.PageInfo(childComplexity), true
+		return e.complexity.BugChangeLabelPayload.Operation(childComplexity), true
 
-	case "BugConnection.totalCount":
-		if e.complexity.BugConnection.TotalCount == nil {
+	case "BugChangeLabelPayload.results":
+		if e.complexity.BugChangeLabelPayload.Results == nil {
 			break
 		}
 
-		return e.complexity.BugConnection.TotalCount(childComplexity), true
+		return e.complexity.BugChangeLabelPayload.Results(childComplexity), true
 
-	case "BugEdge.cursor":
-		if e.complexity.BugEdge.Cursor == nil {
+	case "BugComment.author":
+		if e.complexity.BugComment.Author == nil {
 			break
 		}
 
-		return e.complexity.BugEdge.Cursor(childComplexity), true
+		return e.complexity.BugComment.Author(childComplexity), true
 
-	case "BugEdge.node":
-		if e.complexity.BugEdge.Node == nil {
+	case "BugComment.id":
+		if e.complexity.BugComment.CombinedId == nil {
 			break
 		}
 
-		return e.complexity.BugEdge.Node(childComplexity), true
+		return e.complexity.BugComment.CombinedId(childComplexity), true
 
-	case "ChangeLabelPayload.bug":
-		if e.complexity.ChangeLabelPayload.Bug == nil {
+	case "BugComment.files":
+		if e.complexity.BugComment.Files == nil {
 			break
 		}
 
-		return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
+		return e.complexity.BugComment.Files(childComplexity), true
 
-	case "ChangeLabelPayload.clientMutationId":
-		if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
+	case "BugComment.message":
+		if e.complexity.BugComment.Message == nil {
 			break
 		}
 
-		return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
+		return e.complexity.BugComment.Message(childComplexity), true
 
-	case "ChangeLabelPayload.operation":
-		if e.complexity.ChangeLabelPayload.Operation == nil {
+	case "BugCommentConnection.edges":
+		if e.complexity.BugCommentConnection.Edges == nil {
 			break
 		}
 
-		return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
+		return e.complexity.BugCommentConnection.Edges(childComplexity), true
 
-	case "ChangeLabelPayload.results":
-		if e.complexity.ChangeLabelPayload.Results == nil {
+	case "BugCommentConnection.nodes":
+		if e.complexity.BugCommentConnection.Nodes == nil {
 			break
 		}
 
-		return e.complexity.ChangeLabelPayload.Results(childComplexity), true
+		return e.complexity.BugCommentConnection.Nodes(childComplexity), true
 
-	case "CloseBugPayload.bug":
-		if e.complexity.CloseBugPayload.Bug == nil {
+	case "BugCommentConnection.pageInfo":
+		if e.complexity.BugCommentConnection.PageInfo == nil {
 			break
 		}
 
-		return e.complexity.CloseBugPayload.Bug(childComplexity), true
+		return e.complexity.BugCommentConnection.PageInfo(childComplexity), true
 
-	case "CloseBugPayload.clientMutationId":
-		if e.complexity.CloseBugPayload.ClientMutationID == nil {
+	case "BugCommentConnection.totalCount":
+		if e.complexity.BugCommentConnection.TotalCount == nil {
 			break
 		}
 
-		return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
+		return e.complexity.BugCommentConnection.TotalCount(childComplexity), true
 
-	case "CloseBugPayload.operation":
-		if e.complexity.CloseBugPayload.Operation == nil {
+	case "BugCommentEdge.cursor":
+		if e.complexity.BugCommentEdge.Cursor == nil {
 			break
 		}
 
-		return e.complexity.CloseBugPayload.Operation(childComplexity), true
+		return e.complexity.BugCommentEdge.Cursor(childComplexity), true
 
-	case "Color.B":
-		if e.complexity.Color.B == nil {
+	case "BugCommentEdge.node":
+		if e.complexity.BugCommentEdge.Node == nil {
 			break
 		}
 
-		return e.complexity.Color.B(childComplexity), true
+		return e.complexity.BugCommentEdge.Node(childComplexity), true
 
-	case "Color.G":
-		if e.complexity.Color.G == nil {
+	case "BugCommentHistoryStep.date":
+		if e.complexity.BugCommentHistoryStep.Date == nil {
 			break
 		}
 
-		return e.complexity.Color.G(childComplexity), true
+		return e.complexity.BugCommentHistoryStep.Date(childComplexity), true
 
-	case "Color.R":
-		if e.complexity.Color.R == nil {
+	case "BugCommentHistoryStep.message":
+		if e.complexity.BugCommentHistoryStep.Message == nil {
 			break
 		}
 
-		return e.complexity.Color.R(childComplexity), true
+		return e.complexity.BugCommentHistoryStep.Message(childComplexity), true
 
-	case "Comment.author":
-		if e.complexity.Comment.Author == nil {
+	case "BugConnection.edges":
+		if e.complexity.BugConnection.Edges == nil {
 			break
 		}
 
-		return e.complexity.Comment.Author(childComplexity), true
+		return e.complexity.BugConnection.Edges(childComplexity), true
 
-	case "Comment.files":
-		if e.complexity.Comment.Files == nil {
+	case "BugConnection.nodes":
+		if e.complexity.BugConnection.Nodes == nil {
 			break
 		}
 
-		return e.complexity.Comment.Files(childComplexity), true
+		return e.complexity.BugConnection.Nodes(childComplexity), true
 
-	case "Comment.id":
-		if e.complexity.Comment.ID == nil {
+	case "BugConnection.pageInfo":
+		if e.complexity.BugConnection.PageInfo == nil {
 			break
 		}
 
-		return e.complexity.Comment.ID(childComplexity), true
+		return e.complexity.BugConnection.PageInfo(childComplexity), true
 
-	case "Comment.message":
-		if e.complexity.Comment.Message == nil {
+	case "BugConnection.totalCount":
+		if e.complexity.BugConnection.TotalCount == nil {
 			break
 		}
 
-		return e.complexity.Comment.Message(childComplexity), true
+		return e.complexity.BugConnection.TotalCount(childComplexity), true
 
-	case "CommentConnection.edges":
-		if e.complexity.CommentConnection.Edges == nil {
+	case "BugCreateOperation.author":
+		if e.complexity.BugCreateOperation.Author == nil {
 			break
 		}
 
-		return e.complexity.CommentConnection.Edges(childComplexity), true
+		return e.complexity.BugCreateOperation.Author(childComplexity), true
 
-	case "CommentConnection.nodes":
-		if e.complexity.CommentConnection.Nodes == nil {
+	case "BugCreateOperation.files":
+		if e.complexity.BugCreateOperation.Files == nil {
 			break
 		}
 
-		return e.complexity.CommentConnection.Nodes(childComplexity), true
+		return e.complexity.BugCreateOperation.Files(childComplexity), true
 
-	case "CommentConnection.pageInfo":
-		if e.complexity.CommentConnection.PageInfo == nil {
+	case "BugCreateOperation.id":
+		if e.complexity.BugCreateOperation.Id == nil {
 			break
 		}
 
-		return e.complexity.CommentConnection.PageInfo(childComplexity), true
+		return e.complexity.BugCreateOperation.Id(childComplexity), true
 
-	case "CommentConnection.totalCount":
-		if e.complexity.CommentConnection.TotalCount == nil {
+	case "BugCreateOperation.message":
+		if e.complexity.BugCreateOperation.Message == nil {
 			break
 		}
 
-		return e.complexity.CommentConnection.TotalCount(childComplexity), true
+		return e.complexity.BugCreateOperation.Message(childComplexity), true
 
-	case "CommentEdge.cursor":
-		if e.complexity.CommentEdge.Cursor == nil {
+	case "BugCreateOperation.date":
+		if e.complexity.BugCreateOperation.Time == nil {
 			break
 		}
 
-		return e.complexity.CommentEdge.Cursor(childComplexity), true
+		return e.complexity.BugCreateOperation.Time(childComplexity), true
 
-	case "CommentEdge.node":
-		if e.complexity.CommentEdge.Node == nil {
+	case "BugCreateOperation.title":
+		if e.complexity.BugCreateOperation.Title == nil {
 			break
 		}
 
-		return e.complexity.CommentEdge.Node(childComplexity), true
+		return e.complexity.BugCreateOperation.Title(childComplexity), true
 
-	case "CommentHistoryStep.date":
-		if e.complexity.CommentHistoryStep.Date == nil {
+	case "BugCreatePayload.bug":
+		if e.complexity.BugCreatePayload.Bug == nil {
 			break
 		}
 
-		return e.complexity.CommentHistoryStep.Date(childComplexity), true
+		return e.complexity.BugCreatePayload.Bug(childComplexity), true
 
-	case "CommentHistoryStep.message":
-		if e.complexity.CommentHistoryStep.Message == nil {
+	case "BugCreatePayload.clientMutationId":
+		if e.complexity.BugCreatePayload.ClientMutationID == nil {
 			break
 		}
 
-		return e.complexity.CommentHistoryStep.Message(childComplexity), true
+		return e.complexity.BugCreatePayload.ClientMutationID(childComplexity), true
 
-	case "CreateOperation.author":
-		if e.complexity.CreateOperation.Author == nil {
+	case "BugCreatePayload.operation":
+		if e.complexity.BugCreatePayload.Operation == nil {
 			break
 		}
 
-		return e.complexity.CreateOperation.Author(childComplexity), true
+		return e.complexity.BugCreatePayload.Operation(childComplexity), true
 
-	case "CreateOperation.date":
-		if e.complexity.CreateOperation.Date == nil {
+	case "BugCreateTimelineItem.author":
+		if e.complexity.BugCreateTimelineItem.Author == nil {
 			break
 		}
 
-		return e.complexity.CreateOperation.Date(childComplexity), true
+		return e.complexity.BugCreateTimelineItem.Author(childComplexity), true
 
-	case "CreateOperation.files":
-		if e.complexity.CreateOperation.Files == nil {
+	case "BugCreateTimelineItem.id":
+		if e.complexity.BugCreateTimelineItem.CombinedId == nil {
 			break
 		}
 
-		return e.complexity.CreateOperation.Files(childComplexity), true
+		return e.complexity.BugCreateTimelineItem.CombinedId(childComplexity), true
 
-	case "CreateOperation.id":
-		if e.complexity.CreateOperation.Id == nil {
+	case "BugCreateTimelineItem.createdAt":
+		if e.complexity.BugCreateTimelineItem.CreatedAt == nil {
 			break
 		}
 
-		return e.complexity.CreateOperation.Id(childComplexity), true
+		return e.complexity.BugCreateTimelineItem.CreatedAt(childComplexity), true
 
-	case "CreateOperation.message":
-		if e.complexity.CreateOperation.Message == nil {
+	case "BugCreateTimelineItem.edited":
+		if e.complexity.BugCreateTimelineItem.Edited == nil {
 			break
 		}
 
-		return e.complexity.CreateOperation.Message(childComplexity), true
+		return e.complexity.BugCreateTimelineItem.Edited(childComplexity), true
 
-	case "CreateOperation.title":
-		if e.complexity.CreateOperation.Title == nil {
+	case "BugCreateTimelineItem.files":
+		if e.complexity.BugCreateTimelineItem.Files == nil {
 			break
 		}
 
-		return e.complexity.CreateOperation.Title(childComplexity), true
+		return e.complexity.BugCreateTimelineItem.Files(childComplexity), true
 
-	case "CreateTimelineItem.author":
-		if e.complexity.CreateTimelineItem.Author == nil {
+	case "BugCreateTimelineItem.history":
+		if e.complexity.BugCreateTimelineItem.History == nil {
 			break
 		}
 
-		return e.complexity.CreateTimelineItem.Author(childComplexity), true
+		return e.complexity.BugCreateTimelineItem.History(childComplexity), true
 
-	case "CreateTimelineItem.createdAt":
-		if e.complexity.CreateTimelineItem.CreatedAt == nil {
+	case "BugCreateTimelineItem.lastEdit":
+		if e.complexity.BugCreateTimelineItem.LastEdit == nil {
 			break
 		}
 
-		return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
+		return e.complexity.BugCreateTimelineItem.LastEdit(childComplexity), true
 
-	case "CreateTimelineItem.edited":
-		if e.complexity.CreateTimelineItem.Edited == nil {
+	case "BugCreateTimelineItem.message":
+		if e.complexity.BugCreateTimelineItem.Message == nil {
 			break
 		}
 
-		return e.complexity.CreateTimelineItem.Edited(childComplexity), true
+		return e.complexity.BugCreateTimelineItem.Message(childComplexity), true
 
-	case "CreateTimelineItem.files":
-		if e.complexity.CreateTimelineItem.Files == nil {
+	case "BugCreateTimelineItem.messageIsEmpty":
+		if e.complexity.BugCreateTimelineItem.MessageIsEmpty == nil {
 			break
 		}
 
-		return e.complexity.CreateTimelineItem.Files(childComplexity), true
+		return e.complexity.BugCreateTimelineItem.MessageIsEmpty(childComplexity), true
 
-	case "CreateTimelineItem.history":
-		if e.complexity.CreateTimelineItem.History == nil {
+	case "BugEdge.cursor":
+		if e.complexity.BugEdge.Cursor == nil {
 			break
 		}
 
-		return e.complexity.CreateTimelineItem.History(childComplexity), true
+		return e.complexity.BugEdge.Cursor(childComplexity), true
 
-	case "CreateTimelineItem.id":
-		if e.complexity.CreateTimelineItem.ID == nil {
+	case "BugEdge.node":
+		if e.complexity.BugEdge.Node == nil {
 			break
 		}
 
-		return e.complexity.CreateTimelineItem.ID(childComplexity), true
+		return e.complexity.BugEdge.Node(childComplexity), true
 
-	case "CreateTimelineItem.lastEdit":
-		if e.complexity.CreateTimelineItem.LastEdit == nil {
+	case "BugEditCommentOperation.author":
+		if e.complexity.BugEditCommentOperation.Author == nil {
 			break
 		}
 
-		return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
+		return e.complexity.BugEditCommentOperation.Author(childComplexity), true
 
-	case "CreateTimelineItem.message":
-		if e.complexity.CreateTimelineItem.Message == nil {
+	case "BugEditCommentOperation.files":
+		if e.complexity.BugEditCommentOperation.Files == nil {
 			break
 		}
 
-		return e.complexity.CreateTimelineItem.Message(childComplexity), true
+		return e.complexity.BugEditCommentOperation.Files(childComplexity), true
 
-	case "CreateTimelineItem.messageIsEmpty":
-		if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
+	case "BugEditCommentOperation.id":
+		if e.complexity.BugEditCommentOperation.Id == nil {
 			break
 		}
 
-		return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
+		return e.complexity.BugEditCommentOperation.Id(childComplexity), true
 
-	case "EditCommentOperation.author":
-		if e.complexity.EditCommentOperation.Author == nil {
+	case "BugEditCommentOperation.message":
+		if e.complexity.BugEditCommentOperation.Message == nil {
 			break
 		}
 
-		return e.complexity.EditCommentOperation.Author(childComplexity), true
+		return e.complexity.BugEditCommentOperation.Message(childComplexity), true
 
-	case "EditCommentOperation.date":
-		if e.complexity.EditCommentOperation.Date == nil {
+	case "BugEditCommentOperation.target":
+		if e.complexity.BugEditCommentOperation.Target == nil {
 			break
 		}
 
-		return e.complexity.EditCommentOperation.Date(childComplexity), true
+		return e.complexity.BugEditCommentOperation.Target(childComplexity), true
 
-	case "EditCommentOperation.files":
-		if e.complexity.EditCommentOperation.Files == nil {
+	case "BugEditCommentOperation.date":
+		if e.complexity.BugEditCommentOperation.Time == nil {
 			break
 		}
 
-		return e.complexity.EditCommentOperation.Files(childComplexity), true
+		return e.complexity.BugEditCommentOperation.Time(childComplexity), true
 
-	case "EditCommentOperation.id":
-		if e.complexity.EditCommentOperation.Id == nil {
+	case "BugEditCommentPayload.bug":
+		if e.complexity.BugEditCommentPayload.Bug == nil {
 			break
 		}
 
-		return e.complexity.EditCommentOperation.Id(childComplexity), true
+		return e.complexity.BugEditCommentPayload.Bug(childComplexity), true
 
-	case "EditCommentOperation.message":
-		if e.complexity.EditCommentOperation.Message == nil {
+	case "BugEditCommentPayload.clientMutationId":
+		if e.complexity.BugEditCommentPayload.ClientMutationID == nil {
 			break
 		}
 
-		return e.complexity.EditCommentOperation.Message(childComplexity), true
+		return e.complexity.BugEditCommentPayload.ClientMutationID(childComplexity), true
 
-	case "EditCommentOperation.target":
-		if e.complexity.EditCommentOperation.Target == nil {
+	case "BugEditCommentPayload.operation":
+		if e.complexity.BugEditCommentPayload.Operation == nil {
 			break
 		}
 
-		return e.complexity.EditCommentOperation.Target(childComplexity), true
+		return e.complexity.BugEditCommentPayload.Operation(childComplexity), true
 
-	case "EditCommentPayload.bug":
-		if e.complexity.EditCommentPayload.Bug == nil {
+	case "BugLabelChangeOperation.added":
+		if e.complexity.BugLabelChangeOperation.Added == nil {
 			break
 		}
 
-		return e.complexity.EditCommentPayload.Bug(childComplexity), true
+		return e.complexity.BugLabelChangeOperation.Added(childComplexity), true
 
-	case "EditCommentPayload.clientMutationId":
-		if e.complexity.EditCommentPayload.ClientMutationID == nil {
+	case "BugLabelChangeOperation.author":
+		if e.complexity.BugLabelChangeOperation.Author == nil {
 			break
 		}
 
-		return e.complexity.EditCommentPayload.ClientMutationID(childComplexity), true
+		return e.complexity.BugLabelChangeOperation.Author(childComplexity), true
 
-	case "EditCommentPayload.operation":
-		if e.complexity.EditCommentPayload.Operation == nil {
+	case "BugLabelChangeOperation.id":
+		if e.complexity.BugLabelChangeOperation.Id == nil {
 			break
 		}
 
-		return e.complexity.EditCommentPayload.Operation(childComplexity), true
+		return e.complexity.BugLabelChangeOperation.Id(childComplexity), true
 
-	case "Identity.avatarUrl":
-		if e.complexity.Identity.AvatarUrl == nil {
+	case "BugLabelChangeOperation.removed":
+		if e.complexity.BugLabelChangeOperation.Removed == nil {
 			break
 		}
 
-		return e.complexity.Identity.AvatarUrl(childComplexity), true
+		return e.complexity.BugLabelChangeOperation.Removed(childComplexity), true
 
-	case "Identity.displayName":
-		if e.complexity.Identity.DisplayName == nil {
+	case "BugLabelChangeOperation.date":
+		if e.complexity.BugLabelChangeOperation.Time == nil {
 			break
 		}
 
-		return e.complexity.Identity.DisplayName(childComplexity), true
+		return e.complexity.BugLabelChangeOperation.Time(childComplexity), true
 
-	case "Identity.email":
-		if e.complexity.Identity.Email == nil {
+	case "BugLabelChangeTimelineItem.added":
+		if e.complexity.BugLabelChangeTimelineItem.Added == nil {
 			break
 		}
 
-		return e.complexity.Identity.Email(childComplexity), true
+		return e.complexity.BugLabelChangeTimelineItem.Added(childComplexity), true
 
-	case "Identity.humanId":
-		if e.complexity.Identity.HumanID == nil {
+	case "BugLabelChangeTimelineItem.author":
+		if e.complexity.BugLabelChangeTimelineItem.Author == nil {
 			break
 		}
 
-		return e.complexity.Identity.HumanID(childComplexity), true
+		return e.complexity.BugLabelChangeTimelineItem.Author(childComplexity), true
 
-	case "Identity.id":
-		if e.complexity.Identity.Id == nil {
+	case "BugLabelChangeTimelineItem.id":
+		if e.complexity.BugLabelChangeTimelineItem.CombinedId == nil {
 			break
 		}
 
-		return e.complexity.Identity.Id(childComplexity), true
+		return e.complexity.BugLabelChangeTimelineItem.CombinedId(childComplexity), true
 
-	case "Identity.isProtected":
-		if e.complexity.Identity.IsProtected == nil {
+	case "BugLabelChangeTimelineItem.date":
+		if e.complexity.BugLabelChangeTimelineItem.Date == nil {
 			break
 		}
 
-		return e.complexity.Identity.IsProtected(childComplexity), true
+		return e.complexity.BugLabelChangeTimelineItem.Date(childComplexity), true
 
-	case "Identity.login":
-		if e.complexity.Identity.Login == nil {
+	case "BugLabelChangeTimelineItem.removed":
+		if e.complexity.BugLabelChangeTimelineItem.Removed == nil {
 			break
 		}
 
-		return e.complexity.Identity.Login(childComplexity), true
+		return e.complexity.BugLabelChangeTimelineItem.Removed(childComplexity), true
 
-	case "Identity.name":
-		if e.complexity.Identity.Name == nil {
+	case "BugSetStatusOperation.author":
+		if e.complexity.BugSetStatusOperation.Author == nil {
 			break
 		}
 
-		return e.complexity.Identity.Name(childComplexity), true
+		return e.complexity.BugSetStatusOperation.Author(childComplexity), true
 
-	case "IdentityConnection.edges":
-		if e.complexity.IdentityConnection.Edges == nil {
+	case "BugSetStatusOperation.id":
+		if e.complexity.BugSetStatusOperation.Id == nil {
 			break
 		}
 
-		return e.complexity.IdentityConnection.Edges(childComplexity), true
+		return e.complexity.BugSetStatusOperation.Id(childComplexity), true
 
-	case "IdentityConnection.nodes":
-		if e.complexity.IdentityConnection.Nodes == nil {
+	case "BugSetStatusOperation.status":
+		if e.complexity.BugSetStatusOperation.Status == nil {
 			break
 		}
 
-		return e.complexity.IdentityConnection.Nodes(childComplexity), true
+		return e.complexity.BugSetStatusOperation.Status(childComplexity), true
 
-	case "IdentityConnection.pageInfo":
-		if e.complexity.IdentityConnection.PageInfo == nil {
+	case "BugSetStatusOperation.date":
+		if e.complexity.BugSetStatusOperation.Time == nil {
 			break
 		}
 
-		return e.complexity.IdentityConnection.PageInfo(childComplexity), true
+		return e.complexity.BugSetStatusOperation.Time(childComplexity), true
 
-	case "IdentityConnection.totalCount":
-		if e.complexity.IdentityConnection.TotalCount == nil {
+	case "BugSetStatusTimelineItem.author":
+		if e.complexity.BugSetStatusTimelineItem.Author == nil {
 			break
 		}
 
-		return e.complexity.IdentityConnection.TotalCount(childComplexity), true
+		return e.complexity.BugSetStatusTimelineItem.Author(childComplexity), true
 
-	case "IdentityEdge.cursor":
-		if e.complexity.IdentityEdge.Cursor == nil {
+	case "BugSetStatusTimelineItem.id":
+		if e.complexity.BugSetStatusTimelineItem.CombinedId == nil {
 			break
 		}
 
-		return e.complexity.IdentityEdge.Cursor(childComplexity), true
+		return e.complexity.BugSetStatusTimelineItem.CombinedId(childComplexity), true
 
-	case "IdentityEdge.node":
-		if e.complexity.IdentityEdge.Node == nil {
+	case "BugSetStatusTimelineItem.date":
+		if e.complexity.BugSetStatusTimelineItem.Date == nil {
 			break
 		}
 
-		return e.complexity.IdentityEdge.Node(childComplexity), true
+		return e.complexity.BugSetStatusTimelineItem.Date(childComplexity), true
 
-	case "Label.color":
-		if e.complexity.Label.Color == nil {
+	case "BugSetStatusTimelineItem.status":
+		if e.complexity.BugSetStatusTimelineItem.Status == nil {
 			break
 		}
 
-		return e.complexity.Label.Color(childComplexity), true
+		return e.complexity.BugSetStatusTimelineItem.Status(childComplexity), true
 
-	case "Label.name":
-		if e.complexity.Label.Name == nil {
+	case "BugSetTitleOperation.author":
+		if e.complexity.BugSetTitleOperation.Author == nil {
 			break
 		}
 
-		return e.complexity.Label.Name(childComplexity), true
+		return e.complexity.BugSetTitleOperation.Author(childComplexity), true
 
-	case "LabelChangeOperation.added":
-		if e.complexity.LabelChangeOperation.Added == nil {
+	case "BugSetTitleOperation.id":
+		if e.complexity.BugSetTitleOperation.Id == nil {
 			break
 		}
 
-		return e.complexity.LabelChangeOperation.Added(childComplexity), true
+		return e.complexity.BugSetTitleOperation.Id(childComplexity), true
 
-	case "LabelChangeOperation.author":
-		if e.complexity.LabelChangeOperation.Author == nil {
+	case "BugSetTitleOperation.date":
+		if e.complexity.BugSetTitleOperation.Time == nil {
 			break
 		}
 
-		return e.complexity.LabelChangeOperation.Author(childComplexity), true
+		return e.complexity.BugSetTitleOperation.Time(childComplexity), true
 
-	case "LabelChangeOperation.date":
-		if e.complexity.LabelChangeOperation.Date == nil {
+	case "BugSetTitleOperation.title":
+		if e.complexity.BugSetTitleOperation.Title == nil {
 			break
 		}
 
-		return e.complexity.LabelChangeOperation.Date(childComplexity), true
+		return e.complexity.BugSetTitleOperation.Title(childComplexity), true
 
-	case "LabelChangeOperation.id":
-		if e.complexity.LabelChangeOperation.Id == nil {
+	case "BugSetTitleOperation.was":
+		if e.complexity.BugSetTitleOperation.Was == nil {
 			break
 		}
 
-		return e.complexity.LabelChangeOperation.Id(childComplexity), true
+		return e.complexity.BugSetTitleOperation.Was(childComplexity), true
 
-	case "LabelChangeOperation.removed":
-		if e.complexity.LabelChangeOperation.Removed == nil {
+	case "BugSetTitlePayload.bug":
+		if e.complexity.BugSetTitlePayload.Bug == nil {
 			break
 		}
 
-		return e.complexity.LabelChangeOperation.Removed(childComplexity), true
+		return e.complexity.BugSetTitlePayload.Bug(childComplexity), true
 
-	case "LabelChangeResult.label":
-		if e.complexity.LabelChangeResult.Label == nil {
+	case "BugSetTitlePayload.clientMutationId":
+		if e.complexity.BugSetTitlePayload.ClientMutationID == nil {
 			break
 		}
 
-		return e.complexity.LabelChangeResult.Label(childComplexity), true
+		return e.complexity.BugSetTitlePayload.ClientMutationID(childComplexity), true
 
-	case "LabelChangeResult.status":
-		if e.complexity.LabelChangeResult.Status == nil {
+	case "BugSetTitlePayload.operation":
+		if e.complexity.BugSetTitlePayload.Operation == nil {
 			break
 		}
 
-		return e.complexity.LabelChangeResult.Status(childComplexity), true
+		return e.complexity.BugSetTitlePayload.Operation(childComplexity), true
 
-	case "LabelChangeTimelineItem.added":
-		if e.complexity.LabelChangeTimelineItem.Added == nil {
+	case "BugSetTitleTimelineItem.author":
+		if e.complexity.BugSetTitleTimelineItem.Author == nil {
 			break
 		}
 
-		return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
+		return e.complexity.BugSetTitleTimelineItem.Author(childComplexity), true
 
-	case "LabelChangeTimelineItem.author":
-		if e.complexity.LabelChangeTimelineItem.Author == nil {
+	case "BugSetTitleTimelineItem.id":
+		if e.complexity.BugSetTitleTimelineItem.CombinedId == nil {
 			break
 		}
 
-		return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
+		return e.complexity.BugSetTitleTimelineItem.CombinedId(childComplexity), true
 
-	case "LabelChangeTimelineItem.date":
-		if e.complexity.LabelChangeTimelineItem.Date == nil {
+	case "BugSetTitleTimelineItem.date":
+		if e.complexity.BugSetTitleTimelineItem.Date == nil {
 			break
 		}
 
-		return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
+		return e.complexity.BugSetTitleTimelineItem.Date(childComplexity), true
 
-	case "LabelChangeTimelineItem.id":
-		if e.complexity.LabelChangeTimelineItem.ID == nil {
+	case "BugSetTitleTimelineItem.title":
+		if e.complexity.BugSetTitleTimelineItem.Title == nil {
 			break
 		}
 
-		return e.complexity.LabelChangeTimelineItem.ID(childComplexity), true
+		return e.complexity.BugSetTitleTimelineItem.Title(childComplexity), true
 
-	case "LabelChangeTimelineItem.removed":
-		if e.complexity.LabelChangeTimelineItem.Removed == nil {
+	case "BugSetTitleTimelineItem.was":
+		if e.complexity.BugSetTitleTimelineItem.Was == nil {
 			break
 		}
 
-		return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
+		return e.complexity.BugSetTitleTimelineItem.Was(childComplexity), true
 
-	case "LabelConnection.edges":
-		if e.complexity.LabelConnection.Edges == nil {
+	case "BugStatusClosePayload.bug":
+		if e.complexity.BugStatusClosePayload.Bug == nil {
 			break
 		}
 
-		return e.complexity.LabelConnection.Edges(childComplexity), true
+		return e.complexity.BugStatusClosePayload.Bug(childComplexity), true
 
-	case "LabelConnection.nodes":
-		if e.complexity.LabelConnection.Nodes == nil {
+	case "BugStatusClosePayload.clientMutationId":
+		if e.complexity.BugStatusClosePayload.ClientMutationID == nil {
 			break
 		}
 
-		return e.complexity.LabelConnection.Nodes(childComplexity), true
+		return e.complexity.BugStatusClosePayload.ClientMutationID(childComplexity), true
 
-	case "LabelConnection.pageInfo":
-		if e.complexity.LabelConnection.PageInfo == nil {
+	case "BugStatusClosePayload.operation":
+		if e.complexity.BugStatusClosePayload.Operation == nil {
 			break
 		}
 
-		return e.complexity.LabelConnection.PageInfo(childComplexity), true
+		return e.complexity.BugStatusClosePayload.Operation(childComplexity), true
 
-	case "LabelConnection.totalCount":
-		if e.complexity.LabelConnection.TotalCount == nil {
+	case "BugStatusOpenPayload.bug":
+		if e.complexity.BugStatusOpenPayload.Bug == nil {
 			break
 		}
 
-		return e.complexity.LabelConnection.TotalCount(childComplexity), true
+		return e.complexity.BugStatusOpenPayload.Bug(childComplexity), true
 
-	case "LabelEdge.cursor":
-		if e.complexity.LabelEdge.Cursor == nil {
+	case "BugStatusOpenPayload.clientMutationId":
+		if e.complexity.BugStatusOpenPayload.ClientMutationID == nil {
 			break
 		}
 
-		return e.complexity.LabelEdge.Cursor(childComplexity), true
+		return e.complexity.BugStatusOpenPayload.ClientMutationID(childComplexity), true
 
-	case "LabelEdge.node":
-		if e.complexity.LabelEdge.Node == nil {
+	case "BugStatusOpenPayload.operation":
+		if e.complexity.BugStatusOpenPayload.Operation == nil {
 			break
 		}
 
-		return e.complexity.LabelEdge.Node(childComplexity), true
+		return e.complexity.BugStatusOpenPayload.Operation(childComplexity), true
 
-	case "Mutation.addComment":
-		if e.complexity.Mutation.AddComment == nil {
+	case "BugTimelineItemConnection.edges":
+		if e.complexity.BugTimelineItemConnection.Edges == nil {
 			break
 		}
 
-		args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
-		}
-
-		return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
+		return e.complexity.BugTimelineItemConnection.Edges(childComplexity), true
 
-	case "Mutation.addCommentAndClose":
-		if e.complexity.Mutation.AddCommentAndClose == nil {
+	case "BugTimelineItemConnection.nodes":
+		if e.complexity.BugTimelineItemConnection.Nodes == nil {
 			break
 		}
 
-		args, err := ec.field_Mutation_addCommentAndClose_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
-		}
-
-		return e.complexity.Mutation.AddCommentAndClose(childComplexity, args["input"].(models.AddCommentAndCloseBugInput)), true
+		return e.complexity.BugTimelineItemConnection.Nodes(childComplexity), true
 
-	case "Mutation.addCommentAndReopen":
-		if e.complexity.Mutation.AddCommentAndReopen == nil {
+	case "BugTimelineItemConnection.pageInfo":
+		if e.complexity.BugTimelineItemConnection.PageInfo == nil {
 			break
 		}
 
-		args, err := ec.field_Mutation_addCommentAndReopen_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
-		}
-
-		return e.complexity.Mutation.AddCommentAndReopen(childComplexity, args["input"].(models.AddCommentAndReopenBugInput)), true
+		return e.complexity.BugTimelineItemConnection.PageInfo(childComplexity), true
 
-	case "Mutation.changeLabels":
-		if e.complexity.Mutation.ChangeLabels == nil {
+	case "BugTimelineItemConnection.totalCount":
+		if e.complexity.BugTimelineItemConnection.TotalCount == nil {
 			break
 		}
 
-		args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
-		}
-
-		return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
+		return e.complexity.BugTimelineItemConnection.TotalCount(childComplexity), true
 
-	case "Mutation.closeBug":
-		if e.complexity.Mutation.CloseBug == nil {
+	case "BugTimelineItemEdge.cursor":
+		if e.complexity.BugTimelineItemEdge.Cursor == nil {
 			break
 		}
 
-		args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
-		}
-
-		return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
+		return e.complexity.BugTimelineItemEdge.Cursor(childComplexity), true
 
-	case "Mutation.editComment":
-		if e.complexity.Mutation.EditComment == nil {
+	case "BugTimelineItemEdge.node":
+		if e.complexity.BugTimelineItemEdge.Node == nil {
 			break
 		}
 
-		args, err := ec.field_Mutation_editComment_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
-		}
-
-		return e.complexity.Mutation.EditComment(childComplexity, args["input"].(models.EditCommentInput)), true
+		return e.complexity.BugTimelineItemEdge.Node(childComplexity), true
 
-	case "Mutation.newBug":
-		if e.complexity.Mutation.NewBug == nil {
+	case "Color.B":
+		if e.complexity.Color.B == nil {
 			break
 		}
 
-		args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
-		}
-
-		return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
+		return e.complexity.Color.B(childComplexity), true
 
-	case "Mutation.openBug":
-		if e.complexity.Mutation.OpenBug == nil {
+	case "Color.G":
+		if e.complexity.Color.G == nil {
 			break
 		}
 
-		args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
-		}
-
-		return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
+		return e.complexity.Color.G(childComplexity), true
 
-	case "Mutation.setTitle":
-		if e.complexity.Mutation.SetTitle == nil {
+	case "Color.R":
+		if e.complexity.Color.R == nil {
 			break
 		}
 
-		args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
+		return e.complexity.Color.R(childComplexity), true
+
+	case "Identity.avatarUrl":
+		if e.complexity.Identity.AvatarUrl == nil {
+			break
 		}
 
-		return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
+		return e.complexity.Identity.AvatarUrl(childComplexity), true
 
-	case "NewBugPayload.bug":
-		if e.complexity.NewBugPayload.Bug == nil {
+	case "Identity.displayName":
+		if e.complexity.Identity.DisplayName == nil {
 			break
 		}
 
-		return e.complexity.NewBugPayload.Bug(childComplexity), true
+		return e.complexity.Identity.DisplayName(childComplexity), true
 
-	case "NewBugPayload.clientMutationId":
-		if e.complexity.NewBugPayload.ClientMutationID == nil {
+	case "Identity.email":
+		if e.complexity.Identity.Email == nil {
 			break
 		}
 
-		return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
+		return e.complexity.Identity.Email(childComplexity), true
 
-	case "NewBugPayload.operation":
-		if e.complexity.NewBugPayload.Operation == nil {
+	case "Identity.humanId":
+		if e.complexity.Identity.HumanID == nil {
 			break
 		}
 
-		return e.complexity.NewBugPayload.Operation(childComplexity), true
+		return e.complexity.Identity.HumanID(childComplexity), true
 
-	case "OpenBugPayload.bug":
-		if e.complexity.OpenBugPayload.Bug == nil {
+	case "Identity.id":
+		if e.complexity.Identity.Id == nil {
 			break
 		}
 
-		return e.complexity.OpenBugPayload.Bug(childComplexity), true
+		return e.complexity.Identity.Id(childComplexity), true
 
-	case "OpenBugPayload.clientMutationId":
-		if e.complexity.OpenBugPayload.ClientMutationID == nil {
+	case "Identity.isProtected":
+		if e.complexity.Identity.IsProtected == nil {
 			break
 		}
 
-		return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
+		return e.complexity.Identity.IsProtected(childComplexity), true
 
-	case "OpenBugPayload.operation":
-		if e.complexity.OpenBugPayload.Operation == nil {
+	case "Identity.login":
+		if e.complexity.Identity.Login == nil {
 			break
 		}
 
-		return e.complexity.OpenBugPayload.Operation(childComplexity), true
+		return e.complexity.Identity.Login(childComplexity), true
 
-	case "OperationConnection.edges":
-		if e.complexity.OperationConnection.Edges == nil {
+	case "Identity.name":
+		if e.complexity.Identity.Name == nil {
 			break
 		}
 
-		return e.complexity.OperationConnection.Edges(childComplexity), true
+		return e.complexity.Identity.Name(childComplexity), true
 
-	case "OperationConnection.nodes":
-		if e.complexity.OperationConnection.Nodes == nil {
+	case "IdentityConnection.edges":
+		if e.complexity.IdentityConnection.Edges == nil {
 			break
 		}
 
-		return e.complexity.OperationConnection.Nodes(childComplexity), true
+		return e.complexity.IdentityConnection.Edges(childComplexity), true
 
-	case "OperationConnection.pageInfo":
-		if e.complexity.OperationConnection.PageInfo == nil {
+	case "IdentityConnection.nodes":
+		if e.complexity.IdentityConnection.Nodes == nil {
 			break
 		}
 
-		return e.complexity.OperationConnection.PageInfo(childComplexity), true
+		return e.complexity.IdentityConnection.Nodes(childComplexity), true
 
-	case "OperationConnection.totalCount":
-		if e.complexity.OperationConnection.TotalCount == nil {
+	case "IdentityConnection.pageInfo":
+		if e.complexity.IdentityConnection.PageInfo == nil {
 			break
 		}
 
-		return e.complexity.OperationConnection.TotalCount(childComplexity), true
+		return e.complexity.IdentityConnection.PageInfo(childComplexity), true
 
-	case "OperationEdge.cursor":
-		if e.complexity.OperationEdge.Cursor == nil {
+	case "IdentityConnection.totalCount":
+		if e.complexity.IdentityConnection.TotalCount == nil {
 			break
 		}
 
-		return e.complexity.OperationEdge.Cursor(childComplexity), true
+		return e.complexity.IdentityConnection.TotalCount(childComplexity), true
 
-	case "OperationEdge.node":
-		if e.complexity.OperationEdge.Node == nil {
+	case "IdentityEdge.cursor":
+		if e.complexity.IdentityEdge.Cursor == nil {
 			break
 		}
 
-		return e.complexity.OperationEdge.Node(childComplexity), true
+		return e.complexity.IdentityEdge.Cursor(childComplexity), true
 
-	case "PageInfo.endCursor":
-		if e.complexity.PageInfo.EndCursor == nil {
+	case "IdentityEdge.node":
+		if e.complexity.IdentityEdge.Node == nil {
 			break
 		}
 
-		return e.complexity.PageInfo.EndCursor(childComplexity), true
+		return e.complexity.IdentityEdge.Node(childComplexity), true
 
-	case "PageInfo.hasNextPage":
-		if e.complexity.PageInfo.HasNextPage == nil {
+	case "Label.color":
+		if e.complexity.Label.Color == nil {
 			break
 		}
 
-		return e.complexity.PageInfo.HasNextPage(childComplexity), true
+		return e.complexity.Label.Color(childComplexity), true
 
-	case "PageInfo.hasPreviousPage":
-		if e.complexity.PageInfo.HasPreviousPage == nil {
+	case "Label.name":
+		if e.complexity.Label.Name == nil {
 			break
 		}
 
-		return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
+		return e.complexity.Label.Name(childComplexity), true
 
-	case "PageInfo.startCursor":
-		if e.complexity.PageInfo.StartCursor == nil {
+	case "LabelChangeResult.label":
+		if e.complexity.LabelChangeResult.Label == nil {
 			break
 		}
 
-		return e.complexity.PageInfo.StartCursor(childComplexity), true
+		return e.complexity.LabelChangeResult.Label(childComplexity), true
 
-	case "Query.repository":
-		if e.complexity.Query.Repository == nil {
+	case "LabelChangeResult.status":
+		if e.complexity.LabelChangeResult.Status == nil {
 			break
 		}
 
-		args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
+		return e.complexity.LabelChangeResult.Status(childComplexity), true
+
+	case "LabelConnection.edges":
+		if e.complexity.LabelConnection.Edges == nil {
+			break
 		}
 
-		return e.complexity.Query.Repository(childComplexity, args["ref"].(*string)), true
+		return e.complexity.LabelConnection.Edges(childComplexity), true
 
-	case "Repository.allBugs":
-		if e.complexity.Repository.AllBugs == nil {
+	case "LabelConnection.nodes":
+		if e.complexity.LabelConnection.Nodes == nil {
 			break
 		}
 
-		args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
+		return e.complexity.LabelConnection.Nodes(childComplexity), true
+
+	case "LabelConnection.pageInfo":
+		if e.complexity.LabelConnection.PageInfo == nil {
+			break
 		}
 
-		return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
+		return e.complexity.LabelConnection.PageInfo(childComplexity), true
 
-	case "Repository.allIdentities":
-		if e.complexity.Repository.AllIdentities == nil {
+	case "LabelConnection.totalCount":
+		if e.complexity.LabelConnection.TotalCount == nil {
 			break
 		}
 
-		args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
-		if err != nil {
-			return 0, false
+		return e.complexity.LabelConnection.TotalCount(childComplexity), true
+
+	case "LabelEdge.cursor":
+		if e.complexity.LabelEdge.Cursor == nil {
+			break
 		}
 
-		return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
+		return e.complexity.LabelEdge.Cursor(childComplexity), true
 
-	case "Repository.bug":
-		if e.complexity.Repository.Bug == nil {
+	case "LabelEdge.node":
+		if e.complexity.LabelEdge.Node == nil {
 			break
 		}
 
-		args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
+		return e.complexity.LabelEdge.Node(childComplexity), true
+
+	case "Mutation.bugAddComment":
+		if e.complexity.Mutation.BugAddComment == nil {
+			break
+		}
+
+		args, err := ec.field_Mutation_bugAddComment_args(context.TODO(), rawArgs)
 		if err != nil {
 			return 0, false
 		}
 
-		return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
+		return e.complexity.Mutation.BugAddComment(childComplexity, args["input"].(models.BugAddCommentInput)), true
 
-	case "Repository.identity":
-		if e.complexity.Repository.Identity == nil {
+	case "Mutation.bugAddCommentAndClose":
+		if e.complexity.Mutation.BugAddCommentAndClose == nil {
 			break
 		}
 
-		args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
+		args, err := ec.field_Mutation_bugAddCommentAndClose_args(context.TODO(), rawArgs)
 		if err != nil {
 			return 0, false
 		}
 
-		return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
+		return e.complexity.Mutation.BugAddCommentAndClose(childComplexity, args["input"].(models.BugAddCommentAndCloseInput)), true
 
-	case "Repository.name":
-		if e.complexity.Repository.Name == nil {
+	case "Mutation.bugAddCommentAndReopen":
+		if e.complexity.Mutation.BugAddCommentAndReopen == nil {
 			break
 		}
 
-		return e.complexity.Repository.Name(childComplexity), true
-
-	case "Repository.userIdentity":
-		if e.complexity.Repository.UserIdentity == nil {
-			break
+		args, err := ec.field_Mutation_bugAddCommentAndReopen_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
 		}
 
-		return e.complexity.Repository.UserIdentity(childComplexity), true
+		return e.complexity.Mutation.BugAddCommentAndReopen(childComplexity, args["input"].(models.BugAddCommentAndReopenInput)), true
 
-	case "Repository.validLabels":
-		if e.complexity.Repository.ValidLabels == nil {
+	case "Mutation.bugChangeLabels":
+		if e.complexity.Mutation.BugChangeLabels == nil {
 			break
 		}
 
-		args, err := ec.field_Repository_validLabels_args(context.TODO(), rawArgs)
+		args, err := ec.field_Mutation_bugChangeLabels_args(context.TODO(), rawArgs)
 		if err != nil {
 			return 0, false
 		}
 
-		return e.complexity.Repository.ValidLabels(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
+		return e.complexity.Mutation.BugChangeLabels(childComplexity, args["input"].(*models.BugChangeLabelInput)), true
 
-	case "SetStatusOperation.author":
-		if e.complexity.SetStatusOperation.Author == nil {
+	case "Mutation.bugCreate":
+		if e.complexity.Mutation.BugCreate == nil {
 			break
 		}
 
-		return e.complexity.SetStatusOperation.Author(childComplexity), true
-
-	case "SetStatusOperation.date":
-		if e.complexity.SetStatusOperation.Date == nil {
-			break
+		args, err := ec.field_Mutation_bugCreate_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
 		}
 
-		return e.complexity.SetStatusOperation.Date(childComplexity), true
+		return e.complexity.Mutation.BugCreate(childComplexity, args["input"].(models.BugCreateInput)), true
 
-	case "SetStatusOperation.id":
-		if e.complexity.SetStatusOperation.Id == nil {
+	case "Mutation.bugEditComment":
+		if e.complexity.Mutation.BugEditComment == nil {
 			break
 		}
 
-		return e.complexity.SetStatusOperation.Id(childComplexity), true
-
-	case "SetStatusOperation.status":
-		if e.complexity.SetStatusOperation.Status == nil {
-			break
+		args, err := ec.field_Mutation_bugEditComment_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
 		}
 
-		return e.complexity.SetStatusOperation.Status(childComplexity), true
+		return e.complexity.Mutation.BugEditComment(childComplexity, args["input"].(models.BugEditCommentInput)), true
 
-	case "SetStatusTimelineItem.author":
-		if e.complexity.SetStatusTimelineItem.Author == nil {
+	case "Mutation.bugSetTitle":
+		if e.complexity.Mutation.BugSetTitle == nil {
 			break
 		}
 
-		return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
-
-	case "SetStatusTimelineItem.date":
-		if e.complexity.SetStatusTimelineItem.Date == nil {
-			break
+		args, err := ec.field_Mutation_bugSetTitle_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
 		}
 
-		return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
+		return e.complexity.Mutation.BugSetTitle(childComplexity, args["input"].(models.BugSetTitleInput)), true
 
-	case "SetStatusTimelineItem.id":
-		if e.complexity.SetStatusTimelineItem.ID == nil {
+	case "Mutation.bugStatusClose":
+		if e.complexity.Mutation.BugStatusClose == nil {
 			break
 		}
 
-		return e.complexity.SetStatusTimelineItem.ID(childComplexity), true
-
-	case "SetStatusTimelineItem.status":
-		if e.complexity.SetStatusTimelineItem.Status == nil {
-			break
+		args, err := ec.field_Mutation_bugStatusClose_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
 		}
 
-		return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
+		return e.complexity.Mutation.BugStatusClose(childComplexity, args["input"].(models.BugStatusCloseInput)), true
 
-	case "SetTitleOperation.author":
-		if e.complexity.SetTitleOperation.Author == nil {
+	case "Mutation.bugStatusOpen":
+		if e.complexity.Mutation.BugStatusOpen == nil {
 			break
 		}
 
-		return e.complexity.SetTitleOperation.Author(childComplexity), true
+		args, err := ec.field_Mutation_bugStatusOpen_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
+		}
+
+		return e.complexity.Mutation.BugStatusOpen(childComplexity, args["input"].(models.BugStatusOpenInput)), true
 
-	case "SetTitleOperation.date":
-		if e.complexity.SetTitleOperation.Date == nil {
+	case "OperationConnection.edges":
+		if e.complexity.OperationConnection.Edges == nil {
 			break
 		}
 
-		return e.complexity.SetTitleOperation.Date(childComplexity), true
+		return e.complexity.OperationConnection.Edges(childComplexity), true
 
-	case "SetTitleOperation.id":
-		if e.complexity.SetTitleOperation.Id == nil {
+	case "OperationConnection.nodes":
+		if e.complexity.OperationConnection.Nodes == nil {
 			break
 		}
 
-		return e.complexity.SetTitleOperation.Id(childComplexity), true
+		return e.complexity.OperationConnection.Nodes(childComplexity), true
 
-	case "SetTitleOperation.title":
-		if e.complexity.SetTitleOperation.Title == nil {
+	case "OperationConnection.pageInfo":
+		if e.complexity.OperationConnection.PageInfo == nil {
 			break
 		}
 
-		return e.complexity.SetTitleOperation.Title(childComplexity), true
+		return e.complexity.OperationConnection.PageInfo(childComplexity), true
 
-	case "SetTitleOperation.was":
-		if e.complexity.SetTitleOperation.Was == nil {
+	case "OperationConnection.totalCount":
+		if e.complexity.OperationConnection.TotalCount == nil {
 			break
 		}
 
-		return e.complexity.SetTitleOperation.Was(childComplexity), true
+		return e.complexity.OperationConnection.TotalCount(childComplexity), true
 
-	case "SetTitlePayload.bug":
-		if e.complexity.SetTitlePayload.Bug == nil {
+	case "OperationEdge.cursor":
+		if e.complexity.OperationEdge.Cursor == nil {
 			break
 		}
 
-		return e.complexity.SetTitlePayload.Bug(childComplexity), true
+		return e.complexity.OperationEdge.Cursor(childComplexity), true
 
-	case "SetTitlePayload.clientMutationId":
-		if e.complexity.SetTitlePayload.ClientMutationID == nil {
+	case "OperationEdge.node":
+		if e.complexity.OperationEdge.Node == nil {
 			break
 		}
 
-		return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
+		return e.complexity.OperationEdge.Node(childComplexity), true
 
-	case "SetTitlePayload.operation":
-		if e.complexity.SetTitlePayload.Operation == nil {
+	case "PageInfo.endCursor":
+		if e.complexity.PageInfo.EndCursor == nil {
 			break
 		}
 
-		return e.complexity.SetTitlePayload.Operation(childComplexity), true
+		return e.complexity.PageInfo.EndCursor(childComplexity), true
 
-	case "SetTitleTimelineItem.author":
-		if e.complexity.SetTitleTimelineItem.Author == nil {
+	case "PageInfo.hasNextPage":
+		if e.complexity.PageInfo.HasNextPage == nil {
 			break
 		}
 
-		return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
+		return e.complexity.PageInfo.HasNextPage(childComplexity), true
 
-	case "SetTitleTimelineItem.date":
-		if e.complexity.SetTitleTimelineItem.Date == nil {
+	case "PageInfo.hasPreviousPage":
+		if e.complexity.PageInfo.HasPreviousPage == nil {
 			break
 		}
 
-		return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
+		return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
 
-	case "SetTitleTimelineItem.id":
-		if e.complexity.SetTitleTimelineItem.ID == nil {
+	case "PageInfo.startCursor":
+		if e.complexity.PageInfo.StartCursor == nil {
 			break
 		}
 
-		return e.complexity.SetTitleTimelineItem.ID(childComplexity), true
+		return e.complexity.PageInfo.StartCursor(childComplexity), true
 
-	case "SetTitleTimelineItem.title":
-		if e.complexity.SetTitleTimelineItem.Title == nil {
+	case "Query.repository":
+		if e.complexity.Query.Repository == nil {
 			break
 		}
 
-		return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
+		args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
+		}
+
+		return e.complexity.Query.Repository(childComplexity, args["ref"].(*string)), true
 
-	case "SetTitleTimelineItem.was":
-		if e.complexity.SetTitleTimelineItem.Was == nil {
+	case "Repository.allBugs":
+		if e.complexity.Repository.AllBugs == nil {
 			break
 		}
 
-		return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
+		args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
+		}
+
+		return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
 
-	case "TimelineItemConnection.edges":
-		if e.complexity.TimelineItemConnection.Edges == nil {
+	case "Repository.allIdentities":
+		if e.complexity.Repository.AllIdentities == nil {
 			break
 		}
 
-		return e.complexity.TimelineItemConnection.Edges(childComplexity), true
+		args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
+		}
+
+		return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 
-	case "TimelineItemConnection.nodes":
-		if e.complexity.TimelineItemConnection.Nodes == nil {
+	case "Repository.bug":
+		if e.complexity.Repository.Bug == nil {
 			break
 		}
 
-		return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
+		args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
+		}
+
+		return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
 
-	case "TimelineItemConnection.pageInfo":
-		if e.complexity.TimelineItemConnection.PageInfo == nil {
+	case "Repository.identity":
+		if e.complexity.Repository.Identity == nil {
 			break
 		}
 
-		return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
+		args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
+		}
+
+		return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
 
-	case "TimelineItemConnection.totalCount":
-		if e.complexity.TimelineItemConnection.TotalCount == nil {
+	case "Repository.name":
+		if e.complexity.Repository.Name == nil {
 			break
 		}
 
-		return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
+		return e.complexity.Repository.Name(childComplexity), true
 
-	case "TimelineItemEdge.cursor":
-		if e.complexity.TimelineItemEdge.Cursor == nil {
+	case "Repository.userIdentity":
+		if e.complexity.Repository.UserIdentity == nil {
 			break
 		}
 
-		return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
+		return e.complexity.Repository.UserIdentity(childComplexity), true
 
-	case "TimelineItemEdge.node":
-		if e.complexity.TimelineItemEdge.Node == nil {
+	case "Repository.validLabels":
+		if e.complexity.Repository.ValidLabels == nil {
 			break
 		}
 
-		return e.complexity.TimelineItemEdge.Node(childComplexity), true
+		args, err := ec.field_Repository_validLabels_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
+		}
+
+		return e.complexity.Repository.ValidLabels(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 
 	}
 	return 0, false

api/graphql/graph/status.generated.go

@@ -0,0 +1,53 @@
+// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
+
+package graph
+
+import (
+	"context"
+
+	"github.com/99designs/gqlgen/graphql"
+	"github.com/git-bug/git-bug/entities/common"
+	"github.com/vektah/gqlparser/v2/ast"
+)
+
+// region    ************************** generated!.gotpl **************************
+
+// endregion ************************** generated!.gotpl **************************
+
+// region    ***************************** args.gotpl *****************************
+
+// endregion ***************************** args.gotpl *****************************
+
+// region    ************************** directives.gotpl **************************
+
+// endregion ************************** directives.gotpl **************************
+
+// region    **************************** field.gotpl *****************************
+
+// endregion **************************** field.gotpl *****************************
+
+// region    **************************** input.gotpl *****************************
+
+// endregion **************************** input.gotpl *****************************
+
+// region    ************************** interface.gotpl ***************************
+
+// endregion ************************** interface.gotpl ***************************
+
+// region    **************************** object.gotpl ****************************
+
+// endregion **************************** object.gotpl ****************************
+
+// region    ***************************** type.gotpl *****************************
+
+func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋcommonᚐStatus(ctx context.Context, v interface{}) (common.Status, error) {
+	var res common.Status
+	err := res.UnmarshalGQL(v)
+	return res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalNStatus2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋcommonᚐStatus(ctx context.Context, sel ast.SelectionSet, v common.Status) graphql.Marshaler {
+	return v
+}
+
+// endregion ***************************** type.gotpl *****************************

api/graphql/graph/types.generated.go

@@ -363,69 +363,69 @@ func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet,
 		if obj == nil {
 			return graphql.Null
 		}
-		return ec._SetStatusOperation(ctx, sel, obj)
+		return ec._BugSetStatusOperation(ctx, sel, obj)
 	case *bug.CreateOperation:
 		if obj == nil {
 			return graphql.Null
 		}
-		return ec._CreateOperation(ctx, sel, obj)
+		return ec._BugCreateOperation(ctx, sel, obj)
 	case *bug.SetTitleOperation:
 		if obj == nil {
 			return graphql.Null
 		}
-		return ec._SetTitleOperation(ctx, sel, obj)
+		return ec._BugSetTitleOperation(ctx, sel, obj)
 	case *bug.AddCommentOperation:
 		if obj == nil {
 			return graphql.Null
 		}
-		return ec._AddCommentOperation(ctx, sel, obj)
+		return ec._BugAddCommentOperation(ctx, sel, obj)
 	case *bug.EditCommentOperation:
 		if obj == nil {
 			return graphql.Null
 		}
-		return ec._EditCommentOperation(ctx, sel, obj)
+		return ec._BugEditCommentOperation(ctx, sel, obj)
 	case *bug.LabelChangeOperation:
 		if obj == nil {
 			return graphql.Null
 		}
-		return ec._LabelChangeOperation(ctx, sel, obj)
+		return ec._BugLabelChangeOperation(ctx, sel, obj)
 	case *bug.CreateTimelineItem:
 		if obj == nil {
 			return graphql.Null
 		}
-		return ec._CreateTimelineItem(ctx, sel, obj)
+		return ec._BugCreateTimelineItem(ctx, sel, obj)
 	case *bug.AddCommentTimelineItem:
 		if obj == nil {
 			return graphql.Null
 		}
-		return ec._AddCommentTimelineItem(ctx, sel, obj)
+		return ec._BugAddCommentTimelineItem(ctx, sel, obj)
 	case *bug.LabelChangeTimelineItem:
 		if obj == nil {
 			return graphql.Null
 		}
-		return ec._LabelChangeTimelineItem(ctx, sel, obj)
+		return ec._BugLabelChangeTimelineItem(ctx, sel, obj)
 	case *bug.SetStatusTimelineItem:
 		if obj == nil {
 			return graphql.Null
 		}
-		return ec._SetStatusTimelineItem(ctx, sel, obj)
+		return ec._BugSetStatusTimelineItem(ctx, sel, obj)
 	case *bug.SetTitleTimelineItem:
 		if obj == nil {
 			return graphql.Null
 		}
-		return ec._SetTitleTimelineItem(ctx, sel, obj)
-	case models.BugWrapper:
+		return ec._BugSetTitleTimelineItem(ctx, sel, obj)
+	case bug.Comment:
+		return ec._BugComment(ctx, sel, &obj)
+	case *bug.Comment:
 		if obj == nil {
 			return graphql.Null
 		}
-		return ec._Bug(ctx, sel, obj)
-	case bug.Comment:
-		return ec._Comment(ctx, sel, &obj)
-	case *bug.Comment:
+		return ec._BugComment(ctx, sel, obj)
+	case models.BugWrapper:
 		if obj == nil {
 			return graphql.Null
 		}
-		return ec._Comment(ctx, sel, obj)
+		return ec._Bug(ctx, sel, obj)
 	default:
 		panic(fmt.Errorf("unexpected type %T", obj))
 	}

api/graphql/graphql_test.go

@@ -44,7 +44,7 @@ func TestQueries(t *testing.T) {
                 email
                 avatarUrl
               }
-      
+
               createdAt
               humanId
               id
@@ -81,7 +81,7 @@ func TestQueries(t *testing.T) {
                   displayName
                 }
               }
-      
+
               comments(first: 2) {
                 pageInfo {
                   endCursor
@@ -94,7 +94,7 @@ func TestQueries(t *testing.T) {
                   message
                 }
               }
-      
+
               operations(first: 20) {
                 pageInfo {
                   endCursor
@@ -109,23 +109,23 @@ func TestQueries(t *testing.T) {
                     avatarUrl
                   }
                   date
-                  ... on CreateOperation {
+                  ... on BugCreateOperation {
                     title
                     message
                     files
                   }
-                  ... on SetTitleOperation {
+                  ... on BugSetTitleOperation {
                     title
                     was
                   }
-                  ... on AddCommentOperation {
+                  ... on BugAddCommentOperation {
                     files
                     message
                   }
-                  ... on SetStatusOperation {
+                  ... on BugSetStatusOperation {
                     status
                   }
-                  ... on LabelChangeOperation {
+                  ... on BugLabelChangeOperation {
                     added {
                       name
                       color {

api/graphql/models/edges.go

@@ -11,12 +11,12 @@ func (e BugEdge) GetCursor() string {
 }
 
 // GetCursor return the cursor entry of an edge
-func (e CommentEdge) GetCursor() string {
+func (e BugCommentEdge) GetCursor() string {
 	return e.Cursor
 }
 
 // GetCursor return the cursor entry of an edge
-func (e TimelineItemEdge) GetCursor() string {
+func (e BugTimelineItemEdge) GetCursor() string {
 	return e.Cursor
 }
 

api/graphql/models/gen_models.go

@@ -14,7 +14,7 @@ type Authored interface {
 	IsAuthored()
 }
 
-type AddCommentAndCloseBugInput struct {
+type BugAddCommentAndCloseInput struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId,omitempty"`
 	// The name of the repository. If not set, the default repository is used.
@@ -27,7 +27,7 @@ type AddCommentAndCloseBugInput struct {
 	Files []repository.Hash `json:"files,omitempty"`
 }
 
-type AddCommentAndCloseBugPayload struct {
+type BugAddCommentAndClosePayload struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId,omitempty"`
 	// The affected bug.
@@ -38,7 +38,7 @@ type AddCommentAndCloseBugPayload struct {
 	StatusOperation *bug.SetStatusOperation `json:"statusOperation"`
 }
 
-type AddCommentAndReopenBugInput struct {
+type BugAddCommentAndReopenInput struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId,omitempty"`
 	// The name of the repository. If not set, the default repository is used.
@@ -51,7 +51,7 @@ type AddCommentAndReopenBugInput struct {
 	Files []repository.Hash `json:"files,omitempty"`
 }
 
-type AddCommentAndReopenBugPayload struct {
+type BugAddCommentAndReopenPayload struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId,omitempty"`
 	// The affected bug.
@@ -62,7 +62,7 @@ type AddCommentAndReopenBugPayload struct {
 	StatusOperation *bug.SetStatusOperation `json:"statusOperation"`
 }
 
-type AddCommentInput struct {
+type BugAddCommentInput struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId,omitempty"`
 	// The name of the repository. If not set, the default repository is used.
@@ -75,7 +75,7 @@ type AddCommentInput struct {
 	Files []repository.Hash `json:"files,omitempty"`
 }
 
-type AddCommentPayload struct {
+type BugAddCommentPayload struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId,omitempty"`
 	// The affected bug.
@@ -84,6 +84,42 @@ type AddCommentPayload struct {
 	Operation *bug.AddCommentOperation `json:"operation"`
 }
 
+type BugChangeLabelInput struct {
+	// A unique identifier for the client performing the mutation.
+	ClientMutationID *string `json:"clientMutationId,omitempty"`
+	// The name of the repository. If not set, the default repository is used.
+	RepoRef *string `json:"repoRef,omitempty"`
+	// The bug ID's prefix.
+	Prefix string `json:"prefix"`
+	// The list of label to add.
+	Added []string `json:"added,omitempty"`
+	// The list of label to remove.
+	Removed []string `json:"Removed,omitempty"`
+}
+
+type BugChangeLabelPayload struct {
+	// A unique identifier for the client performing the mutation.
+	ClientMutationID *string `json:"clientMutationId,omitempty"`
+	// The affected bug.
+	Bug BugWrapper `json:"bug"`
+	// The resulting operation.
+	Operation *bug.LabelChangeOperation `json:"operation"`
+	// The effect each source label had.
+	Results []*bug.LabelChangeResult `json:"results"`
+}
+
+type BugCommentConnection struct {
+	Edges      []*BugCommentEdge `json:"edges"`
+	Nodes      []*bug.Comment    `json:"nodes"`
+	PageInfo   *PageInfo         `json:"pageInfo"`
+	TotalCount int               `json:"totalCount"`
+}
+
+type BugCommentEdge struct {
+	Cursor string       `json:"cursor"`
+	Node   *bug.Comment `json:"node"`
+}
+
 // The connection type for Bug.
 type BugConnection struct {
 	// A list of edges.
@@ -95,6 +131,28 @@ type BugConnection struct {
 	TotalCount int `json:"totalCount"`
 }
 
+type BugCreateInput struct {
+	// A unique identifier for the client performing the mutation.
+	ClientMutationID *string `json:"clientMutationId,omitempty"`
+	// The name of the repository. If not set, the default repository is used.
+	RepoRef *string `json:"repoRef,omitempty"`
+	// The title of the new bug.
+	Title string `json:"title"`
+	// The first message of the new bug.
+	Message string `json:"message"`
+	// The collection of file's hash required for the first message.
+	Files []repository.Hash `json:"files,omitempty"`
+}
+
+type BugCreatePayload struct {
+	// A unique identifier for the client performing the mutation.
+	ClientMutationID *string `json:"clientMutationId,omitempty"`
+	// The created bug.
+	Bug BugWrapper `json:"bug"`
+	// The resulting operation.
+	Operation *bug.CreateOperation `json:"operation"`
+}
+
 // An edge in a connection.
 type BugEdge struct {
 	// A cursor for use in pagination.
@@ -103,80 +161,96 @@ type BugEdge struct {
 	Node BugWrapper `json:"node"`
 }
 
-type ChangeLabelInput struct {
+type BugEditCommentInput struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId,omitempty"`
 	// The name of the repository. If not set, the default repository is used.
 	RepoRef *string `json:"repoRef,omitempty"`
-	// The bug ID's prefix.
-	Prefix string `json:"prefix"`
-	// The list of label to add.
-	Added []string `json:"added,omitempty"`
-	// The list of label to remove.
-	Removed []string `json:"Removed,omitempty"`
+	// A prefix of the CombinedId of the comment to be changed.
+	TargetPrefix string `json:"targetPrefix"`
+	// The new message to be set.
+	Message string `json:"message"`
+	// The collection of file's hash required for the first message.
+	Files []repository.Hash `json:"files,omitempty"`
 }
 
-type ChangeLabelPayload struct {
+type BugEditCommentPayload struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId,omitempty"`
 	// The affected bug.
 	Bug BugWrapper `json:"bug"`
 	// The resulting operation.
-	Operation *bug.LabelChangeOperation `json:"operation"`
-	// The effect each source label had.
-	Results []*bug.LabelChangeResult `json:"results"`
+	Operation *bug.EditCommentOperation `json:"operation"`
 }
 
-type CloseBugInput struct {
+type BugSetTitleInput struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId,omitempty"`
 	// The name of the repository. If not set, the default repository is used.
 	RepoRef *string `json:"repoRef,omitempty"`
 	// The bug ID's prefix.
 	Prefix string `json:"prefix"`
+	// The new title.
+	Title string `json:"title"`
 }
 
-type CloseBugPayload struct {
+type BugSetTitlePayload struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId,omitempty"`
 	// The affected bug.
 	Bug BugWrapper `json:"bug"`
-	// The resulting operation.
-	Operation *bug.SetStatusOperation `json:"operation"`
+	// The resulting operation
+	Operation *bug.SetTitleOperation `json:"operation"`
 }
 
-type CommentConnection struct {
-	Edges      []*CommentEdge `json:"edges"`
-	Nodes      []*bug.Comment `json:"nodes"`
-	PageInfo   *PageInfo      `json:"pageInfo"`
-	TotalCount int            `json:"totalCount"`
+type BugStatusCloseInput struct {
+	// A unique identifier for the client performing the mutation.
+	ClientMutationID *string `json:"clientMutationId,omitempty"`
+	// The name of the repository. If not set, the default repository is used.
+	RepoRef *string `json:"repoRef,omitempty"`
+	// The bug ID's prefix.
+	Prefix string `json:"prefix"`
 }
 
-type CommentEdge struct {
-	Cursor string       `json:"cursor"`
-	Node   *bug.Comment `json:"node"`
+type BugStatusClosePayload struct {
+	// A unique identifier for the client performing the mutation.
+	ClientMutationID *string `json:"clientMutationId,omitempty"`
+	// The affected bug.
+	Bug BugWrapper `json:"bug"`
+	// The resulting operation.
+	Operation *bug.SetStatusOperation `json:"operation"`
 }
 
-type EditCommentInput struct {
+type BugStatusOpenInput struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId,omitempty"`
 	// The name of the repository. If not set, the default repository is used.
 	RepoRef *string `json:"repoRef,omitempty"`
-	// A prefix of the CombinedId of the comment to be changed.
-	TargetPrefix string `json:"targetPrefix"`
-	// The new message to be set.
-	Message string `json:"message"`
-	// The collection of file's hash required for the first message.
-	Files []repository.Hash `json:"files,omitempty"`
+	// The bug ID's prefix.
+	Prefix string `json:"prefix"`
 }
 
-type EditCommentPayload struct {
+type BugStatusOpenPayload struct {
 	// A unique identifier for the client performing the mutation.
 	ClientMutationID *string `json:"clientMutationId,omitempty"`
 	// The affected bug.
 	Bug BugWrapper `json:"bug"`
 	// The resulting operation.
-	Operation *bug.EditCommentOperation `json:"operation"`
+	Operation *bug.SetStatusOperation `json:"operation"`
+}
+
+// The connection type for TimelineItem
+type BugTimelineItemConnection struct {
+	Edges      []*BugTimelineItemEdge `json:"edges"`
+	Nodes      []bug.TimelineItem     `json:"nodes"`
+	PageInfo   *PageInfo              `json:"pageInfo"`
+	TotalCount int                    `json:"totalCount"`
+}
+
+// Represent a TimelineItem
+type BugTimelineItemEdge struct {
+	Cursor string           `json:"cursor"`
+	Node   bug.TimelineItem `json:"node"`
 }
 
 type IdentityConnection struct {
@@ -206,46 +280,6 @@ type LabelEdge struct {
 type Mutation struct {
 }
 
-type NewBugInput struct {
-	// A unique identifier for the client performing the mutation.
-	ClientMutationID *string `json:"clientMutationId,omitempty"`
-	// The name of the repository. If not set, the default repository is used.
-	RepoRef *string `json:"repoRef,omitempty"`
-	// The title of the new bug.
-	Title string `json:"title"`
-	// The first message of the new bug.
-	Message string `json:"message"`
-	// The collection of file's hash required for the first message.
-	Files []repository.Hash `json:"files,omitempty"`
-}
-
-type NewBugPayload struct {
-	// A unique identifier for the client performing the mutation.
-	ClientMutationID *string `json:"clientMutationId,omitempty"`
-	// The created bug.
-	Bug BugWrapper `json:"bug"`
-	// The resulting operation.
-	Operation *bug.CreateOperation `json:"operation"`
-}
-
-type OpenBugInput struct {
-	// A unique identifier for the client performing the mutation.
-	ClientMutationID *string `json:"clientMutationId,omitempty"`
-	// The name of the repository. If not set, the default repository is used.
-	RepoRef *string `json:"repoRef,omitempty"`
-	// The bug ID's prefix.
-	Prefix string `json:"prefix"`
-}
-
-type OpenBugPayload struct {
-	// A unique identifier for the client performing the mutation.
-	ClientMutationID *string `json:"clientMutationId,omitempty"`
-	// The affected bug.
-	Bug BugWrapper `json:"bug"`
-	// The resulting operation.
-	Operation *bug.SetStatusOperation `json:"operation"`
-}
-
 // The connection type for an Operation
 type OperationConnection struct {
 	Edges      []*OperationEdge `json:"edges"`
@@ -274,37 +308,3 @@ type PageInfo struct {
 
 type Query struct {
 }
-
-type SetTitleInput struct {
-	// A unique identifier for the client performing the mutation.
-	ClientMutationID *string `json:"clientMutationId,omitempty"`
-	// The name of the repository. If not set, the default repository is used.
-	RepoRef *string `json:"repoRef,omitempty"`
-	// The bug ID's prefix.
-	Prefix string `json:"prefix"`
-	// The new title.
-	Title string `json:"title"`
-}
-
-type SetTitlePayload struct {
-	// A unique identifier for the client performing the mutation.
-	ClientMutationID *string `json:"clientMutationId,omitempty"`
-	// The affected bug.
-	Bug BugWrapper `json:"bug"`
-	// The resulting operation
-	Operation *bug.SetTitleOperation `json:"operation"`
-}
-
-// The connection type for TimelineItem
-type TimelineItemConnection struct {
-	Edges      []*TimelineItemEdge `json:"edges"`
-	Nodes      []bug.TimelineItem  `json:"nodes"`
-	PageInfo   *PageInfo           `json:"pageInfo"`
-	TotalCount int                 `json:"totalCount"`
-}
-
-// Represent a TimelineItem
-type TimelineItemEdge struct {
-	Cursor string           `json:"cursor"`
-	Node   bug.TimelineItem `json:"node"`
-}

api/graphql/models/models.go

@@ -16,8 +16,3 @@ type Repository struct {
 	Cache *cache.MultiRepoCache
 	Repo  *cache.RepoCache
 }
-
-type RepositoryMutation struct {
-	Cache *cache.MultiRepoCache
-	Repo  *cache.RepoCache
-}

api/graphql/resolvers/bug.go

@@ -18,7 +18,7 @@ func (bugResolver) HumanID(_ context.Context, obj models.BugWrapper) (string, er
 	return obj.Id().Human(), nil
 }
 
-func (bugResolver) Comments(_ context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.CommentConnection, error) {
+func (bugResolver) Comments(_ context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.BugCommentConnection, error) {
 	input := models.ConnectionInput{
 		Before: before,
 		After:  after,
@@ -27,18 +27,18 @@ func (bugResolver) Comments(_ context.Context, obj models.BugWrapper, after *str
 	}
 
 	edger := func(comment bug.Comment, offset int) connections.Edge {
-		return models.CommentEdge{
+		return models.BugCommentEdge{
 			Node:   &comment,
 			Cursor: connections.OffsetToCursor(offset),
 		}
 	}
 
-	conMaker := func(edges []*models.CommentEdge, nodes []bug.Comment, info *models.PageInfo, totalCount int) (*models.CommentConnection, error) {
+	conMaker := func(edges []*models.BugCommentEdge, nodes []bug.Comment, info *models.PageInfo, totalCount int) (*models.BugCommentConnection, error) {
 		var commentNodes []*bug.Comment
 		for _, c := range nodes {
 			commentNodes = append(commentNodes, &c)
 		}
-		return &models.CommentConnection{
+		return &models.BugCommentConnection{
 			Edges:      edges,
 			Nodes:      commentNodes,
 			PageInfo:   info,
@@ -86,7 +86,7 @@ func (bugResolver) Operations(_ context.Context, obj models.BugWrapper, after *s
 	return connections.Connection(ops, edger, conMaker, input)
 }
 
-func (bugResolver) Timeline(_ context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error) {
+func (bugResolver) Timeline(_ context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.BugTimelineItemConnection, error) {
 	input := models.ConnectionInput{
 		Before: before,
 		After:  after,
@@ -95,14 +95,14 @@ func (bugResolver) Timeline(_ context.Context, obj models.BugWrapper, after *str
 	}
 
 	edger := func(op bug.TimelineItem, offset int) connections.Edge {
-		return models.TimelineItemEdge{
+		return models.BugTimelineItemEdge{
 			Node:   op,
 			Cursor: connections.OffsetToCursor(offset),
 		}
 	}
 
-	conMaker := func(edges []*models.TimelineItemEdge, nodes []bug.TimelineItem, info *models.PageInfo, totalCount int) (*models.TimelineItemConnection, error) {
-		return &models.TimelineItemConnection{
+	conMaker := func(edges []*models.BugTimelineItemEdge, nodes []bug.TimelineItem, info *models.PageInfo, totalCount int) (*models.BugTimelineItemConnection, error) {
+		return &models.BugTimelineItemConnection{
 			Edges:      edges,
 			Nodes:      nodes,
 			PageInfo:   info,
@@ -181,3 +181,11 @@ func (bugResolver) Participants(_ context.Context, obj models.BugWrapper, after
 
 	return connections.Connection(participants, edger, conMaker, input)
 }
+
+var _ graph.BugCommentResolver = &commentResolver{}
+
+type commentResolver struct{}
+
+func (c commentResolver) Author(_ context.Context, obj *bug.Comment) (models.IdentityWrapper, error) {
+	return models.NewLoadedIdentity(obj.Author), nil
+}

api/graphql/resolvers/bug_operations.go

@@ -0,0 +1,61 @@
+package resolvers
+
+import (
+	"context"
+
+	"github.com/git-bug/git-bug/api/graphql/graph"
+	"github.com/git-bug/git-bug/api/graphql/models"
+	"github.com/git-bug/git-bug/entities/bug"
+)
+
+var _ graph.BugCreateOperationResolver = bugCreateOperationResolver{}
+
+type bugCreateOperationResolver struct{}
+
+func (bugCreateOperationResolver) Author(_ context.Context, obj *bug.CreateOperation) (models.IdentityWrapper, error) {
+	return models.NewLoadedIdentity(obj.Author()), nil
+}
+
+var _ graph.BugAddCommentOperationResolver = bugAddCommentOperationResolver{}
+
+type bugAddCommentOperationResolver struct{}
+
+func (bugAddCommentOperationResolver) Author(_ context.Context, obj *bug.AddCommentOperation) (models.IdentityWrapper, error) {
+	return models.NewLoadedIdentity(obj.Author()), nil
+}
+
+var _ graph.BugEditCommentOperationResolver = bugEditCommentOperationResolver{}
+
+type bugEditCommentOperationResolver struct{}
+
+func (bugEditCommentOperationResolver) Target(_ context.Context, obj *bug.EditCommentOperation) (string, error) {
+	return obj.Target.String(), nil
+}
+
+func (bugEditCommentOperationResolver) Author(_ context.Context, obj *bug.EditCommentOperation) (models.IdentityWrapper, error) {
+	return models.NewLoadedIdentity(obj.Author()), nil
+}
+
+var _ graph.BugLabelChangeOperationResolver = bugLabelChangeOperationResolver{}
+
+type bugLabelChangeOperationResolver struct{}
+
+func (bugLabelChangeOperationResolver) Author(_ context.Context, obj *bug.LabelChangeOperation) (models.IdentityWrapper, error) {
+	return models.NewLoadedIdentity(obj.Author()), nil
+}
+
+var _ graph.BugSetStatusOperationResolver = bugSetStatusOperationResolver{}
+
+type bugSetStatusOperationResolver struct{}
+
+func (bugSetStatusOperationResolver) Author(_ context.Context, obj *bug.SetStatusOperation) (models.IdentityWrapper, error) {
+	return models.NewLoadedIdentity(obj.Author()), nil
+}
+
+var _ graph.BugSetTitleOperationResolver = bugSetTitleOperationResolver{}
+
+type bugSetTitleOperationResolver struct{}
+
+func (bugSetTitleOperationResolver) Author(_ context.Context, obj *bug.SetTitleOperation) (models.IdentityWrapper, error) {
+	return models.NewLoadedIdentity(obj.Author()), nil
+}

api/graphql/resolvers/bug_root.go

@@ -0,0 +1,59 @@
+package resolvers
+
+import (
+	"github.com/git-bug/git-bug/api/graphql/graph"
+)
+
+type bugRootSubResolver struct{}
+
+func (bugRootSubResolver) BugAddCommentOperation() graph.BugAddCommentOperationResolver {
+	return &bugAddCommentOperationResolver{}
+}
+
+func (bugRootSubResolver) BugAddCommentTimelineItem() graph.BugAddCommentTimelineItemResolver {
+	return &bugAddCommentTimelineItemResolver{}
+}
+
+func (r bugRootSubResolver) BugComment() graph.BugCommentResolver {
+	return &commentResolver{}
+}
+
+func (bugRootSubResolver) BugCommentHistoryStep() graph.BugCommentHistoryStepResolver {
+	return &bugCommentHistoryStepResolver{}
+}
+
+func (bugRootSubResolver) BugCreateOperation() graph.BugCreateOperationResolver {
+	return &bugCreateOperationResolver{}
+}
+
+func (bugRootSubResolver) BugCreateTimelineItem() graph.BugCreateTimelineItemResolver {
+	return &bugCreateTimelineItemResolver{}
+}
+
+func (r bugRootSubResolver) BugEditCommentOperation() graph.BugEditCommentOperationResolver {
+	return &bugEditCommentOperationResolver{}
+}
+
+func (bugRootSubResolver) BugLabelChangeOperation() graph.BugLabelChangeOperationResolver {
+	return &bugLabelChangeOperationResolver{}
+}
+
+func (r bugRootSubResolver) BugLabelChangeTimelineItem() graph.BugLabelChangeTimelineItemResolver {
+	return &bugLabelChangeTimelineItem{}
+}
+
+func (bugRootSubResolver) BugSetStatusOperation() graph.BugSetStatusOperationResolver {
+	return &bugSetStatusOperationResolver{}
+}
+
+func (r bugRootSubResolver) BugSetStatusTimelineItem() graph.BugSetStatusTimelineItemResolver {
+	return &bugSetStatusTimelineItem{}
+}
+
+func (r bugRootSubResolver) BugSetTitleOperation() graph.BugSetTitleOperationResolver {
+	return &bugSetTitleOperationResolver{}
+}
+
+func (r bugRootSubResolver) BugSetTitleTimelineItem() graph.BugSetTitleTimelineItemResolver {
+	return &bugSetTitleTimelineItem{}
+}

api/graphql/resolvers/bug_timeline.go

@@ -0,0 +1,94 @@
+package resolvers
+
+import (
+	"context"
+	"time"
+
+	"github.com/git-bug/git-bug/api/graphql/graph"
+	"github.com/git-bug/git-bug/api/graphql/models"
+	"github.com/git-bug/git-bug/entities/bug"
+)
+
+var _ graph.BugCommentHistoryStepResolver = bugCommentHistoryStepResolver{}
+
+type bugCommentHistoryStepResolver struct{}
+
+func (bugCommentHistoryStepResolver) Date(_ context.Context, obj *bug.CommentHistoryStep) (*time.Time, error) {
+	t := obj.UnixTime.Time()
+	return &t, nil
+}
+
+var _ graph.BugAddCommentTimelineItemResolver = bugAddCommentTimelineItemResolver{}
+
+type bugAddCommentTimelineItemResolver struct{}
+
+func (bugAddCommentTimelineItemResolver) Author(_ context.Context, obj *bug.AddCommentTimelineItem) (models.IdentityWrapper, error) {
+	return models.NewLoadedIdentity(obj.Author), nil
+}
+
+func (bugAddCommentTimelineItemResolver) CreatedAt(_ context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error) {
+	t := obj.CreatedAt.Time()
+	return &t, nil
+}
+
+func (bugAddCommentTimelineItemResolver) LastEdit(_ context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error) {
+	t := obj.LastEdit.Time()
+	return &t, nil
+}
+
+var _ graph.BugCreateTimelineItemResolver = bugCreateTimelineItemResolver{}
+
+type bugCreateTimelineItemResolver struct{}
+
+func (r bugCreateTimelineItemResolver) Author(_ context.Context, obj *bug.CreateTimelineItem) (models.IdentityWrapper, error) {
+	return models.NewLoadedIdentity(obj.Author), nil
+}
+
+func (bugCreateTimelineItemResolver) CreatedAt(_ context.Context, obj *bug.CreateTimelineItem) (*time.Time, error) {
+	t := obj.CreatedAt.Time()
+	return &t, nil
+}
+
+func (bugCreateTimelineItemResolver) LastEdit(_ context.Context, obj *bug.CreateTimelineItem) (*time.Time, error) {
+	t := obj.LastEdit.Time()
+	return &t, nil
+}
+
+var _ graph.BugLabelChangeTimelineItemResolver = bugLabelChangeTimelineItem{}
+
+type bugLabelChangeTimelineItem struct{}
+
+func (i bugLabelChangeTimelineItem) Author(_ context.Context, obj *bug.LabelChangeTimelineItem) (models.IdentityWrapper, error) {
+	return models.NewLoadedIdentity(obj.Author), nil
+}
+
+func (bugLabelChangeTimelineItem) Date(_ context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error) {
+	t := obj.UnixTime.Time()
+	return &t, nil
+}
+
+var _ graph.BugSetStatusTimelineItemResolver = bugSetStatusTimelineItem{}
+
+type bugSetStatusTimelineItem struct{}
+
+func (i bugSetStatusTimelineItem) Author(_ context.Context, obj *bug.SetStatusTimelineItem) (models.IdentityWrapper, error) {
+	return models.NewLoadedIdentity(obj.Author), nil
+}
+
+func (bugSetStatusTimelineItem) Date(_ context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error) {
+	t := obj.UnixTime.Time()
+	return &t, nil
+}
+
+var _ graph.BugSetTitleTimelineItemResolver = bugSetTitleTimelineItem{}
+
+type bugSetTitleTimelineItem struct{}
+
+func (i bugSetTitleTimelineItem) Author(_ context.Context, obj *bug.SetTitleTimelineItem) (models.IdentityWrapper, error) {
+	return models.NewLoadedIdentity(obj.Author), nil
+}
+
+func (bugSetTitleTimelineItem) Date(_ context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error) {
+	t := obj.UnixTime.Time()
+	return &t, nil
+}

api/graphql/resolvers/comment.go

@@ -1,22 +0,0 @@
-package resolvers
-
-import (
-	"context"
-
-	"github.com/git-bug/git-bug/api/graphql/graph"
-	"github.com/git-bug/git-bug/api/graphql/models"
-	"github.com/git-bug/git-bug/entities/bug"
-	"github.com/git-bug/git-bug/entity"
-)
-
-var _ graph.CommentResolver = &commentResolver{}
-
-type commentResolver struct{}
-
-func (c commentResolver) ID(ctx context.Context, obj *bug.Comment) (entity.CombinedId, error) {
-	return obj.CombinedId(), nil
-}
-
-func (c commentResolver) Author(_ context.Context, obj *bug.Comment) (models.IdentityWrapper, error) {
-	return models.NewLoadedIdentity(obj.Author), nil
-}

api/graphql/resolvers/identity.go

@@ -11,10 +11,6 @@ var _ graph.IdentityResolver = &identityResolver{}
 
 type identityResolver struct{}
 
-func (identityResolver) ID(ctx context.Context, obj models.IdentityWrapper) (string, error) {
-	return obj.Id().String(), nil
-}
-
 func (r identityResolver) HumanID(ctx context.Context, obj models.IdentityWrapper) (string, error) {
 	return obj.Id().Human(), nil
 

api/graphql/resolvers/mutation.go

@@ -39,7 +39,7 @@ func (r mutationResolver) getBug(repoRef *string, bugPrefix string) (*cache.Repo
 	return repo, b, nil
 }
 
-func (r mutationResolver) NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error) {
+func (r mutationResolver) BugCreate(ctx context.Context, input models.BugCreateInput) (*models.BugCreatePayload, error) {
 	repo, err := r.getRepo(input.RepoRef)
 	if err != nil {
 		return nil, err
@@ -60,14 +60,14 @@ func (r mutationResolver) NewBug(ctx context.Context, input models.NewBugInput)
 		return nil, err
 	}
 
-	return &models.NewBugPayload{
+	return &models.BugCreatePayload{
 		ClientMutationID: input.ClientMutationID,
 		Bug:              models.NewLoadedBug(b.Snapshot()),
 		Operation:        op,
 	}, nil
 }
 
-func (r mutationResolver) AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error) {
+func (r mutationResolver) BugAddComment(ctx context.Context, input models.BugAddCommentInput) (*models.BugAddCommentPayload, error) {
 	repo, b, err := r.getBug(input.RepoRef, input.Prefix)
 	if err != nil {
 		return nil, err
@@ -92,14 +92,14 @@ func (r mutationResolver) AddComment(ctx context.Context, input models.AddCommen
 		return nil, err
 	}
 
-	return &models.AddCommentPayload{
+	return &models.BugAddCommentPayload{
 		ClientMutationID: input.ClientMutationID,
 		Bug:              models.NewLoadedBug(b.Snapshot()),
 		Operation:        op,
 	}, nil
 }
 
-func (r mutationResolver) AddCommentAndClose(ctx context.Context, input models.AddCommentAndCloseBugInput) (*models.AddCommentAndCloseBugPayload, error) {
+func (r mutationResolver) BugAddCommentAndClose(ctx context.Context, input models.BugAddCommentAndCloseInput) (*models.BugAddCommentAndClosePayload, error) {
 	repo, b, err := r.getBug(input.RepoRef, input.Prefix)
 	if err != nil {
 		return nil, err
@@ -129,7 +129,7 @@ func (r mutationResolver) AddCommentAndClose(ctx context.Context, input models.A
 		return nil, err
 	}
 
-	return &models.AddCommentAndCloseBugPayload{
+	return &models.BugAddCommentAndClosePayload{
 		ClientMutationID: input.ClientMutationID,
 		Bug:              models.NewLoadedBug(b.Snapshot()),
 		CommentOperation: opAddComment,
@@ -137,7 +137,7 @@ func (r mutationResolver) AddCommentAndClose(ctx context.Context, input models.A
 	}, nil
 }
 
-func (r mutationResolver) AddCommentAndReopen(ctx context.Context, input models.AddCommentAndReopenBugInput) (*models.AddCommentAndReopenBugPayload, error) {
+func (r mutationResolver) BugAddCommentAndReopen(ctx context.Context, input models.BugAddCommentAndReopenInput) (*models.BugAddCommentAndReopenPayload, error) {
 	repo, b, err := r.getBug(input.RepoRef, input.Prefix)
 	if err != nil {
 		return nil, err
@@ -167,7 +167,7 @@ func (r mutationResolver) AddCommentAndReopen(ctx context.Context, input models.
 		return nil, err
 	}
 
-	return &models.AddCommentAndReopenBugPayload{
+	return &models.BugAddCommentAndReopenPayload{
 		ClientMutationID: input.ClientMutationID,
 		Bug:              models.NewLoadedBug(b.Snapshot()),
 		CommentOperation: opAddComment,
@@ -175,7 +175,7 @@ func (r mutationResolver) AddCommentAndReopen(ctx context.Context, input models.
 	}, nil
 }
 
-func (r mutationResolver) EditComment(ctx context.Context, input models.EditCommentInput) (*models.EditCommentPayload, error) {
+func (r mutationResolver) BugEditComment(ctx context.Context, input models.BugEditCommentInput) (*models.BugEditCommentPayload, error) {
 	repo, err := r.getRepo(input.RepoRef)
 	if err != nil {
 		return nil, err
@@ -207,14 +207,14 @@ func (r mutationResolver) EditComment(ctx context.Context, input models.EditComm
 		return nil, err
 	}
 
-	return &models.EditCommentPayload{
+	return &models.BugEditCommentPayload{
 		ClientMutationID: input.ClientMutationID,
 		Bug:              models.NewLoadedBug(b.Snapshot()),
 		Operation:        op,
 	}, nil
 }
 
-func (r mutationResolver) ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error) {
+func (r mutationResolver) BugChangeLabels(ctx context.Context, input *models.BugChangeLabelInput) (*models.BugChangeLabelPayload, error) {
 	repo, b, err := r.getBug(input.RepoRef, input.Prefix)
 	if err != nil {
 		return nil, err
@@ -246,7 +246,7 @@ func (r mutationResolver) ChangeLabels(ctx context.Context, input *models.Change
 		resultsPtr[i] = &result
 	}
 
-	return &models.ChangeLabelPayload{
+	return &models.BugChangeLabelPayload{
 		ClientMutationID: input.ClientMutationID,
 		Bug:              models.NewLoadedBug(b.Snapshot()),
 		Operation:        op,
@@ -254,7 +254,7 @@ func (r mutationResolver) ChangeLabels(ctx context.Context, input *models.Change
 	}, nil
 }
 
-func (r mutationResolver) OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error) {
+func (r mutationResolver) BugStatusOpen(ctx context.Context, input models.BugStatusOpenInput) (*models.BugStatusOpenPayload, error) {
 	repo, b, err := r.getBug(input.RepoRef, input.Prefix)
 	if err != nil {
 		return nil, err
@@ -275,14 +275,14 @@ func (r mutationResolver) OpenBug(ctx context.Context, input models.OpenBugInput
 		return nil, err
 	}
 
-	return &models.OpenBugPayload{
+	return &models.BugStatusOpenPayload{
 		ClientMutationID: input.ClientMutationID,
 		Bug:              models.NewLoadedBug(b.Snapshot()),
 		Operation:        op,
 	}, nil
 }
 
-func (r mutationResolver) CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error) {
+func (r mutationResolver) BugStatusClose(ctx context.Context, input models.BugStatusCloseInput) (*models.BugStatusClosePayload, error) {
 	repo, b, err := r.getBug(input.RepoRef, input.Prefix)
 	if err != nil {
 		return nil, err
@@ -303,14 +303,14 @@ func (r mutationResolver) CloseBug(ctx context.Context, input models.CloseBugInp
 		return nil, err
 	}
 
-	return &models.CloseBugPayload{
+	return &models.BugStatusClosePayload{
 		ClientMutationID: input.ClientMutationID,
 		Bug:              models.NewLoadedBug(b.Snapshot()),
 		Operation:        op,
 	}, nil
 }
 
-func (r mutationResolver) SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error) {
+func (r mutationResolver) BugSetTitle(ctx context.Context, input models.BugSetTitleInput) (*models.BugSetTitlePayload, error) {
 	repo, b, err := r.getBug(input.RepoRef, input.Prefix)
 	if err != nil {
 		return nil, err
@@ -336,7 +336,7 @@ func (r mutationResolver) SetTitle(ctx context.Context, input models.SetTitleInp
 		return nil, err
 	}
 
-	return &models.SetTitlePayload{
+	return &models.BugSetTitlePayload{
 		ClientMutationID: input.ClientMutationID,
 		Bug:              models.NewLoadedBug(b.Snapshot()),
 		Operation:        op,

api/graphql/resolvers/operations.go

@@ -1,92 +0,0 @@
-package resolvers
-
-import (
-	"context"
-	"time"
-
-	"github.com/git-bug/git-bug/api/graphql/graph"
-	"github.com/git-bug/git-bug/api/graphql/models"
-	"github.com/git-bug/git-bug/entities/bug"
-)
-
-var _ graph.CreateOperationResolver = createOperationResolver{}
-
-type createOperationResolver struct{}
-
-func (createOperationResolver) Author(_ context.Context, obj *bug.CreateOperation) (models.IdentityWrapper, error) {
-	return models.NewLoadedIdentity(obj.Author()), nil
-}
-
-func (createOperationResolver) Date(_ context.Context, obj *bug.CreateOperation) (*time.Time, error) {
-	t := obj.Time()
-	return &t, nil
-}
-
-var _ graph.AddCommentOperationResolver = addCommentOperationResolver{}
-
-type addCommentOperationResolver struct{}
-
-func (addCommentOperationResolver) Author(_ context.Context, obj *bug.AddCommentOperation) (models.IdentityWrapper, error) {
-	return models.NewLoadedIdentity(obj.Author()), nil
-}
-
-func (addCommentOperationResolver) Date(_ context.Context, obj *bug.AddCommentOperation) (*time.Time, error) {
-	t := obj.Time()
-	return &t, nil
-}
-
-var _ graph.EditCommentOperationResolver = editCommentOperationResolver{}
-
-type editCommentOperationResolver struct{}
-
-func (editCommentOperationResolver) Target(_ context.Context, obj *bug.EditCommentOperation) (string, error) {
-	return obj.Target.String(), nil
-}
-
-func (editCommentOperationResolver) Author(_ context.Context, obj *bug.EditCommentOperation) (models.IdentityWrapper, error) {
-	return models.NewLoadedIdentity(obj.Author()), nil
-}
-
-func (editCommentOperationResolver) Date(_ context.Context, obj *bug.EditCommentOperation) (*time.Time, error) {
-	t := obj.Time()
-	return &t, nil
-}
-
-var _ graph.LabelChangeOperationResolver = labelChangeOperationResolver{}
-
-type labelChangeOperationResolver struct{}
-
-func (labelChangeOperationResolver) Author(_ context.Context, obj *bug.LabelChangeOperation) (models.IdentityWrapper, error) {
-	return models.NewLoadedIdentity(obj.Author()), nil
-}
-
-func (labelChangeOperationResolver) Date(_ context.Context, obj *bug.LabelChangeOperation) (*time.Time, error) {
-	t := obj.Time()
-	return &t, nil
-}
-
-var _ graph.SetStatusOperationResolver = setStatusOperationResolver{}
-
-type setStatusOperationResolver struct{}
-
-func (setStatusOperationResolver) Author(_ context.Context, obj *bug.SetStatusOperation) (models.IdentityWrapper, error) {
-	return models.NewLoadedIdentity(obj.Author()), nil
-}
-
-func (setStatusOperationResolver) Date(_ context.Context, obj *bug.SetStatusOperation) (*time.Time, error) {
-	t := obj.Time()
-	return &t, nil
-}
-
-var _ graph.SetTitleOperationResolver = setTitleOperationResolver{}
-
-type setTitleOperationResolver struct{}
-
-func (setTitleOperationResolver) Author(_ context.Context, obj *bug.SetTitleOperation) (models.IdentityWrapper, error) {
-	return models.NewLoadedIdentity(obj.Author()), nil
-}
-
-func (setTitleOperationResolver) Date(_ context.Context, obj *bug.SetTitleOperation) (*time.Time, error) {
-	t := obj.Time()
-	return &t, nil
-}

api/graphql/resolvers/root.go

@@ -10,6 +10,7 @@ var _ graph.ResolverRoot = &RootResolver{}
 
 type RootResolver struct {
 	*cache.MultiRepoCache
+	bugRootSubResolver
 }
 
 func NewRootResolver(mrc *cache.MultiRepoCache) *RootResolver {
@@ -30,74 +31,22 @@ func (r RootResolver) Mutation() graph.MutationResolver {
 	}
 }
 
-func (RootResolver) Repository() graph.RepositoryResolver {
-	return &repoResolver{}
-}
-
-func (RootResolver) Bug() graph.BugResolver {
-	return &bugResolver{}
-}
-
 func (RootResolver) Color() graph.ColorResolver {
 	return &colorResolver{}
 }
 
-func (r RootResolver) Comment() graph.CommentResolver {
-	return &commentResolver{}
-}
-
-func (RootResolver) Label() graph.LabelResolver {
-	return &labelResolver{}
-}
-
 func (r RootResolver) Identity() graph.IdentityResolver {
 	return &identityResolver{}
 }
 
-func (RootResolver) CommentHistoryStep() graph.CommentHistoryStepResolver {
-	return &commentHistoryStepResolver{}
-}
-
-func (RootResolver) AddCommentTimelineItem() graph.AddCommentTimelineItemResolver {
-	return &addCommentTimelineItemResolver{}
-}
-
-func (RootResolver) CreateTimelineItem() graph.CreateTimelineItemResolver {
-	return &createTimelineItemResolver{}
-}
-
-func (r RootResolver) LabelChangeTimelineItem() graph.LabelChangeTimelineItemResolver {
-	return &labelChangeTimelineItem{}
-}
-
-func (r RootResolver) SetStatusTimelineItem() graph.SetStatusTimelineItemResolver {
-	return &setStatusTimelineItem{}
-}
-
-func (r RootResolver) SetTitleTimelineItem() graph.SetTitleTimelineItemResolver {
-	return &setTitleTimelineItem{}
-}
-
-func (RootResolver) CreateOperation() graph.CreateOperationResolver {
-	return &createOperationResolver{}
-}
-
-func (RootResolver) AddCommentOperation() graph.AddCommentOperationResolver {
-	return &addCommentOperationResolver{}
-}
-
-func (r RootResolver) EditCommentOperation() graph.EditCommentOperationResolver {
-	return &editCommentOperationResolver{}
-}
-
-func (RootResolver) LabelChangeOperation() graph.LabelChangeOperationResolver {
-	return &labelChangeOperationResolver{}
+func (RootResolver) Label() graph.LabelResolver {
+	return &labelResolver{}
 }
 
-func (RootResolver) SetStatusOperation() graph.SetStatusOperationResolver {
-	return &setStatusOperationResolver{}
+func (RootResolver) Repository() graph.RepositoryResolver {
+	return &repoResolver{}
 }
 
-func (RootResolver) SetTitleOperation() graph.SetTitleOperationResolver {
-	return &setTitleOperationResolver{}
+func (RootResolver) Bug() graph.BugResolver {
+	return &bugResolver{}
 }

api/graphql/resolvers/timeline.go

@@ -1,115 +0,0 @@
-package resolvers
-
-import (
-	"context"
-	"time"
-
-	"github.com/git-bug/git-bug/api/graphql/graph"
-	"github.com/git-bug/git-bug/api/graphql/models"
-	"github.com/git-bug/git-bug/entities/bug"
-	"github.com/git-bug/git-bug/entity"
-)
-
-var _ graph.CommentHistoryStepResolver = commentHistoryStepResolver{}
-
-type commentHistoryStepResolver struct{}
-
-func (commentHistoryStepResolver) Date(_ context.Context, obj *bug.CommentHistoryStep) (*time.Time, error) {
-	t := obj.UnixTime.Time()
-	return &t, nil
-}
-
-var _ graph.AddCommentTimelineItemResolver = addCommentTimelineItemResolver{}
-
-type addCommentTimelineItemResolver struct{}
-
-func (addCommentTimelineItemResolver) ID(_ context.Context, obj *bug.AddCommentTimelineItem) (entity.CombinedId, error) {
-	return obj.CombinedId(), nil
-}
-
-func (addCommentTimelineItemResolver) Author(_ context.Context, obj *bug.AddCommentTimelineItem) (models.IdentityWrapper, error) {
-	return models.NewLoadedIdentity(obj.Author), nil
-}
-
-func (addCommentTimelineItemResolver) CreatedAt(_ context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error) {
-	t := obj.CreatedAt.Time()
-	return &t, nil
-}
-
-func (addCommentTimelineItemResolver) LastEdit(_ context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error) {
-	t := obj.LastEdit.Time()
-	return &t, nil
-}
-
-var _ graph.CreateTimelineItemResolver = createTimelineItemResolver{}
-
-type createTimelineItemResolver struct{}
-
-func (createTimelineItemResolver) ID(_ context.Context, obj *bug.CreateTimelineItem) (entity.CombinedId, error) {
-	return obj.CombinedId(), nil
-}
-
-func (r createTimelineItemResolver) Author(_ context.Context, obj *bug.CreateTimelineItem) (models.IdentityWrapper, error) {
-	return models.NewLoadedIdentity(obj.Author), nil
-}
-
-func (createTimelineItemResolver) CreatedAt(_ context.Context, obj *bug.CreateTimelineItem) (*time.Time, error) {
-	t := obj.CreatedAt.Time()
-	return &t, nil
-}
-
-func (createTimelineItemResolver) LastEdit(_ context.Context, obj *bug.CreateTimelineItem) (*time.Time, error) {
-	t := obj.LastEdit.Time()
-	return &t, nil
-}
-
-var _ graph.LabelChangeTimelineItemResolver = labelChangeTimelineItem{}
-
-type labelChangeTimelineItem struct{}
-
-func (labelChangeTimelineItem) ID(_ context.Context, obj *bug.LabelChangeTimelineItem) (entity.CombinedId, error) {
-	return obj.CombinedId(), nil
-}
-
-func (i labelChangeTimelineItem) Author(_ context.Context, obj *bug.LabelChangeTimelineItem) (models.IdentityWrapper, error) {
-	return models.NewLoadedIdentity(obj.Author), nil
-}
-
-func (labelChangeTimelineItem) Date(_ context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error) {
-	t := obj.UnixTime.Time()
-	return &t, nil
-}
-
-var _ graph.SetStatusTimelineItemResolver = setStatusTimelineItem{}
-
-type setStatusTimelineItem struct{}
-
-func (setStatusTimelineItem) ID(_ context.Context, obj *bug.SetStatusTimelineItem) (entity.CombinedId, error) {
-	return obj.CombinedId(), nil
-}
-
-func (i setStatusTimelineItem) Author(_ context.Context, obj *bug.SetStatusTimelineItem) (models.IdentityWrapper, error) {
-	return models.NewLoadedIdentity(obj.Author), nil
-}
-
-func (setStatusTimelineItem) Date(_ context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error) {
-	t := obj.UnixTime.Time()
-	return &t, nil
-}
-
-var _ graph.SetTitleTimelineItemResolver = setTitleTimelineItem{}
-
-type setTitleTimelineItem struct{}
-
-func (setTitleTimelineItem) ID(_ context.Context, obj *bug.SetTitleTimelineItem) (entity.CombinedId, error) {
-	return obj.CombinedId(), nil
-}
-
-func (i setTitleTimelineItem) Author(_ context.Context, obj *bug.SetTitleTimelineItem) (models.IdentityWrapper, error) {
-	return models.NewLoadedIdentity(obj.Author), nil
-}
-
-func (setTitleTimelineItem) Date(_ context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error) {
-	t := obj.UnixTime.Time()
-	return &t, nil
-}

api/graphql/schema/bug.graphql

@@ -1,34 +1,3 @@
-"""Represents a comment on a bug."""
-type Comment implements Authored {
-  id: CombinedId!
-
-  """The author of this comment."""
-  author: Identity!
-
-  """The message of this comment."""
-  message: String!
-
-  """All media's hash referenced in this comment"""
-  files: [Hash!]!
-}
-
-type CommentConnection {
-  edges: [CommentEdge!]!
-  nodes: [Comment!]!
-  pageInfo: PageInfo!
-  totalCount: Int!
-}
-
-type CommentEdge {
-  cursor: String!
-  node: Comment!
-}
-
-enum Status {
-  OPEN
-  CLOSED
-}
-
 type Bug implements Authored {
   """The identifier for this bug"""
   id: ID!
@@ -75,7 +44,7 @@ type Bug implements Authored {
     first: Int
     """Returns the last _n_ elements from the list."""
     last: Int
-  ): CommentConnection!
+  ): BugCommentConnection!
 
   timeline(
     """Returns the elements in the list that come after the specified cursor."""
@@ -86,7 +55,7 @@ type Bug implements Authored {
     first: Int
     """Returns the last _n_ elements from the list."""
     last: Int
-  ): TimelineItemConnection!
+  ): BugTimelineItemConnection!
 
   operations(
     """Returns the elements in the list that come after the specified cursor."""

api/graphql/schema/bug_comment.graphql

@@ -0,0 +1,26 @@
+"""Represents a comment on a bug."""
+type BugComment implements Authored
+@goModel(model: "github.com/git-bug/git-bug/entities/bug.Comment") {
+    id: CombinedId! @goField(name: "CombinedId")
+
+    """The author of this comment."""
+    author: Identity!
+
+    """The message of this comment."""
+    message: String!
+
+    """All media's hash referenced in this comment"""
+    files: [Hash!]!
+}
+
+type BugCommentConnection {
+    edges: [BugCommentEdge!]!
+    nodes: [BugComment!]!
+    pageInfo: PageInfo!
+    totalCount: Int!
+}
+
+type BugCommentEdge {
+    cursor: String!
+    node: BugComment!
+}

api/graphql/schema/mutations.graphql → api/graphql/schema/bug_mutations.graphql

@@ -1,4 +1,25 @@
-input NewBugInput {
+extend type Mutation {
+    """Create a new bug"""
+    bugCreate(input: BugCreateInput!): BugCreatePayload!
+    """Add a new comment to a bug"""
+    bugAddComment(input: BugAddCommentInput!): BugAddCommentPayload!
+    """Add a new comment to a bug and close it"""
+    bugAddCommentAndClose(input: BugAddCommentAndCloseInput!): BugAddCommentAndClosePayload!
+    """Add a new comment to a bug and reopen it"""
+    bugAddCommentAndReopen(input: BugAddCommentAndReopenInput!): BugAddCommentAndReopenPayload!
+    """Change a comment of a bug"""
+    bugEditComment(input: BugEditCommentInput!): BugEditCommentPayload!
+    """Add or remove a set of label on a bug"""
+    bugChangeLabels(input: BugChangeLabelInput): BugChangeLabelPayload!
+    """Change a bug's status to open"""
+    bugStatusOpen(input: BugStatusOpenInput!): BugStatusOpenPayload!
+    """Change a bug's status to closed"""
+    bugStatusClose(input: BugStatusCloseInput!): BugStatusClosePayload!
+    """Change a bug's title"""
+    bugSetTitle(input: BugSetTitleInput!): BugSetTitlePayload!
+}
+
+input BugCreateInput {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The name of the repository. If not set, the default repository is used."""
@@ -11,16 +32,16 @@ input NewBugInput {
     files: [Hash!]
 }
 
-type NewBugPayload {
+type BugCreatePayload {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The created bug."""
     bug: Bug!
     """The resulting operation."""
-    operation: CreateOperation!
+    operation: BugCreateOperation!
 }
 
-input AddCommentInput {
+input BugAddCommentInput {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The name of the repository. If not set, the default repository is used."""
@@ -33,16 +54,16 @@ input AddCommentInput {
     files: [Hash!]
 }
 
-type AddCommentPayload {
+type BugAddCommentPayload {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The affected bug."""
     bug: Bug!
     """The resulting operation."""
-    operation: AddCommentOperation!
+    operation: BugAddCommentOperation!
 }
 
-input AddCommentAndCloseBugInput {
+input BugAddCommentAndCloseInput {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The name of the repository. If not set, the default repository is used."""
@@ -55,18 +76,18 @@ input AddCommentAndCloseBugInput {
     files: [Hash!]
 }
 
-type AddCommentAndCloseBugPayload {
+type BugAddCommentAndClosePayload {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The affected bug."""
     bug: Bug!
     """The resulting AddComment operation."""
-    commentOperation: AddCommentOperation!
+    commentOperation: BugAddCommentOperation!
     """The resulting SetStatusOperation."""
-    statusOperation: SetStatusOperation!
+    statusOperation: BugSetStatusOperation!
 }
 
-input AddCommentAndReopenBugInput {
+input BugAddCommentAndReopenInput {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The name of the repository. If not set, the default repository is used."""
@@ -79,18 +100,18 @@ input AddCommentAndReopenBugInput {
     files: [Hash!]
 }
 
-type AddCommentAndReopenBugPayload {
+type BugAddCommentAndReopenPayload {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The affected bug."""
     bug: Bug!
     """The resulting AddComment operation."""
-    commentOperation: AddCommentOperation!
+    commentOperation: BugAddCommentOperation!
     """The resulting SetStatusOperation."""
-    statusOperation: SetStatusOperation!
+    statusOperation: BugSetStatusOperation!
 }
 
-input EditCommentInput {
+input BugEditCommentInput {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The name of the repository. If not set, the default repository is used."""
@@ -103,16 +124,16 @@ input EditCommentInput {
     files: [Hash!]
 }
 
-type EditCommentPayload {
+type BugEditCommentPayload {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The affected bug."""
     bug: Bug!
     """The resulting operation."""
-    operation: EditCommentOperation!
+    operation: BugEditCommentOperation!
 }
 
-input ChangeLabelInput {
+input BugChangeLabelInput {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The name of the repository. If not set, the default repository is used."""
@@ -125,33 +146,18 @@ input ChangeLabelInput {
     Removed: [String!]
 }
 
-enum LabelChangeStatus {
-    ADDED
-    REMOVED
-    DUPLICATE_IN_OP
-    ALREADY_SET
-    DOESNT_EXIST
-}
-
-type LabelChangeResult {
-    """The source label."""
-    label: Label!
-    """The effect this label had."""
-    status: LabelChangeStatus!
-}
-
-type ChangeLabelPayload {
+type BugChangeLabelPayload {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The affected bug."""
     bug: Bug!
     """The resulting operation."""
-    operation: LabelChangeOperation!
+    operation: BugLabelChangeOperation!
     """The effect each source label had."""
     results: [LabelChangeResult]!
 }
 
-input OpenBugInput {
+input BugStatusOpenInput {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The name of the repository. If not set, the default repository is used."""
@@ -160,16 +166,16 @@ input OpenBugInput {
     prefix: String!
 }
 
-type OpenBugPayload {
+type BugStatusOpenPayload {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The affected bug."""
     bug: Bug!
     """The resulting operation."""
-    operation: SetStatusOperation!
+    operation: BugSetStatusOperation!
 }
 
-input CloseBugInput {
+input BugStatusCloseInput {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The name of the repository. If not set, the default repository is used."""
@@ -178,16 +184,16 @@ input CloseBugInput {
     prefix: String!
 }
 
-type CloseBugPayload {
+type BugStatusClosePayload {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The affected bug."""
     bug: Bug!
     """The resulting operation."""
-    operation: SetStatusOperation!
+    operation: BugSetStatusOperation!
 }
 
-input SetTitleInput {
+input BugSetTitleInput {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The name of the repository. If not set, the default repository is used."""
@@ -198,11 +204,11 @@ input SetTitleInput {
     title: String!
 }
 
-type SetTitlePayload {
+type BugSetTitlePayload {
     """A unique identifier for the client performing the mutation."""
     clientMutationId: String
     """The affected bug."""
     bug: Bug!
     """The resulting operation"""
-    operation: SetTitleOperation!
+    operation: BugSetTitleOperation!
 }

api/graphql/schema/operations.graphql → api/graphql/schema/bug_operations.graphql

@@ -1,99 +1,77 @@
-"""An operation applied to a bug."""
-interface Operation {
-    """The identifier of the operation"""
-    id: ID!
-    """The operations author."""
-    author: Identity!
-    """The datetime when this operation was issued."""
-    date: Time!
-}
-
-# Connection
-
-"""The connection type for an Operation"""
-type OperationConnection {
-    edges: [OperationEdge!]!
-    nodes: [Operation!]!
-    pageInfo: PageInfo!
-    totalCount: Int!
-}
-
-"""Represent an Operation"""
-type OperationEdge {
-    cursor: String!
-    node: Operation!
-}
-
-# Operations
-
-type CreateOperation implements Operation & Authored {
+type BugCreateOperation implements Operation & Authored
+@goModel(model: "github.com/git-bug/git-bug/entities/bug.CreateOperation") {
     """The identifier of the operation"""
     id: ID!
     """The author of this object."""
     author: Identity!
     """The datetime when this operation was issued."""
-    date: Time!
+    date: Time! @goField(name: "Time")
 
     title: String!
     message: String!
     files: [Hash!]!
 }
 
-type SetTitleOperation implements Operation & Authored {
+type BugSetTitleOperation implements Operation & Authored
+@goModel(model: "github.com/git-bug/git-bug/entities/bug.SetTitleOperation") {
     """The identifier of the operation"""
     id: ID!
     """The author of this object."""
     author: Identity!
     """The datetime when this operation was issued."""
-    date: Time!
+    date: Time! @goField(name: "Time")
 
     title: String!
     was: String!
 }
 
-type AddCommentOperation implements Operation & Authored {
+type BugAddCommentOperation implements Operation & Authored
+@goModel(model: "github.com/git-bug/git-bug/entities/bug.AddCommentOperation") {
     """The identifier of the operation"""
     id: ID!
     """The author of this object."""
     author: Identity!
     """The datetime when this operation was issued."""
-    date: Time!
+    date: Time! @goField(name: "Time")
 
     message: String!
     files: [Hash!]!
 }
 
-type EditCommentOperation implements Operation & Authored {
+type BugEditCommentOperation implements Operation & Authored
+@goModel(model: "github.com/git-bug/git-bug/entities/bug.EditCommentOperation") {
     """The identifier of the operation"""
     id: ID!
     """The author of this object."""
     author: Identity!
     """The datetime when this operation was issued."""
-    date: Time!
+    date: Time! @goField(name: "Time")
 
     target: String!
     message: String!
     files: [Hash!]!
 }
 
-type SetStatusOperation implements Operation & Authored {
+type BugSetStatusOperation implements Operation & Authored
+@goModel(model: "github.com/git-bug/git-bug/entities/bug.SetStatusOperation") {
     """The identifier of the operation"""
     id: ID!
     """The author of this object."""
     author: Identity!
     """The datetime when this operation was issued."""
-    date: Time!
+    date: Time! @goField(name: "Time")
 
     status: Status!
 }
 
-type LabelChangeOperation implements Operation & Authored {
+type BugLabelChangeOperation implements Operation & Authored
+@goModel(model: "github.com/git-bug/git-bug/entities/bug.LabelChangeOperation") {
     """The identifier of the operation"""
     id: ID!
     """The author of this object."""
     author: Identity!
     """The datetime when this operation was issued."""
-    date: Time!
+    date: Time! @goField(name: "Time")
 
     added: [Label!]!
     removed: [Label!]!

api/graphql/schema/bug_timeline.graphql

@@ -0,0 +1,93 @@
+"""An item in the timeline of bug events"""
+interface BugTimelineItem
+@goModel(model: "github.com/git-bug/git-bug/entities/bug.TimelineItem") {
+    """The identifier of the source operation"""
+    id: CombinedId!
+}
+
+"""CommentHistoryStep hold one version of a message in the history"""
+type BugCommentHistoryStep
+@goModel(model: "github.com/git-bug/git-bug/entities/bug.CommentHistoryStep") {
+    message: String!
+    date: Time!
+}
+
+# Connection
+
+"""The connection type for TimelineItem"""
+type BugTimelineItemConnection {
+    edges: [BugTimelineItemEdge!]!
+    nodes: [BugTimelineItem!]!
+    pageInfo: PageInfo!
+    totalCount: Int!
+}
+
+"""Represent a TimelineItem"""
+type BugTimelineItemEdge {
+    cursor: String!
+    node: BugTimelineItem!
+}
+
+# Items
+
+"""BugCreateTimelineItem is a BugTimelineItem that represent the creation of a bug and its message edition history"""
+type BugCreateTimelineItem implements BugTimelineItem & Authored
+@goModel(model: "github.com/git-bug/git-bug/entities/bug.CreateTimelineItem") {
+    """The identifier of the source operation"""
+    id: CombinedId! @goField(name: "CombinedId")
+    author: Identity!
+    message: String!
+    messageIsEmpty: Boolean!
+    files: [Hash!]!
+    createdAt: Time!
+    lastEdit: Time!
+    edited: Boolean!
+    history: [BugCommentHistoryStep!]!
+}
+
+"""BugAddCommentTimelineItem is a BugTimelineItem that represent a BugComment and its edition history"""
+type BugAddCommentTimelineItem implements BugTimelineItem & Authored
+@goModel(model: "github.com/git-bug/git-bug/entities/bug.AddCommentTimelineItem") {
+    """The identifier of the source operation"""
+    id: CombinedId! @goField(name: "CombinedId")
+    author: Identity!
+    message: String!
+    messageIsEmpty: Boolean!
+    files: [Hash!]!
+    createdAt: Time!
+    lastEdit: Time!
+    edited: Boolean!
+    history: [BugCommentHistoryStep!]!
+}
+
+"""BugLabelChangeTimelineItem is a BugTimelineItem that represent a change in the labels of a bug"""
+type BugLabelChangeTimelineItem implements BugTimelineItem & Authored
+@goModel(model: "github.com/git-bug/git-bug/entities/bug.LabelChangeTimelineItem") {
+    """The identifier of the source operation"""
+    id: CombinedId! @goField(name: "CombinedId")
+    author: Identity!
+    date: Time!
+    added: [Label!]!
+    removed: [Label!]!
+}
+
+"""BugSetStatusTimelineItem is a BugTimelineItem that represent a change in the status of a bug"""
+type BugSetStatusTimelineItem implements BugTimelineItem & Authored
+@goModel(model: "github.com/git-bug/git-bug/entities/bug.SetStatusTimelineItem") {
+    """The identifier of the source operation"""
+    id: CombinedId! @goField(name: "CombinedId")
+    author: Identity!
+    date: Time!
+    status: Status!
+}
+
+"""BugLabelChangeTimelineItem is a BugTimelineItem that represent a change in the title of a bug"""
+type BugSetTitleTimelineItem implements BugTimelineItem & Authored
+@goModel(model: "github.com/git-bug/git-bug/entities/bug.SetTitleTimelineItem") {
+    """The identifier of the source operation"""
+    id: CombinedId! @goField(name: "CombinedId")
+    author: Identity!
+    date: Time!
+    title: String!
+    was: String!
+}

api/graphql/schema/directives.graphql

@@ -0,0 +1,18 @@
+# Below are directives defined by gqlgen, see https://gqlgen.com/config/
+
+directive @goModel(
+    model: String
+    models: [String!]
+    forceGenerate: Boolean
+) on OBJECT | INPUT_OBJECT | SCALAR | ENUM | INTERFACE | UNION
+
+directive @goField(
+    forceResolver: Boolean
+    name: String
+    omittable: Boolean
+) on INPUT_FIELD_DEFINITION | FIELD_DEFINITION
+
+directive @goTag(
+    key: String!
+    value: String
+) on INPUT_FIELD_DEFINITION | FIELD_DEFINITION

api/graphql/schema/identity.graphql

@@ -29,4 +29,4 @@ type IdentityConnection {
 type IdentityEdge {
     cursor: String!
     node: Identity!
-}
+}

api/graphql/schema/label.graphql

@@ -16,4 +16,19 @@ type LabelConnection {
 type LabelEdge {
     cursor: String!
     node: Label!
-}
+}
+
+enum LabelChangeStatus {
+    ADDED
+    REMOVED
+    DUPLICATE_IN_OP
+    ALREADY_SET
+    DOESNT_EXIST
+}
+
+type LabelChangeResult {
+    """The source label."""
+    label: Label!
+    """The effect this label had."""
+    status: LabelChangeStatus!
+}

api/graphql/schema/operation.graphql

@@ -0,0 +1,25 @@
+"""An operation applied to an entity."""
+interface Operation {
+    """The identifier of the operation"""
+    id: ID!
+    """The operations author."""
+    author: Identity!
+    """The datetime when this operation was issued."""
+    date: Time! @goField(name: "Time")
+}
+
+# Connection
+
+"""The connection type for an Operation"""
+type OperationConnection {
+    edges: [OperationEdge!]!
+    nodes: [Operation!]!
+    pageInfo: PageInfo!
+    totalCount: Int!
+}
+
+"""Represent an Operation"""
+type OperationEdge {
+    cursor: String!
+    node: Operation!
+}

api/graphql/schema/repository.graphql

@@ -1,4 +1,3 @@
-
 type Repository {
     """The name of the repository"""
     name: String

api/graphql/schema/root.graphql

@@ -3,23 +3,4 @@ type Query {
     repository(ref: String): Repository
 }
 
-type Mutation {
-    """Create a new bug"""
-    newBug(input: NewBugInput!): NewBugPayload!
-    """Add a new comment to a bug"""
-    addComment(input: AddCommentInput!): AddCommentPayload!
-    """Add a new comment to a bug and close it"""
-    addCommentAndClose(input: AddCommentAndCloseBugInput!): AddCommentAndCloseBugPayload!
-    """Add a new comment to a bug and reopen it"""
-    addCommentAndReopen(input: AddCommentAndReopenBugInput!): AddCommentAndReopenBugPayload!
-    """Change a comment of a bug"""
-    editComment(input: EditCommentInput!): EditCommentPayload!
-    """Add or remove a set of label on a bug"""
-    changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
-    """Change a bug's status to open"""
-    openBug(input: OpenBugInput!): OpenBugPayload!
-    """Change a bug's status to closed"""
-    closeBug(input: CloseBugInput!): CloseBugPayload!
-    """Change a bug's title"""
-    setTitle(input: SetTitleInput!): SetTitlePayload!
-}
+type Mutation # See each entity mutations

api/graphql/schema/status.graphql

@@ -0,0 +1,4 @@
+enum Status {
+    OPEN
+    CLOSED
+}

api/graphql/schema/timeline.graphql

@@ -1,86 +0,0 @@
-"""An item in the timeline of events"""
-interface TimelineItem {
-    """The identifier of the source operation"""
-    id: CombinedId!
-}
-
-"""CommentHistoryStep hold one version of a message in the history"""
-type CommentHistoryStep {
-    message: String!
-    date: Time!
-}
-
-# Connection
-
-"""The connection type for TimelineItem"""
-type TimelineItemConnection {
-    edges: [TimelineItemEdge!]!
-    nodes: [TimelineItem!]!
-    pageInfo: PageInfo!
-    totalCount: Int!
-}
-
-"""Represent a TimelineItem"""
-type TimelineItemEdge {
-    cursor: String!
-    node: TimelineItem!
-}
-
-# Items
-
-"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
-type CreateTimelineItem implements TimelineItem & Authored {
-    """The identifier of the source operation"""
-    id: CombinedId!
-    author: Identity!
-    message: String!
-    messageIsEmpty: Boolean!
-    files: [Hash!]!
-    createdAt: Time!
-    lastEdit: Time!
-    edited: Boolean!
-    history: [CommentHistoryStep!]!
-}
-
-"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
-type AddCommentTimelineItem implements TimelineItem & Authored {
-    """The identifier of the source operation"""
-    id: CombinedId!
-    author: Identity!
-    message: String!
-    messageIsEmpty: Boolean!
-    files: [Hash!]!
-    createdAt: Time!
-    lastEdit: Time!
-    edited: Boolean!
-    history: [CommentHistoryStep!]!
-}
-
-"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
-type LabelChangeTimelineItem implements TimelineItem & Authored {
-    """The identifier of the source operation"""
-    id: CombinedId!
-    author: Identity!
-    date: Time!
-    added: [Label!]!
-    removed: [Label!]!
-}
-
-"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
-type SetStatusTimelineItem implements TimelineItem & Authored {
-    """The identifier of the source operation"""
-    id: CombinedId!
-    author: Identity!
-    date: Time!
-    status: Status!
-}
-
-"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
-type SetTitleTimelineItem implements TimelineItem & Authored {
-    """The identifier of the source operation"""
-    id: CombinedId!
-    author: Identity!
-    date: Time!
-    title: String!
-    was: String!
-}

api/graphql/tracer.go

@@ -14,32 +14,21 @@ import (
 
 // adapted from https://github.com/99designs/gqlgen/blob/master/graphql/handler/debug/tracer.go
 
+var _ graphql.HandlerExtension = &Tracer{}
+var _ graphql.ResponseInterceptor = &Tracer{}
+
 type Tracer struct {
 	Out io.Writer
 }
 
-var _ interface {
-	graphql.HandlerExtension
-	graphql.ResponseInterceptor
-} = &Tracer{}
-
 func (a Tracer) ExtensionName() string {
 	return "error tracer"
 }
 
-func (a *Tracer) Validate(schema graphql.ExecutableSchema) error {
+func (a Tracer) Validate(schema graphql.ExecutableSchema) error {
 	return nil
 }
 
-func stringify(value interface{}) string {
-	valueJson, err := json.MarshalIndent(value, "  ", "  ")
-	if err == nil {
-		return string(valueJson)
-	}
-
-	return fmt.Sprint(value)
-}
-
 func (a Tracer) InterceptResponse(ctx context.Context, next graphql.ResponseHandler) *graphql.Response {
 	resp := next(ctx)
 
@@ -65,3 +54,12 @@ func (a Tracer) InterceptResponse(ctx context.Context, next graphql.ResponseHand
 	_, _ = fmt.Fprintln(a.Out)
 	return resp
 }
+
+func stringify(value interface{}) string {
+	valueJson, err := json.MarshalIndent(value, "  ", "  ")
+	if err == nil {
+		return string(valueJson)
+	}
+
+	return fmt.Sprint(value)
+}

go.mod

@@ -28,6 +28,8 @@ require (
 	github.com/phayes/freeport v0.0.0-20220201140144-74d24b5ae9f5
 	github.com/pkg/errors v0.9.1
 	github.com/shurcooL/githubv4 v0.0.0-20240429030203-be2daab69064
+	github.com/shurcooL/httpfs v0.0.0-20230704072500-f1e31cf0ba5c
+	github.com/shurcooL/vfsgen v0.0.0-20230704071429-0000e147ea92
 	github.com/skratchdot/open-golang v0.0.0-20200116055534-eef842397966
 	github.com/spf13/cobra v1.8.1
 	github.com/stretchr/testify v1.9.0

go.sum

@@ -264,6 +264,10 @@ github.com/shurcooL/githubv4 v0.0.0-20240429030203-be2daab69064 h1:RCQBSFx5JrsbH
 github.com/shurcooL/githubv4 v0.0.0-20240429030203-be2daab69064/go.mod h1:zqMwyHmnN/eDOZOdiTohqIUKUrTFX62PNlu7IJdu0q8=
 github.com/shurcooL/graphql v0.0.0-20230722043721-ed46e5a46466 h1:17JxqqJY66GmZVHkmAsGEkcIu0oCe3AM420QDgGwZx0=
 github.com/shurcooL/graphql v0.0.0-20230722043721-ed46e5a46466/go.mod h1:9dIRpgIY7hVhoqfe0/FcYp0bpInZaT7dc3BYOprrIUE=
+github.com/shurcooL/httpfs v0.0.0-20230704072500-f1e31cf0ba5c h1:aqg5Vm5dwtvL+YgDpBcK1ITf3o96N/K7/wsRXQnUTEs=
+github.com/shurcooL/httpfs v0.0.0-20230704072500-f1e31cf0ba5c/go.mod h1:owqhoLW1qZoYLZzLnBw+QkPP9WZnjlSWihhxAJC1+/M=
+github.com/shurcooL/vfsgen v0.0.0-20230704071429-0000e147ea92 h1:OfRzdxCzDhp+rsKWXuOO2I/quKMJ/+TQwVbIP/gltZg=
+github.com/shurcooL/vfsgen v0.0.0-20230704071429-0000e147ea92/go.mod h1:7/OT02F6S6I7v6WXb+IjhMuZEYfH/RJ5RwEWnEo5BMg=
 github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
 github.com/skeema/knownhosts v1.3.0 h1:AM+y0rI04VksttfwjkSTNQorvGqmwATnvnAHpSgc0LY=
 github.com/skeema/knownhosts v1.3.0/go.mod h1:sPINvnADmT/qYH1kfv+ePMmOBTH6Tbl7b5LvTDjFK7M=

tools.go

@@ -5,5 +5,7 @@ package tools
 import (
 	_ "github.com/99designs/gqlgen"
 	_ "github.com/praetorian-inc/gokart"
+	_ "github.com/shurcooL/httpfs/filter"
+	_ "github.com/shurcooL/vfsgen"
 	_ "golang.org/x/vuln/cmd/govulncheck"
 )

webui/packed_assets.go

@@ -1,7 +1,6 @@
 // Code generated by vfsgen; DO NOT EDIT.
 
 //go:build !debugwebui
-// +build !debugwebui
 
 package webui
 
@@ -21,71 +20,71 @@ var WebUIAssets = func() http.FileSystem {
 	fs := vfsgen۰FS{
 		"/": &vfsgen۰DirInfo{
 			name:    "/",
-			modTime: time.Date(2022, 11, 20, 14, 1, 52, 650910730, time.UTC),
+			modTime: time.Date(2024, 8, 27, 17, 17, 49, 869973542, time.UTC),
 		},
 		"/asset-manifest.json": &vfsgen۰CompressedFileInfo{
 			name:             "asset-manifest.json",
-			modTime:          time.Date(2022, 11, 20, 14, 1, 52, 650910730, time.UTC),
+			modTime:          time.Date(2024, 8, 27, 17, 17, 49, 869973542, time.UTC),
 			uncompressedSize: 218,
 
-			compressedContent: []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x02\xff\xaa\xe6\x52\x50\x50\x4a\xcb\xcc\x49\x2d\x56\xb2\x52\x00\x71\x14\x14\x94\x72\x13\x33\xf3\xf4\xb2\x40\x02\x4a\xfa\xc5\x25\x89\x25\x99\xc9\xfa\x59\xc5\xfa\x60\x51\xb3\x94\x54\xa3\x14\x43\x93\x44\x90\xb4\x0e\x44\x75\x66\x5e\x4a\x6a\x85\x5e\x46\x49\x6e\x0e\x58\x03\x12\x57\x07\xc9\x38\x24\x8d\x7a\xb9\x89\x05\x04\xcc\x06\x2b\xe1\x52\x50\xa8\x05\x19\xa1\x94\x9a\x57\x52\x54\x59\x90\x9f\x99\x57\x02\x72\x53\x34\xc4\x54\x3c\x0e\xe3\x52\x50\x88\xe5\xaa\x05\x04\x00\x00\xff\xff\x4f\x3f\x92\xb2\xda\x00\x00\x00"),
+			compressedContent: []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x02\xff\xaa\xe6\x52\x50\x50\x4a\xcb\xcc\x49\x2d\x56\xb2\x52\x00\x71\x14\x14\x94\x72\x13\x33\xf3\xf4\xb2\x40\x02\x4a\xfa\xc5\x25\x89\x25\x99\xc9\xfa\x59\xc5\xfa\x60\xd1\x24\x43\x13\x03\x0b\x13\x8b\x54\x90\xb4\x0e\x44\x75\x66\x5e\x4a\x6a\x85\x5e\x46\x49\x6e\x0e\x58\x03\x12\x57\x07\xc9\x38\x24\x8d\x7a\xb9\x89\x05\x04\xcc\x06\x2b\xe1\x52\x50\xa8\x05\x19\xa1\x94\x9a\x57\x52\x54\x59\x90\x9f\x99\x57\x02\x72\x53\x34\xc4\x54\x3c\x0e\xe3\x52\x50\x88\xe5\xaa\x05\x04\x00\x00\xff\xff\xda\x02\x96\x7d\xda\x00\x00\x00"),
 		},
 		"/favicon.ico": &vfsgen۰CompressedFileInfo{
 			name:             "favicon.ico",
-			modTime:          time.Date(2022, 11, 20, 14, 1, 13, 273988216, time.UTC),
+			modTime:          time.Date(2024, 8, 27, 17, 17, 8, 649348373, time.UTC),
 			uncompressedSize: 32988,
 

webui/src/components/BugTitleForm/SetTitle.graphql

@@ -1,5 +1,5 @@
-mutation setTitle($input: SetTitleInput!) {
-  setTitle(input: $input) {
+mutation setTitle($input: BugSetTitleInput!) {
+  bugSetTitle(input: $input) {
     bug {
       id
     }

webui/src/components/CloseBugButton/CloseBug.graphql

@@ -1,6 +1,6 @@
 # Write your query or mutation here
-mutation closeBug($input: CloseBugInput!) {
-  closeBug(input: $input) {
+mutation closeBug($input: BugStatusCloseInput!) {
+  bugStatusClose(input: $input) {
     bug {
       id
     }

webui/src/components/CloseBugWithCommentButton/CloseBugWithComment.graphql

@@ -1,5 +1,5 @@
-mutation AddCommentAndCloseBug($input: AddCommentAndCloseBugInput!) {
-  addCommentAndClose(input: $input) {
+mutation AddCommentAndCloseBug($input: BugAddCommentAndCloseInput!) {
+  bugAddCommentAndClose(input: $input) {
     statusOperation {
       status
     }

webui/src/components/ReopenBugButton/OpenBug.graphql

@@ -1,5 +1,5 @@
-mutation openBug($input: OpenBugInput!) {
-  openBug(input: $input) {
+mutation openBug($input: BugStatusOpenInput!) {
+  bugStatusOpen(input: $input) {
     bug {
       id
     }

webui/src/components/ReopenBugWithCommentButton/ReopenBugWithComment.graphql

@@ -1,5 +1,5 @@
-mutation AddCommentAndReopenBug($input: AddCommentAndReopenBugInput!) {
-  addCommentAndReopen(input: $input) {
+mutation AddCommentAndReopenBug($input: BugAddCommentAndReopenInput!) {
+  bugAddCommentAndReopen(input: $input) {
     statusOperation {
       status
     }

webui/src/pages/bug/CommentForm.graphql

@@ -1,5 +1,5 @@
-mutation AddComment($input: AddCommentInput!) {
-  addComment(input: $input) {
+mutation AddComment($input: BugAddCommentInput!) {
+  bugAddComment(input: $input) {
     operation {
       id
     }

webui/src/pages/bug/EditCommentForm.graphql

@@ -1,8 +1,8 @@
 #import "./MessageCommentFragment.graphql"
 #import "./MessageCreateFragment.graphql"
 
-mutation EditComment($input: EditCommentInput!) {
-  editComment(input: $input) {
+mutation EditComment($input: BugEditCommentInput!) {
+  bugEditComment(input: $input) {
     bug {
       id
       timeline {

webui/src/pages/bug/EditCommentForm.tsx

@@ -63,7 +63,7 @@ function EditCommentForm({ bug, comment, onCancel, onPostSubmit }: Props) {
         },
       },
     }).then((result) => {
-      const comments = result.data?.editComment.bug.timeline.comments as (
+      const comments = result.data?.bugEditComment.bug.timeline.comments as (
         | AddCommentFragment
         | CreateFragment
       )[];

webui/src/pages/bug/LabelChangeFragment.graphql

@@ -1,6 +1,6 @@
 #import "../../components/fragments.graphql"
 
-fragment LabelChange on LabelChangeTimelineItem {
+fragment LabelChange on BugLabelChangeTimelineItem {
   date
   ...authored
   added {

webui/src/pages/bug/MessageCommentFragment.graphql

@@ -1,6 +1,6 @@
 #import "../../components/fragments.graphql"
 
-fragment AddComment on AddCommentTimelineItem {
+fragment AddComment on BugAddCommentTimelineItem {
   id
   createdAt
   ...authored

webui/src/pages/bug/MessageCreateFragment.graphql

@@ -1,6 +1,6 @@
 #import "../../components/fragments.graphql"
 
-fragment Create on CreateTimelineItem {
+fragment Create on BugCreateTimelineItem {
   id
   createdAt
   ...authored

webui/src/pages/bug/SetStatusFragment.graphql

@@ -1,6 +1,6 @@
 #import "../../components/fragments.graphql"
 
-fragment SetStatus on SetStatusTimelineItem {
+fragment SetStatus on BugSetStatusTimelineItem {
   date
   ...authored
   status

webui/src/pages/bug/SetTitleFragment.graphql

@@ -1,6 +1,6 @@
 #import "../../components/fragments.graphql"
 
-fragment SetTitle on SetTitleTimelineItem {
+fragment SetTitle on BugSetTitleTimelineItem {
   date
   ...authored
   title

webui/src/pages/bug/Timeline.tsx

@@ -27,15 +27,15 @@ function Timeline({ bug, ops }: Props) {
     <div className={classes.main}>
       {ops.map((op, index) => {
         switch (op.__typename) {
-          case 'CreateTimelineItem':
+          case 'BugCreateTimelineItem':
             return <Message key={index} op={op} bug={bug} />;
-          case 'AddCommentTimelineItem':
+          case 'BugAddCommentTimelineItem':
             return <Message key={index} op={op} bug={bug} />;
-          case 'LabelChangeTimelineItem':
+          case 'BugLabelChangeTimelineItem':
             return <LabelChange key={index} op={op} />;
-          case 'SetTitleTimelineItem':
+          case 'BugSetTitleTimelineItem':
             return <SetTitle key={index} op={op} />;
-          case 'SetStatusTimelineItem':
+          case 'BugSetStatusTimelineItem':
             return <SetStatus key={index} op={op} />;
         }
 

webui/src/pages/bug/TimelineQuery.graphql

@@ -21,20 +21,20 @@ query Timeline($id: String!, $first: Int = 10, $after: String) {
   }
 }
 
-fragment TimelineItem on TimelineItem {
-  ... on LabelChangeTimelineItem {
+fragment TimelineItem on BugTimelineItem {
+  ... on BugLabelChangeTimelineItem {
     ...LabelChange
   }
-  ... on SetStatusTimelineItem {
+  ... on BugSetStatusTimelineItem {
     ...SetStatus
   }
-  ... on SetTitleTimelineItem {
+  ... on BugSetTitleTimelineItem {
     ...SetTitle
   }
-  ... on AddCommentTimelineItem {
+  ... on BugAddCommentTimelineItem {
     ...AddComment
   }
-  ... on CreateTimelineItem {
+  ... on BugCreateTimelineItem {
     ...Create
   }
 }

webui/src/pages/bug/labels/SetLabel.graphql

@@ -1,5 +1,5 @@
-mutation SetLabel($input: ChangeLabelInput) {
-  changeLabels(input: $input) {
+mutation SetLabel($input: BugChangeLabelInput) {
+  bugChangeLabels(input: $input) {
     results {
       status
       label {

webui/src/pages/new/NewBug.graphql

@@ -1,5 +1,5 @@
-mutation newBug($input: NewBugInput!) {
-  newBug(input: $input) {
+mutation newBug($input: BugCreateInput!) {
+  bugCreate(input: $input) {
     bug {
       id
     }

webui/src/pages/new/NewBugPage.tsx

@@ -62,7 +62,7 @@ function NewBugPage() {
         },
       },
     }).then(function (data) {
-      const id = data.data?.newBug.bug.id;
+      const id = data.data?.bugCreate.bug.id;
       navigate('/bug/' + id);
     });