@@ -21,6 +21,8 @@ import (
"github.com/vektah/gqlparser/ast"
)
+// region ************************** generated!.gotpl **************************
+
// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
return &executableSchema{
@@ -61,39 +63,39 @@ type DirectiveRoot struct {
type ComplexityRoot struct {
AddCommentOperation struct {
- Hash func(childComplexity int) int
Author func(childComplexity int) int
Date func(childComplexity int) int
- Message func(childComplexity int) int
Files func(childComplexity int) int
+ Hash func(childComplexity int) int
+ Message func(childComplexity int) int
}
AddCommentTimelineItem struct {
- Hash func(childComplexity int) int
Author func(childComplexity int) int
- Message func(childComplexity int) int
- MessageIsEmpty func(childComplexity int) int
- Files func(childComplexity int) int
CreatedAt func(childComplexity int) int
- LastEdit func(childComplexity int) int
Edited func(childComplexity int) int
+ Files func(childComplexity int) int
+ Hash func(childComplexity int) int
History func(childComplexity int) int
+ LastEdit func(childComplexity int) int
+ Message func(childComplexity int) int
+ MessageIsEmpty func(childComplexity int) int
}
Bug struct {
- Id func(childComplexity int) int
- HumanId func(childComplexity int) int
- Status func(childComplexity int) int
- Title func(childComplexity int) int
- Labels func(childComplexity int) int
+ 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
- Actors func(childComplexity int, after *string, before *string, first *int, last *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
- Comments 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
- Operations func(childComplexity int, after *string, before *string, first *int, last *int) int
+ Title func(childComplexity int) int
}
BugConnection struct {
@@ -110,8 +112,8 @@ type ComplexityRoot struct {
Comment struct {
Author func(childComplexity int) int
- Message func(childComplexity int) int
Files func(childComplexity int) int
+ Message func(childComplexity int) int
}
CommentConnection struct {
@@ -127,49 +129,49 @@ type ComplexityRoot struct {
}
CommentHistoryStep struct {
- Message func(childComplexity int) int
Date func(childComplexity int) int
+ Message func(childComplexity int) int
}
CreateOperation struct {
- Hash func(childComplexity int) int
Author func(childComplexity int) int
Date func(childComplexity int) int
- Title func(childComplexity int) int
- Message func(childComplexity int) int
Files func(childComplexity int) int
+ Hash func(childComplexity int) int
+ Message func(childComplexity int) int
+ Title func(childComplexity int) int
}
CreateTimelineItem struct {
- Hash func(childComplexity int) int
Author func(childComplexity int) int
- Message func(childComplexity int) int
- MessageIsEmpty func(childComplexity int) int
- Files func(childComplexity int) int
CreatedAt func(childComplexity int) int
- LastEdit func(childComplexity int) int
Edited func(childComplexity int) int
+ Files func(childComplexity int) int
+ Hash func(childComplexity int) int
History func(childComplexity int) int
+ LastEdit func(childComplexity int) int
+ Message func(childComplexity int) int
+ MessageIsEmpty func(childComplexity int) int
}
EditCommentOperation struct {
- Hash func(childComplexity int) int
Author func(childComplexity int) int
Date func(childComplexity int) int
- Target func(childComplexity int) int
- Message func(childComplexity int) int
Files func(childComplexity int) int
+ Hash func(childComplexity int) int
+ Message func(childComplexity int) int
+ Target func(childComplexity int) int
}
Identity struct {
- Id func(childComplexity int) int
- HumanId func(childComplexity int) int
- Name func(childComplexity int) int
- Email func(childComplexity int) int
- Login func(childComplexity int) int
+ AvatarURL func(childComplexity int) int
DisplayName func(childComplexity int) int
- AvatarUrl func(childComplexity int) int
+ Email func(childComplexity int) int
+ HumanID func(childComplexity int) int
+ ID func(childComplexity int) int
IsProtected func(childComplexity int) int
+ Login func(childComplexity int) int
+ Name func(childComplexity int) int
}
IdentityConnection struct {
@@ -185,29 +187,29 @@ type ComplexityRoot struct {
}
LabelChangeOperation struct {
- Hash func(childComplexity int) int
+ Added func(childComplexity int) int
Author func(childComplexity int) int
Date func(childComplexity int) int
- Added func(childComplexity int) int
+ Hash func(childComplexity int) int
Removed func(childComplexity int) int
}
LabelChangeTimelineItem struct {
- Hash func(childComplexity int) int
+ Added func(childComplexity int) int
Author func(childComplexity int) int
Date func(childComplexity int) int
- Added func(childComplexity int) int
+ Hash func(childComplexity int) int
Removed func(childComplexity int) int
}
Mutation struct {
- NewBug func(childComplexity int, repoRef *string, title string, message string, files []git.Hash) int
AddComment func(childComplexity int, repoRef *string, prefix string, message string, files []git.Hash) int
ChangeLabels func(childComplexity int, repoRef *string, prefix string, added []string, removed []string) int
- Open func(childComplexity int, repoRef *string, prefix string) int
Close func(childComplexity int, repoRef *string, prefix string) int
- SetTitle func(childComplexity int, repoRef *string, prefix string, title string) int
Commit func(childComplexity int, repoRef *string, prefix string) int
+ NewBug func(childComplexity int, repoRef *string, title string, message string, files []git.Hash) int
+ Open func(childComplexity int, repoRef *string, prefix string) int
+ SetTitle func(childComplexity int, repoRef *string, prefix string, title string) int
}
OperationConnection struct {
@@ -223,10 +225,10 @@ type ComplexityRoot struct {
}
PageInfo struct {
+ EndCursor func(childComplexity int) int
HasNextPage func(childComplexity int) int
HasPreviousPage func(childComplexity int) int
StartCursor func(childComplexity int) int
- EndCursor func(childComplexity int) int
}
Query struct {
@@ -236,38 +238,38 @@ type ComplexityRoot struct {
Repository struct {
AllBugs func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
- Bug func(childComplexity int, prefix string) int
AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
+ Bug func(childComplexity int, prefix string) int
Identity func(childComplexity int, prefix string) int
UserIdentity func(childComplexity int) int
}
SetStatusOperation struct {
- Hash func(childComplexity int) int
Author func(childComplexity int) int
Date func(childComplexity int) int
+ Hash func(childComplexity int) int
Status func(childComplexity int) int
}
SetStatusTimelineItem struct {
- Hash func(childComplexity int) int
Author func(childComplexity int) int
Date func(childComplexity int) int
+ Hash func(childComplexity int) int
Status func(childComplexity int) int
}
SetTitleOperation struct {
- Hash func(childComplexity int) int
Author func(childComplexity int) int
Date func(childComplexity int) int
+ Hash func(childComplexity int) int
Title func(childComplexity int) int
Was func(childComplexity int) int
}
SetTitleTimelineItem struct {
- Hash func(childComplexity int) int
Author func(childComplexity int) int
Date func(childComplexity int) int
+ Hash func(childComplexity int) int
Title func(childComplexity int) int
Was func(childComplexity int) int
}
@@ -286,34 +288,34 @@ type ComplexityRoot struct {
}
type AddCommentOperationResolver interface {
- Date(ctx context.Context, obj *bug.AddCommentOperation) (time.Time, error)
+ Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
}
type AddCommentTimelineItemResolver interface {
- CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (time.Time, error)
- LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (time.Time, error)
+ CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
+ LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
}
type BugResolver interface {
Status(ctx context.Context, obj *bug.Snapshot) (models.Status, error)
- LastEdit(ctx context.Context, obj *bug.Snapshot) (time.Time, error)
- Actors(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.IdentityConnection, error)
- Participants(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.IdentityConnection, error)
- Comments(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.CommentConnection, error)
- Timeline(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.TimelineItemConnection, error)
- Operations(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.OperationConnection, error)
+ LastEdit(ctx context.Context, obj *bug.Snapshot) (*time.Time, error)
+ Actors(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
+ Participants(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
+ Comments(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
+ Timeline(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
+ Operations(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
}
type CommentHistoryStepResolver interface {
- Date(ctx context.Context, obj *bug.CommentHistoryStep) (time.Time, error)
+ Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
}
type CreateOperationResolver interface {
- Date(ctx context.Context, obj *bug.CreateOperation) (time.Time, error)
+ Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
}
type CreateTimelineItemResolver interface {
- CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (time.Time, error)
- LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (time.Time, error)
+ CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
+ LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
}
type EditCommentOperationResolver interface {
- Date(ctx context.Context, obj *bug.EditCommentOperation) (time.Time, error)
+ Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
}
type IdentityResolver interface {
ID(ctx context.Context, obj *identity.Interface) (string, error)
@@ -326,2060 +328,3809 @@ type IdentityResolver interface {
IsProtected(ctx context.Context, obj *identity.Interface) (bool, error)
}
type LabelChangeOperationResolver interface {
- Date(ctx context.Context, obj *bug.LabelChangeOperation) (time.Time, error)
+ Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
}
type LabelChangeTimelineItemResolver interface {
- Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (time.Time, error)
+ Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
}
type MutationResolver interface {
- NewBug(ctx context.Context, repoRef *string, title string, message string, files []git.Hash) (bug.Snapshot, error)
- AddComment(ctx context.Context, repoRef *string, prefix string, message string, files []git.Hash) (bug.Snapshot, error)
- ChangeLabels(ctx context.Context, repoRef *string, prefix string, added []string, removed []string) (bug.Snapshot, error)
- Open(ctx context.Context, repoRef *string, prefix string) (bug.Snapshot, error)
- Close(ctx context.Context, repoRef *string, prefix string) (bug.Snapshot, error)
- SetTitle(ctx context.Context, repoRef *string, prefix string, title string) (bug.Snapshot, error)
- Commit(ctx context.Context, repoRef *string, prefix string) (bug.Snapshot, error)
+ NewBug(ctx context.Context, repoRef *string, title string, message string, files []git.Hash) (*bug.Snapshot, error)
+ AddComment(ctx context.Context, repoRef *string, prefix string, message string, files []git.Hash) (*bug.Snapshot, error)
+ ChangeLabels(ctx context.Context, repoRef *string, prefix string, added []string, removed []string) (*bug.Snapshot, error)
+ Open(ctx context.Context, repoRef *string, prefix string) (*bug.Snapshot, error)
+ Close(ctx context.Context, repoRef *string, prefix string) (*bug.Snapshot, error)
+ SetTitle(ctx context.Context, repoRef *string, prefix string, title string) (*bug.Snapshot, error)
+ Commit(ctx context.Context, repoRef *string, prefix string) (*bug.Snapshot, error)
}
type QueryResolver interface {
DefaultRepository(ctx context.Context) (*models.Repository, error)
Repository(ctx context.Context, id string) (*models.Repository, error)
}
type RepositoryResolver interface {
- AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (models.BugConnection, error)
+ AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
Bug(ctx context.Context, obj *models.Repository, prefix string) (*bug.Snapshot, error)
- AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (models.IdentityConnection, error)
- Identity(ctx context.Context, obj *models.Repository, prefix string) (*identity.Interface, error)
- UserIdentity(ctx context.Context, obj *models.Repository) (*identity.Interface, error)
+ AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
+ Identity(ctx context.Context, obj *models.Repository, prefix string) (identity.Interface, error)
+ UserIdentity(ctx context.Context, obj *models.Repository) (identity.Interface, error)
}
type SetStatusOperationResolver interface {
- Date(ctx context.Context, obj *bug.SetStatusOperation) (time.Time, error)
+ Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
}
type SetStatusTimelineItemResolver interface {
- Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (time.Time, error)
+ Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
}
type SetTitleOperationResolver interface {
- Date(ctx context.Context, obj *bug.SetTitleOperation) (time.Time, error)
+ Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
}
type SetTitleTimelineItemResolver interface {
- Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (time.Time, error)
+ Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
}
-func field_Bug_actors_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 *string
- if tmp, ok := rawArgs["after"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg0 = &ptr1
- }
+type executableSchema struct {
+ resolvers ResolverRoot
+ directives DirectiveRoot
+ complexity ComplexityRoot
+}
- if err != nil {
- return nil, err
- }
- }
- args["after"] = arg0
- var arg1 *string
- if tmp, ok := rawArgs["before"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg1 = &ptr1
- }
+func (e *executableSchema) Schema() *ast.Schema {
+ return parsedSchema
+}
- if err != nil {
- return nil, err
- }
- }
- args["before"] = arg1
- var arg2 *int
- if tmp, ok := rawArgs["first"]; ok {
- var err error
- var ptr1 int
- if tmp != nil {
- ptr1, err = graphql.UnmarshalInt(tmp)
- arg2 = &ptr1
+func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
+ ec := executionContext{nil, e}
+ _ = ec
+ switch typeName + "." + field {
+
+ case "AddCommentOperation.Author":
+ if e.complexity.AddCommentOperation.Author == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.AddCommentOperation.Author(childComplexity), true
+
+ case "AddCommentOperation.Date":
+ if e.complexity.AddCommentOperation.Date == nil {
+ break
}
- }
- args["first"] = arg2
- var arg3 *int
- if tmp, ok := rawArgs["last"]; ok {
- var err error
- var ptr1 int
- if tmp != nil {
- ptr1, err = graphql.UnmarshalInt(tmp)
- arg3 = &ptr1
+
+ return e.complexity.AddCommentOperation.Date(childComplexity), true
+
+ case "AddCommentOperation.Files":
+ if e.complexity.AddCommentOperation.Files == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.AddCommentOperation.Files(childComplexity), true
+
+ case "AddCommentOperation.Hash":
+ if e.complexity.AddCommentOperation.Hash == nil {
+ break
}
- }
- args["last"] = arg3
- return args, nil
-}
+ return e.complexity.AddCommentOperation.Hash(childComplexity), true
-func field_Bug_participants_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 *string
- if tmp, ok := rawArgs["after"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg0 = &ptr1
+ case "AddCommentOperation.Message":
+ if e.complexity.AddCommentOperation.Message == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.AddCommentOperation.Message(childComplexity), true
+
+ case "AddCommentTimelineItem.Author":
+ if e.complexity.AddCommentTimelineItem.Author == nil {
+ break
}
- }
- args["after"] = arg0
- var arg1 *string
- if tmp, ok := rawArgs["before"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg1 = &ptr1
+
+ return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
+
+ case "AddCommentTimelineItem.CreatedAt":
+ if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
+
+ case "AddCommentTimelineItem.Edited":
+ if e.complexity.AddCommentTimelineItem.Edited == nil {
+ break
}
- }
- args["before"] = arg1
- var arg2 *int
- if tmp, ok := rawArgs["first"]; ok {
- var err error
- var ptr1 int
- if tmp != nil {
- ptr1, err = graphql.UnmarshalInt(tmp)
- arg2 = &ptr1
+
+ return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
+
+ case "AddCommentTimelineItem.Files":
+ if e.complexity.AddCommentTimelineItem.Files == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
+
+ case "AddCommentTimelineItem.Hash":
+ if e.complexity.AddCommentTimelineItem.Hash == nil {
+ break
}
- }
- args["first"] = arg2
- var arg3 *int
- if tmp, ok := rawArgs["last"]; ok {
- var err error
- var ptr1 int
- if tmp != nil {
- ptr1, err = graphql.UnmarshalInt(tmp)
- arg3 = &ptr1
+
+ return e.complexity.AddCommentTimelineItem.Hash(childComplexity), true
+
+ case "AddCommentTimelineItem.History":
+ if e.complexity.AddCommentTimelineItem.History == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.AddCommentTimelineItem.History(childComplexity), true
+
+ case "AddCommentTimelineItem.LastEdit":
+ if e.complexity.AddCommentTimelineItem.LastEdit == nil {
+ break
}
- }
- args["last"] = arg3
- return args, nil
-}
+ return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
-func field_Bug_comments_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 *string
- if tmp, ok := rawArgs["after"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg0 = &ptr1
+ case "AddCommentTimelineItem.Message":
+ if e.complexity.AddCommentTimelineItem.Message == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
+
+ case "AddCommentTimelineItem.MessageIsEmpty":
+ if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
+ break
}
- }
- args["after"] = arg0
- var arg1 *string
- if tmp, ok := rawArgs["before"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg1 = &ptr1
+
+ return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
+
+ case "Bug.Actors":
+ if e.complexity.Bug.Actors == nil {
+ break
}
+ args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
if err != nil {
- return nil, err
- }
- }
- args["before"] = arg1
- var arg2 *int
- if tmp, ok := rawArgs["first"]; ok {
- var err error
- var ptr1 int
- if tmp != nil {
- ptr1, err = graphql.UnmarshalInt(tmp)
- arg2 = &ptr1
+ return 0, false
}
- if err != nil {
- return nil, err
+ 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
}
- }
- args["first"] = arg2
- var arg3 *int
- if tmp, ok := rawArgs["last"]; ok {
- var err error
- var ptr1 int
- if tmp != nil {
- ptr1, err = graphql.UnmarshalInt(tmp)
- arg3 = &ptr1
+
+ return e.complexity.Bug.Author(childComplexity), true
+
+ case "Bug.Comments":
+ if e.complexity.Bug.Comments == nil {
+ break
}
+ args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
if err != nil {
- return nil, err
+ return 0, false
}
- }
- args["last"] = arg3
- return args, nil
-}
+ return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
-func field_Bug_timeline_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 *string
- if tmp, ok := rawArgs["after"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg0 = &ptr1
+ case "Bug.CreatedAt":
+ if e.complexity.Bug.CreatedAt == nil {
+ break
}
- if err != nil {
- return nil, err
- }
- }
- args["after"] = arg0
- var arg1 *string
- if tmp, ok := rawArgs["before"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg1 = &ptr1
+ return e.complexity.Bug.CreatedAt(childComplexity), true
+
+ case "Bug.HumanId":
+ if e.complexity.Bug.HumanId == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.Bug.HumanId(childComplexity), true
+
+ case "Bug.Id":
+ if e.complexity.Bug.Id == nil {
+ break
}
- }
- args["before"] = arg1
- var arg2 *int
- if tmp, ok := rawArgs["first"]; ok {
- var err error
- var ptr1 int
- if tmp != nil {
- ptr1, err = graphql.UnmarshalInt(tmp)
- arg2 = &ptr1
+
+ return e.complexity.Bug.Id(childComplexity), true
+
+ case "Bug.Labels":
+ if e.complexity.Bug.Labels == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.Bug.Labels(childComplexity), true
+
+ case "Bug.LastEdit":
+ if e.complexity.Bug.LastEdit == nil {
+ break
}
- }
- args["first"] = arg2
- var arg3 *int
- if tmp, ok := rawArgs["last"]; ok {
- var err error
- var ptr1 int
- if tmp != nil {
- ptr1, err = graphql.UnmarshalInt(tmp)
- arg3 = &ptr1
+
+ return e.complexity.Bug.LastEdit(childComplexity), true
+
+ case "Bug.Operations":
+ if e.complexity.Bug.Operations == nil {
+ break
}
+ args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
if err != nil {
- return nil, err
+ return 0, false
}
- }
- args["last"] = arg3
- return args, nil
-}
+ return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
-func field_Bug_operations_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 *string
- if tmp, ok := rawArgs["after"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg0 = &ptr1
+ case "Bug.Participants":
+ if e.complexity.Bug.Participants == nil {
+ break
}
+ args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
if err != nil {
- return nil, err
- }
- }
- args["after"] = arg0
- var arg1 *string
- if tmp, ok := rawArgs["before"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg1 = &ptr1
+ return 0, false
}
- if err != nil {
- return nil, err
+ return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
+
+ case "Bug.Status":
+ if e.complexity.Bug.Status == nil {
+ break
}
- }
- args["before"] = arg1
- var arg2 *int
- if tmp, ok := rawArgs["first"]; ok {
- var err error
- var ptr1 int
- if tmp != nil {
- ptr1, err = graphql.UnmarshalInt(tmp)
- arg2 = &ptr1
+
+ return e.complexity.Bug.Status(childComplexity), true
+
+ case "Bug.Timeline":
+ if e.complexity.Bug.Timeline == nil {
+ break
}
+ args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
if err != nil {
- return nil, err
- }
- }
- args["first"] = arg2
- var arg3 *int
- if tmp, ok := rawArgs["last"]; ok {
- var err error
- var ptr1 int
- if tmp != nil {
- ptr1, err = graphql.UnmarshalInt(tmp)
- arg3 = &ptr1
+ return 0, false
}
- if err != nil {
- return nil, err
+ return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
+
+ case "Bug.Title":
+ if e.complexity.Bug.Title == nil {
+ break
}
- }
- args["last"] = arg3
- return args, nil
-}
+ return e.complexity.Bug.Title(childComplexity), true
-func field_Mutation_newBug_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 *string
- if tmp, ok := rawArgs["repoRef"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg0 = &ptr1
+ case "BugConnection.Edges":
+ if e.complexity.BugConnection.Edges == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.BugConnection.Edges(childComplexity), true
+
+ case "BugConnection.Nodes":
+ if e.complexity.BugConnection.Nodes == nil {
+ break
}
- }
- args["repoRef"] = arg0
- var arg1 string
- if tmp, ok := rawArgs["title"]; ok {
- var err error
- arg1, err = graphql.UnmarshalString(tmp)
- if err != nil {
- return nil, err
+
+ return e.complexity.BugConnection.Nodes(childComplexity), true
+
+ case "BugConnection.PageInfo":
+ if e.complexity.BugConnection.PageInfo == nil {
+ break
}
- }
- args["title"] = arg1
- var arg2 string
- if tmp, ok := rawArgs["message"]; ok {
- var err error
- arg2, err = graphql.UnmarshalString(tmp)
- if err != nil {
- return nil, err
+
+ return e.complexity.BugConnection.PageInfo(childComplexity), true
+
+ case "BugConnection.TotalCount":
+ if e.complexity.BugConnection.TotalCount == nil {
+ break
}
- }
- args["message"] = arg2
- var arg3 []git.Hash
- if tmp, ok := rawArgs["files"]; ok {
- var err error
- var rawIf1 []interface{}
- if tmp != nil {
- if tmp1, ok := tmp.([]interface{}); ok {
- rawIf1 = tmp1
- } else {
- rawIf1 = []interface{}{tmp}
- }
+
+ return e.complexity.BugConnection.TotalCount(childComplexity), true
+
+ case "BugEdge.Cursor":
+ if e.complexity.BugEdge.Cursor == nil {
+ break
}
- arg3 = make([]git.Hash, len(rawIf1))
- for idx1 := range rawIf1 {
- err = (&arg3[idx1]).UnmarshalGQL(rawIf1[idx1])
+
+ return e.complexity.BugEdge.Cursor(childComplexity), true
+
+ case "BugEdge.Node":
+ if e.complexity.BugEdge.Node == nil {
+ break
}
- if err != nil {
- return nil, err
+
+ return e.complexity.BugEdge.Node(childComplexity), true
+
+ case "Comment.Author":
+ if e.complexity.Comment.Author == nil {
+ break
}
- }
- args["files"] = arg3
- return args, nil
-}
+ return e.complexity.Comment.Author(childComplexity), true
-func field_Mutation_addComment_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 *string
- if tmp, ok := rawArgs["repoRef"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg0 = &ptr1
+ case "Comment.Files":
+ if e.complexity.Comment.Files == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.Comment.Files(childComplexity), true
+
+ case "Comment.Message":
+ if e.complexity.Comment.Message == nil {
+ break
}
- }
- args["repoRef"] = arg0
- var arg1 string
- if tmp, ok := rawArgs["prefix"]; ok {
- var err error
- arg1, err = graphql.UnmarshalString(tmp)
- if err != nil {
- return nil, err
+
+ return e.complexity.Comment.Message(childComplexity), true
+
+ case "CommentConnection.Edges":
+ if e.complexity.CommentConnection.Edges == nil {
+ break
}
- }
- args["prefix"] = arg1
- var arg2 string
- if tmp, ok := rawArgs["message"]; ok {
- var err error
- arg2, err = graphql.UnmarshalString(tmp)
- if err != nil {
- return nil, err
+
+ return e.complexity.CommentConnection.Edges(childComplexity), true
+
+ case "CommentConnection.Nodes":
+ if e.complexity.CommentConnection.Nodes == nil {
+ break
}
- }
- args["message"] = arg2
- var arg3 []git.Hash
- if tmp, ok := rawArgs["files"]; ok {
- var err error
- var rawIf1 []interface{}
- if tmp != nil {
- if tmp1, ok := tmp.([]interface{}); ok {
- rawIf1 = tmp1
- } else {
- rawIf1 = []interface{}{tmp}
- }
+
+ return e.complexity.CommentConnection.Nodes(childComplexity), true
+
+ case "CommentConnection.PageInfo":
+ if e.complexity.CommentConnection.PageInfo == nil {
+ break
}
- arg3 = make([]git.Hash, len(rawIf1))
- for idx1 := range rawIf1 {
- err = (&arg3[idx1]).UnmarshalGQL(rawIf1[idx1])
+
+ return e.complexity.CommentConnection.PageInfo(childComplexity), true
+
+ case "CommentConnection.TotalCount":
+ if e.complexity.CommentConnection.TotalCount == nil {
+ break
}
- if err != nil {
- return nil, err
+
+ return e.complexity.CommentConnection.TotalCount(childComplexity), true
+
+ case "CommentEdge.Cursor":
+ if e.complexity.CommentEdge.Cursor == nil {
+ break
}
- }
- args["files"] = arg3
- return args, nil
-}
+ return e.complexity.CommentEdge.Cursor(childComplexity), true
-func field_Mutation_changeLabels_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 *string
- if tmp, ok := rawArgs["repoRef"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg0 = &ptr1
+ case "CommentEdge.Node":
+ if e.complexity.CommentEdge.Node == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.CommentEdge.Node(childComplexity), true
+
+ case "CommentHistoryStep.Date":
+ if e.complexity.CommentHistoryStep.Date == nil {
+ break
}
- }
- args["repoRef"] = arg0
- var arg1 string
- if tmp, ok := rawArgs["prefix"]; ok {
- var err error
- arg1, err = graphql.UnmarshalString(tmp)
- if err != nil {
- return nil, err
+
+ return e.complexity.CommentHistoryStep.Date(childComplexity), true
+
+ case "CommentHistoryStep.Message":
+ if e.complexity.CommentHistoryStep.Message == nil {
+ break
}
- }
- args["prefix"] = arg1
- var arg2 []string
- if tmp, ok := rawArgs["added"]; ok {
- var err error
- var rawIf1 []interface{}
- if tmp != nil {
- if tmp1, ok := tmp.([]interface{}); ok {
- rawIf1 = tmp1
- } else {
- rawIf1 = []interface{}{tmp}
- }
+
+ return e.complexity.CommentHistoryStep.Message(childComplexity), true
+
+ case "CreateOperation.Author":
+ if e.complexity.CreateOperation.Author == nil {
+ break
}
- arg2 = make([]string, len(rawIf1))
- for idx1 := range rawIf1 {
- arg2[idx1], err = graphql.UnmarshalString(rawIf1[idx1])
+
+ return e.complexity.CreateOperation.Author(childComplexity), true
+
+ case "CreateOperation.Date":
+ if e.complexity.CreateOperation.Date == nil {
+ break
}
- if err != nil {
- return nil, err
- }
- }
- args["added"] = arg2
- var arg3 []string
- if tmp, ok := rawArgs["removed"]; ok {
- var err error
- var rawIf1 []interface{}
- if tmp != nil {
- if tmp1, ok := tmp.([]interface{}); ok {
- rawIf1 = tmp1
- } else {
- rawIf1 = []interface{}{tmp}
- }
- }
- arg3 = make([]string, len(rawIf1))
- for idx1 := range rawIf1 {
- arg3[idx1], err = graphql.UnmarshalString(rawIf1[idx1])
+
+ return e.complexity.CreateOperation.Date(childComplexity), true
+
+ case "CreateOperation.Files":
+ if e.complexity.CreateOperation.Files == nil {
+ break
}
- if err != nil {
- return nil, err
+
+ return e.complexity.CreateOperation.Files(childComplexity), true
+
+ case "CreateOperation.Hash":
+ if e.complexity.CreateOperation.Hash == nil {
+ break
}
- }
- args["removed"] = arg3
- return args, nil
-}
+ return e.complexity.CreateOperation.Hash(childComplexity), true
-func field_Mutation_open_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 *string
- if tmp, ok := rawArgs["repoRef"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg0 = &ptr1
+ case "CreateOperation.Message":
+ if e.complexity.CreateOperation.Message == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.CreateOperation.Message(childComplexity), true
+
+ case "CreateOperation.Title":
+ if e.complexity.CreateOperation.Title == nil {
+ break
}
- }
- args["repoRef"] = arg0
- var arg1 string
- if tmp, ok := rawArgs["prefix"]; ok {
- var err error
- arg1, err = graphql.UnmarshalString(tmp)
- if err != nil {
- return nil, err
+
+ return e.complexity.CreateOperation.Title(childComplexity), true
+
+ case "CreateTimelineItem.Author":
+ if e.complexity.CreateTimelineItem.Author == nil {
+ break
}
- }
- args["prefix"] = arg1
- return args, nil
-}
+ return e.complexity.CreateTimelineItem.Author(childComplexity), true
-func field_Mutation_close_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 *string
- if tmp, ok := rawArgs["repoRef"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg0 = &ptr1
+ case "CreateTimelineItem.CreatedAt":
+ if e.complexity.CreateTimelineItem.CreatedAt == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
+
+ case "CreateTimelineItem.Edited":
+ if e.complexity.CreateTimelineItem.Edited == nil {
+ break
}
- }
- args["repoRef"] = arg0
- var arg1 string
- if tmp, ok := rawArgs["prefix"]; ok {
- var err error
- arg1, err = graphql.UnmarshalString(tmp)
- if err != nil {
- return nil, err
+
+ return e.complexity.CreateTimelineItem.Edited(childComplexity), true
+
+ case "CreateTimelineItem.Files":
+ if e.complexity.CreateTimelineItem.Files == nil {
+ break
}
- }
- args["prefix"] = arg1
- return args, nil
-}
+ return e.complexity.CreateTimelineItem.Files(childComplexity), true
-func field_Mutation_setTitle_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 *string
- if tmp, ok := rawArgs["repoRef"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg0 = &ptr1
+ case "CreateTimelineItem.Hash":
+ if e.complexity.CreateTimelineItem.Hash == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.CreateTimelineItem.Hash(childComplexity), true
+
+ case "CreateTimelineItem.History":
+ if e.complexity.CreateTimelineItem.History == nil {
+ break
}
- }
- args["repoRef"] = arg0
- var arg1 string
- if tmp, ok := rawArgs["prefix"]; ok {
- var err error
- arg1, err = graphql.UnmarshalString(tmp)
- if err != nil {
- return nil, err
+
+ return e.complexity.CreateTimelineItem.History(childComplexity), true
+
+ case "CreateTimelineItem.LastEdit":
+ if e.complexity.CreateTimelineItem.LastEdit == nil {
+ break
}
- }
- args["prefix"] = arg1
- var arg2 string
- if tmp, ok := rawArgs["title"]; ok {
- var err error
- arg2, err = graphql.UnmarshalString(tmp)
- if err != nil {
- return nil, err
+
+ return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
+
+ case "CreateTimelineItem.Message":
+ if e.complexity.CreateTimelineItem.Message == nil {
+ break
}
- }
- args["title"] = arg2
- return args, nil
-}
+ return e.complexity.CreateTimelineItem.Message(childComplexity), true
-func field_Mutation_commit_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 *string
- if tmp, ok := rawArgs["repoRef"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg0 = &ptr1
+ case "CreateTimelineItem.MessageIsEmpty":
+ if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
+
+ case "EditCommentOperation.Author":
+ if e.complexity.EditCommentOperation.Author == nil {
+ break
}
- }
- args["repoRef"] = arg0
- var arg1 string
- if tmp, ok := rawArgs["prefix"]; ok {
- var err error
- arg1, err = graphql.UnmarshalString(tmp)
- if err != nil {
- return nil, err
+
+ return e.complexity.EditCommentOperation.Author(childComplexity), true
+
+ case "EditCommentOperation.Date":
+ if e.complexity.EditCommentOperation.Date == nil {
+ break
}
- }
- args["prefix"] = arg1
- return args, nil
-}
+ return e.complexity.EditCommentOperation.Date(childComplexity), true
-func field_Query_repository_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 string
- if tmp, ok := rawArgs["id"]; ok {
- var err error
- arg0, err = graphql.UnmarshalString(tmp)
- if err != nil {
- return nil, err
+ case "EditCommentOperation.Files":
+ if e.complexity.EditCommentOperation.Files == nil {
+ break
}
- }
- args["id"] = arg0
- return args, nil
-}
+ return e.complexity.EditCommentOperation.Files(childComplexity), true
-func field_Query___type_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 string
- if tmp, ok := rawArgs["name"]; ok {
- var err error
- arg0, err = graphql.UnmarshalString(tmp)
- if err != nil {
- return nil, err
+ case "EditCommentOperation.Hash":
+ if e.complexity.EditCommentOperation.Hash == nil {
+ break
}
- }
- args["name"] = arg0
- return args, nil
-}
+ return e.complexity.EditCommentOperation.Hash(childComplexity), true
-func field_Repository_allBugs_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 *string
- if tmp, ok := rawArgs["after"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg0 = &ptr1
+ case "EditCommentOperation.Message":
+ if e.complexity.EditCommentOperation.Message == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.EditCommentOperation.Message(childComplexity), true
+
+ case "EditCommentOperation.Target":
+ if e.complexity.EditCommentOperation.Target == nil {
+ break
}
- }
- args["after"] = arg0
- var arg1 *string
- if tmp, ok := rawArgs["before"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg1 = &ptr1
+
+ return e.complexity.EditCommentOperation.Target(childComplexity), true
+
+ case "Identity.AvatarURL":
+ if e.complexity.Identity.AvatarURL == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.Identity.AvatarURL(childComplexity), true
+
+ case "Identity.DisplayName":
+ if e.complexity.Identity.DisplayName == nil {
+ break
}
- }
- args["before"] = arg1
- var arg2 *int
- if tmp, ok := rawArgs["first"]; ok {
- var err error
- var ptr1 int
- if tmp != nil {
- ptr1, err = graphql.UnmarshalInt(tmp)
- arg2 = &ptr1
+
+ return e.complexity.Identity.DisplayName(childComplexity), true
+
+ case "Identity.Email":
+ if e.complexity.Identity.Email == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.Identity.Email(childComplexity), true
+
+ case "Identity.HumanID":
+ if e.complexity.Identity.HumanID == nil {
+ break
}
- }
- args["first"] = arg2
- var arg3 *int
- if tmp, ok := rawArgs["last"]; ok {
- var err error
- var ptr1 int
- if tmp != nil {
- ptr1, err = graphql.UnmarshalInt(tmp)
- arg3 = &ptr1
+
+ return e.complexity.Identity.HumanID(childComplexity), true
+
+ case "Identity.ID":
+ if e.complexity.Identity.ID == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.Identity.ID(childComplexity), true
+
+ case "Identity.IsProtected":
+ if e.complexity.Identity.IsProtected == nil {
+ break
}
- }
- args["last"] = arg3
- var arg4 *string
- if tmp, ok := rawArgs["query"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg4 = &ptr1
+
+ return e.complexity.Identity.IsProtected(childComplexity), true
+
+ case "Identity.Login":
+ if e.complexity.Identity.Login == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.Identity.Login(childComplexity), true
+
+ case "Identity.Name":
+ if e.complexity.Identity.Name == nil {
+ break
}
- }
- args["query"] = arg4
- return args, nil
-}
+ return e.complexity.Identity.Name(childComplexity), true
-func field_Repository_bug_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 string
- if tmp, ok := rawArgs["prefix"]; ok {
- var err error
- arg0, err = graphql.UnmarshalString(tmp)
- if err != nil {
- return nil, err
+ case "IdentityConnection.Edges":
+ if e.complexity.IdentityConnection.Edges == nil {
+ break
}
- }
- args["prefix"] = arg0
- return args, nil
-}
+ return e.complexity.IdentityConnection.Edges(childComplexity), true
-func field_Repository_allIdentities_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 *string
- if tmp, ok := rawArgs["after"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg0 = &ptr1
+ case "IdentityConnection.Nodes":
+ if e.complexity.IdentityConnection.Nodes == nil {
+ break
}
- if err != nil {
- return nil, err
- }
- }
- args["after"] = arg0
- var arg1 *string
- if tmp, ok := rawArgs["before"]; ok {
- var err error
- var ptr1 string
- if tmp != nil {
- ptr1, err = graphql.UnmarshalString(tmp)
- arg1 = &ptr1
- }
+ return e.complexity.IdentityConnection.Nodes(childComplexity), true
- if err != nil {
- return nil, err
+ case "IdentityConnection.PageInfo":
+ if e.complexity.IdentityConnection.PageInfo == nil {
+ break
}
- }
- args["before"] = arg1
- var arg2 *int
- if tmp, ok := rawArgs["first"]; ok {
- var err error
- var ptr1 int
- if tmp != nil {
- ptr1, err = graphql.UnmarshalInt(tmp)
- arg2 = &ptr1
+
+ return e.complexity.IdentityConnection.PageInfo(childComplexity), true
+
+ case "IdentityConnection.TotalCount":
+ if e.complexity.IdentityConnection.TotalCount == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.IdentityConnection.TotalCount(childComplexity), true
+
+ case "IdentityEdge.Cursor":
+ if e.complexity.IdentityEdge.Cursor == nil {
+ break
}
- }
- args["first"] = arg2
- var arg3 *int
- if tmp, ok := rawArgs["last"]; ok {
- var err error
- var ptr1 int
- if tmp != nil {
- ptr1, err = graphql.UnmarshalInt(tmp)
- arg3 = &ptr1
+
+ return e.complexity.IdentityEdge.Cursor(childComplexity), true
+
+ case "IdentityEdge.Node":
+ if e.complexity.IdentityEdge.Node == nil {
+ break
}
- if err != nil {
- return nil, err
+ return e.complexity.IdentityEdge.Node(childComplexity), true
+
+ case "LabelChangeOperation.Added":
+ if e.complexity.LabelChangeOperation.Added == nil {
+ break
}
- }
- args["last"] = arg3
- return args, nil
-}
+ return e.complexity.LabelChangeOperation.Added(childComplexity), true
-func field_Repository_identity_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 string
- if tmp, ok := rawArgs["prefix"]; ok {
- var err error
- arg0, err = graphql.UnmarshalString(tmp)
- if err != nil {
- return nil, err
+ case "LabelChangeOperation.Author":
+ if e.complexity.LabelChangeOperation.Author == nil {
+ break
}
- }
- args["prefix"] = arg0
- return args, nil
-}
+ return e.complexity.LabelChangeOperation.Author(childComplexity), true
-func field___Type_fields_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 bool
- if tmp, ok := rawArgs["includeDeprecated"]; ok {
- var err error
- arg0, err = graphql.UnmarshalBoolean(tmp)
- if err != nil {
- return nil, err
+ case "LabelChangeOperation.Date":
+ if e.complexity.LabelChangeOperation.Date == nil {
+ break
}
- }
- args["includeDeprecated"] = arg0
- return args, nil
-}
+ return e.complexity.LabelChangeOperation.Date(childComplexity), true
-func field___Type_enumValues_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
- args := map[string]interface{}{}
- var arg0 bool
- if tmp, ok := rawArgs["includeDeprecated"]; ok {
- var err error
- arg0, err = graphql.UnmarshalBoolean(tmp)
- if err != nil {
- return nil, err
+ case "LabelChangeOperation.Hash":
+ if e.complexity.LabelChangeOperation.Hash == nil {
+ break
}
- }
- args["includeDeprecated"] = arg0
- return args, nil
-}
+ return e.complexity.LabelChangeOperation.Hash(childComplexity), true
-type executableSchema struct {
- resolvers ResolverRoot
- directives DirectiveRoot
- complexity ComplexityRoot
-}
+ case "LabelChangeOperation.Removed":
+ if e.complexity.LabelChangeOperation.Removed == nil {
+ break
+ }
-func (e *executableSchema) Schema() *ast.Schema {
- return parsedSchema
-}
+ return e.complexity.LabelChangeOperation.Removed(childComplexity), true
-func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
- switch typeName + "." + field {
+ case "LabelChangeTimelineItem.Added":
+ if e.complexity.LabelChangeTimelineItem.Added == nil {
+ break
+ }
- case "AddCommentOperation.hash":
- if e.complexity.AddCommentOperation.Hash == nil {
+ return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
+
+ case "LabelChangeTimelineItem.Author":
+ if e.complexity.LabelChangeTimelineItem.Author == nil {
break
}
- return e.complexity.AddCommentOperation.Hash(childComplexity), true
+ return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
- case "AddCommentOperation.author":
- if e.complexity.AddCommentOperation.Author == nil {
+ case "LabelChangeTimelineItem.Date":
+ if e.complexity.LabelChangeTimelineItem.Date == nil {
break
}
- return e.complexity.AddCommentOperation.Author(childComplexity), true
+ return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
- case "AddCommentOperation.date":
- if e.complexity.AddCommentOperation.Date == nil {
+ case "LabelChangeTimelineItem.Hash":
+ if e.complexity.LabelChangeTimelineItem.Hash == nil {
break
}
- return e.complexity.AddCommentOperation.Date(childComplexity), true
+ return e.complexity.LabelChangeTimelineItem.Hash(childComplexity), true
- case "AddCommentOperation.message":
- if e.complexity.AddCommentOperation.Message == nil {
+ case "LabelChangeTimelineItem.Removed":
+ if e.complexity.LabelChangeTimelineItem.Removed == nil {
break
}
- return e.complexity.AddCommentOperation.Message(childComplexity), true
+ return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
- case "AddCommentOperation.files":
- if e.complexity.AddCommentOperation.Files == nil {
+ case "Mutation.AddComment":
+ if e.complexity.Mutation.AddComment == nil {
break
}
- return e.complexity.AddCommentOperation.Files(childComplexity), true
+ args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
+ if err != nil {
+ return 0, false
+ }
- case "AddCommentTimelineItem.hash":
- if e.complexity.AddCommentTimelineItem.Hash == nil {
+ return e.complexity.Mutation.AddComment(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["message"].(string), args["files"].([]git.Hash)), true
+
+ case "Mutation.ChangeLabels":
+ if e.complexity.Mutation.ChangeLabels == nil {
break
}
- return e.complexity.AddCommentTimelineItem.Hash(childComplexity), true
+ args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
+ if err != nil {
+ return 0, false
+ }
- case "AddCommentTimelineItem.author":
- if e.complexity.AddCommentTimelineItem.Author == nil {
+ return e.complexity.Mutation.ChangeLabels(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["added"].([]string), args["removed"].([]string)), true
+
+ case "Mutation.Close":
+ if e.complexity.Mutation.Close == nil {
break
}
- return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
+ args, err := ec.field_Mutation_close_args(context.TODO(), rawArgs)
+ if err != nil {
+ return 0, false
+ }
- case "AddCommentTimelineItem.message":
- if e.complexity.AddCommentTimelineItem.Message == nil {
+ return e.complexity.Mutation.Close(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
+
+ case "Mutation.Commit":
+ if e.complexity.Mutation.Commit == nil {
break
}
- return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
+ args, err := ec.field_Mutation_commit_args(context.TODO(), rawArgs)
+ if err != nil {
+ return 0, false
+ }
- case "AddCommentTimelineItem.messageIsEmpty":
- if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
+ return e.complexity.Mutation.Commit(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
+
+ case "Mutation.NewBug":
+ if e.complexity.Mutation.NewBug == nil {
break
}
- return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
+ args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
+ if err != nil {
+ return 0, false
+ }
- case "AddCommentTimelineItem.files":
- if e.complexity.AddCommentTimelineItem.Files == nil {
+ return e.complexity.Mutation.NewBug(childComplexity, args["repoRef"].(*string), args["title"].(string), args["message"].(string), args["files"].([]git.Hash)), true
+
+ case "Mutation.Open":
+ if e.complexity.Mutation.Open == nil {
break
}
- return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
+ args, err := ec.field_Mutation_open_args(context.TODO(), rawArgs)
+ if err != nil {
+ return 0, false
+ }
- case "AddCommentTimelineItem.createdAt":
- if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
+ return e.complexity.Mutation.Open(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
+
+ case "Mutation.SetTitle":
+ if e.complexity.Mutation.SetTitle == nil {
break
}
- return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
+ args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
+ if err != nil {
+ return 0, false
+ }
- case "AddCommentTimelineItem.lastEdit":
- if e.complexity.AddCommentTimelineItem.LastEdit == nil {
+ return e.complexity.Mutation.SetTitle(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["title"].(string)), true
+
+ case "OperationConnection.Edges":
+ if e.complexity.OperationConnection.Edges == nil {
break
}
- return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
+ return e.complexity.OperationConnection.Edges(childComplexity), true
- case "AddCommentTimelineItem.edited":
- if e.complexity.AddCommentTimelineItem.Edited == nil {
+ case "OperationConnection.Nodes":
+ if e.complexity.OperationConnection.Nodes == nil {
break
}
- return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
+ return e.complexity.OperationConnection.Nodes(childComplexity), true
- case "AddCommentTimelineItem.history":
- if e.complexity.AddCommentTimelineItem.History == nil {
+ case "OperationConnection.PageInfo":
+ if e.complexity.OperationConnection.PageInfo == nil {
break
}
- return e.complexity.AddCommentTimelineItem.History(childComplexity), true
+ return e.complexity.OperationConnection.PageInfo(childComplexity), true
- case "Bug.id":
- if e.complexity.Bug.Id == nil {
+ case "OperationConnection.TotalCount":
+ if e.complexity.OperationConnection.TotalCount == nil {
break
}
- return e.complexity.Bug.Id(childComplexity), true
+ return e.complexity.OperationConnection.TotalCount(childComplexity), true
- case "Bug.humanId":
- if e.complexity.Bug.HumanId == nil {
+ case "OperationEdge.Cursor":
+ if e.complexity.OperationEdge.Cursor == nil {
break
}
- return e.complexity.Bug.HumanId(childComplexity), true
+ return e.complexity.OperationEdge.Cursor(childComplexity), true
- case "Bug.status":
- if e.complexity.Bug.Status == nil {
+ case "OperationEdge.Node":
+ if e.complexity.OperationEdge.Node == nil {
break
}
- return e.complexity.Bug.Status(childComplexity), true
+ return e.complexity.OperationEdge.Node(childComplexity), true
- case "Bug.title":
- if e.complexity.Bug.Title == nil {
+ case "PageInfo.EndCursor":
+ if e.complexity.PageInfo.EndCursor == nil {
break
}
- return e.complexity.Bug.Title(childComplexity), true
+ return e.complexity.PageInfo.EndCursor(childComplexity), true
- case "Bug.labels":
- if e.complexity.Bug.Labels == nil {
+ case "PageInfo.HasNextPage":
+ if e.complexity.PageInfo.HasNextPage == nil {
break
}
- return e.complexity.Bug.Labels(childComplexity), true
+ return e.complexity.PageInfo.HasNextPage(childComplexity), true
- case "Bug.author":
- if e.complexity.Bug.Author == nil {
+ case "PageInfo.HasPreviousPage":
+ if e.complexity.PageInfo.HasPreviousPage == nil {
break
}
- return e.complexity.Bug.Author(childComplexity), true
+ return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
- case "Bug.createdAt":
- if e.complexity.Bug.CreatedAt == nil {
+ case "PageInfo.StartCursor":
+ if e.complexity.PageInfo.StartCursor == nil {
break
}
- return e.complexity.Bug.CreatedAt(childComplexity), true
+ return e.complexity.PageInfo.StartCursor(childComplexity), true
- case "Bug.lastEdit":
- if e.complexity.Bug.LastEdit == nil {
+ case "Query.DefaultRepository":
+ if e.complexity.Query.DefaultRepository == nil {
break
}
- return e.complexity.Bug.LastEdit(childComplexity), true
+ return e.complexity.Query.DefaultRepository(childComplexity), true
- case "Bug.actors":
- if e.complexity.Bug.Actors == nil {
+ case "Query.Repository":
+ if e.complexity.Query.Repository == nil {
break
}
- args, err := field_Bug_actors_args(rawArgs)
+ args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
if err != nil {
return 0, false
}
- return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
+ return e.complexity.Query.Repository(childComplexity, args["id"].(string)), true
- case "Bug.participants":
- if e.complexity.Bug.Participants == nil {
+ case "Repository.AllBugs":
+ if e.complexity.Repository.AllBugs == nil {
break
}
- args, err := field_Bug_participants_args(rawArgs)
+ args, err := ec.field_Repository_allBugs_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.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
- case "Bug.comments":
- if e.complexity.Bug.Comments == nil {
+ case "Repository.AllIdentities":
+ if e.complexity.Repository.AllIdentities == nil {
break
}
- args, err := field_Bug_comments_args(rawArgs)
+ args, err := ec.field_Repository_allIdentities_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.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
- case "Bug.timeline":
- if e.complexity.Bug.Timeline == nil {
+ case "Repository.Bug":
+ if e.complexity.Repository.Bug == nil {
break
}
- args, err := field_Bug_timeline_args(rawArgs)
+ args, err := ec.field_Repository_bug_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.Repository.Bug(childComplexity, args["prefix"].(string)), true
- case "Bug.operations":
- if e.complexity.Bug.Operations == nil {
+ case "Repository.Identity":
+ if e.complexity.Repository.Identity == nil {
break
}
- args, err := field_Bug_operations_args(rawArgs)
+ args, err := ec.field_Repository_identity_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.Repository.Identity(childComplexity, args["prefix"].(string)), true
- case "BugConnection.edges":
- if e.complexity.BugConnection.Edges == nil {
+ case "Repository.UserIdentity":
+ if e.complexity.Repository.UserIdentity == nil {
break
}
- return e.complexity.BugConnection.Edges(childComplexity), true
+ return e.complexity.Repository.UserIdentity(childComplexity), true
- case "BugConnection.nodes":
- if e.complexity.BugConnection.Nodes == nil {
+ case "SetStatusOperation.Author":
+ if e.complexity.SetStatusOperation.Author == nil {
break
}
- return e.complexity.BugConnection.Nodes(childComplexity), true
+ return e.complexity.SetStatusOperation.Author(childComplexity), true
- case "BugConnection.pageInfo":
- if e.complexity.BugConnection.PageInfo == nil {
+ case "SetStatusOperation.Date":
+ if e.complexity.SetStatusOperation.Date == nil {
break
}
- return e.complexity.BugConnection.PageInfo(childComplexity), true
+ return e.complexity.SetStatusOperation.Date(childComplexity), true
- case "BugConnection.totalCount":
- if e.complexity.BugConnection.TotalCount == nil {
+ case "SetStatusOperation.Hash":
+ if e.complexity.SetStatusOperation.Hash == nil {
break
}
- return e.complexity.BugConnection.TotalCount(childComplexity), true
+ return e.complexity.SetStatusOperation.Hash(childComplexity), true
- case "BugEdge.cursor":
- if e.complexity.BugEdge.Cursor == nil {
- break
- }
-
- return e.complexity.BugEdge.Cursor(childComplexity), true
-
- case "BugEdge.node":
- if e.complexity.BugEdge.Node == nil {
+ case "SetStatusOperation.Status":
+ if e.complexity.SetStatusOperation.Status == nil {
break
}
- return e.complexity.BugEdge.Node(childComplexity), true
+ return e.complexity.SetStatusOperation.Status(childComplexity), true
- case "Comment.author":
- if e.complexity.Comment.Author == nil {
+ case "SetStatusTimelineItem.Author":
+ if e.complexity.SetStatusTimelineItem.Author == nil {
break
}
- return e.complexity.Comment.Author(childComplexity), true
+ return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
- case "Comment.message":
- if e.complexity.Comment.Message == nil {
+ case "SetStatusTimelineItem.Date":
+ if e.complexity.SetStatusTimelineItem.Date == nil {
break
}
- return e.complexity.Comment.Message(childComplexity), true
+ return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
- case "Comment.files":
- if e.complexity.Comment.Files == nil {
+ case "SetStatusTimelineItem.Hash":
+ if e.complexity.SetStatusTimelineItem.Hash == nil {
break
}
- return e.complexity.Comment.Files(childComplexity), true
+ return e.complexity.SetStatusTimelineItem.Hash(childComplexity), true
- case "CommentConnection.edges":
- if e.complexity.CommentConnection.Edges == nil {
+ case "SetStatusTimelineItem.Status":
+ if e.complexity.SetStatusTimelineItem.Status == nil {
break
}
- return e.complexity.CommentConnection.Edges(childComplexity), true
+ return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
- case "CommentConnection.nodes":
- if e.complexity.CommentConnection.Nodes == nil {
+ case "SetTitleOperation.Author":
+ if e.complexity.SetTitleOperation.Author == nil {
break
}
- return e.complexity.CommentConnection.Nodes(childComplexity), true
+ return e.complexity.SetTitleOperation.Author(childComplexity), true
- case "CommentConnection.pageInfo":
- if e.complexity.CommentConnection.PageInfo == nil {
+ case "SetTitleOperation.Date":
+ if e.complexity.SetTitleOperation.Date == nil {
break
}
- return e.complexity.CommentConnection.PageInfo(childComplexity), true
+ return e.complexity.SetTitleOperation.Date(childComplexity), true
- case "CommentConnection.totalCount":
- if e.complexity.CommentConnection.TotalCount == nil {
+ case "SetTitleOperation.Hash":
+ if e.complexity.SetTitleOperation.Hash == nil {
break
}
- return e.complexity.CommentConnection.TotalCount(childComplexity), true
+ return e.complexity.SetTitleOperation.Hash(childComplexity), true
- case "CommentEdge.cursor":
- if e.complexity.CommentEdge.Cursor == nil {
+ case "SetTitleOperation.Title":
+ if e.complexity.SetTitleOperation.Title == nil {
break
}
- return e.complexity.CommentEdge.Cursor(childComplexity), true
+ return e.complexity.SetTitleOperation.Title(childComplexity), true
- case "CommentEdge.node":
- if e.complexity.CommentEdge.Node == nil {
+ case "SetTitleOperation.Was":
+ if e.complexity.SetTitleOperation.Was == nil {
break
}
- return e.complexity.CommentEdge.Node(childComplexity), true
+ return e.complexity.SetTitleOperation.Was(childComplexity), true
- case "CommentHistoryStep.message":
- if e.complexity.CommentHistoryStep.Message == nil {
+ case "SetTitleTimelineItem.Author":
+ if e.complexity.SetTitleTimelineItem.Author == nil {
break
}
- return e.complexity.CommentHistoryStep.Message(childComplexity), true
+ return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
- case "CommentHistoryStep.date":
- if e.complexity.CommentHistoryStep.Date == nil {
+ case "SetTitleTimelineItem.Date":
+ if e.complexity.SetTitleTimelineItem.Date == nil {
break
}
- return e.complexity.CommentHistoryStep.Date(childComplexity), true
+ return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
- case "CreateOperation.hash":
- if e.complexity.CreateOperation.Hash == nil {
+ case "SetTitleTimelineItem.Hash":
+ if e.complexity.SetTitleTimelineItem.Hash == nil {
break
}
- return e.complexity.CreateOperation.Hash(childComplexity), true
+ return e.complexity.SetTitleTimelineItem.Hash(childComplexity), true
- case "CreateOperation.author":
- if e.complexity.CreateOperation.Author == nil {
+ case "SetTitleTimelineItem.Title":
+ if e.complexity.SetTitleTimelineItem.Title == nil {
break
}
- return e.complexity.CreateOperation.Author(childComplexity), true
+ return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
- case "CreateOperation.date":
- if e.complexity.CreateOperation.Date == nil {
+ case "SetTitleTimelineItem.Was":
+ if e.complexity.SetTitleTimelineItem.Was == nil {
break
}
- return e.complexity.CreateOperation.Date(childComplexity), true
+ return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
- case "CreateOperation.title":
- if e.complexity.CreateOperation.Title == nil {
+ case "TimelineItemConnection.Edges":
+ if e.complexity.TimelineItemConnection.Edges == nil {
break
}
- return e.complexity.CreateOperation.Title(childComplexity), true
+ return e.complexity.TimelineItemConnection.Edges(childComplexity), true
- case "CreateOperation.message":
- if e.complexity.CreateOperation.Message == nil {
+ case "TimelineItemConnection.Nodes":
+ if e.complexity.TimelineItemConnection.Nodes == nil {
break
}
- return e.complexity.CreateOperation.Message(childComplexity), true
+ return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
- case "CreateOperation.files":
- if e.complexity.CreateOperation.Files == nil {
+ case "TimelineItemConnection.PageInfo":
+ if e.complexity.TimelineItemConnection.PageInfo == nil {
break
}
- return e.complexity.CreateOperation.Files(childComplexity), true
+ return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
- case "CreateTimelineItem.hash":
- if e.complexity.CreateTimelineItem.Hash == nil {
+ case "TimelineItemConnection.TotalCount":
+ if e.complexity.TimelineItemConnection.TotalCount == nil {
break
}
- return e.complexity.CreateTimelineItem.Hash(childComplexity), true
+ return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
- case "CreateTimelineItem.author":
- if e.complexity.CreateTimelineItem.Author == nil {
+ case "TimelineItemEdge.Cursor":
+ if e.complexity.TimelineItemEdge.Cursor == nil {
break
}
- return e.complexity.CreateTimelineItem.Author(childComplexity), true
+ return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
- case "CreateTimelineItem.message":
- if e.complexity.CreateTimelineItem.Message == nil {
+ case "TimelineItemEdge.Node":
+ if e.complexity.TimelineItemEdge.Node == nil {
break
}
- return e.complexity.CreateTimelineItem.Message(childComplexity), true
-
- case "CreateTimelineItem.messageIsEmpty":
- if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
- break
- }
+ return e.complexity.TimelineItemEdge.Node(childComplexity), true
- return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
+ }
+ return 0, false
+}
- case "CreateTimelineItem.files":
- if e.complexity.CreateTimelineItem.Files == nil {
- break
- }
+func (e *executableSchema) Query(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
+ ec := executionContext{graphql.GetRequestContext(ctx), e}
- return e.complexity.CreateTimelineItem.Files(childComplexity), true
+ buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
+ data := ec._Query(ctx, op.SelectionSet)
+ var buf bytes.Buffer
+ data.MarshalGQL(&buf)
+ return buf.Bytes()
+ })
- case "CreateTimelineItem.createdAt":
- if e.complexity.CreateTimelineItem.CreatedAt == nil {
- break
- }
+ return &graphql.Response{
+ Data: buf,
+ Errors: ec.Errors,
+ Extensions: ec.Extensions,
+ }
+}
- return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
+func (e *executableSchema) Mutation(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
+ ec := executionContext{graphql.GetRequestContext(ctx), e}
- case "CreateTimelineItem.lastEdit":
- if e.complexity.CreateTimelineItem.LastEdit == nil {
- break
- }
+ buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
+ data := ec._Mutation(ctx, op.SelectionSet)
+ var buf bytes.Buffer
+ data.MarshalGQL(&buf)
+ return buf.Bytes()
+ })
- return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
+ return &graphql.Response{
+ Data: buf,
+ Errors: ec.Errors,
+ Extensions: ec.Extensions,
+ }
+}
- case "CreateTimelineItem.edited":
- if e.complexity.CreateTimelineItem.Edited == nil {
- break
- }
+func (e *executableSchema) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response {
+ return graphql.OneShot(graphql.ErrorResponse(ctx, "subscriptions are not supported"))
+}
- return e.complexity.CreateTimelineItem.Edited(childComplexity), true
+type executionContext struct {
+ *graphql.RequestContext
+ *executableSchema
+}
- case "CreateTimelineItem.history":
- if e.complexity.CreateTimelineItem.History == nil {
- break
+func (ec *executionContext) FieldMiddleware(ctx context.Context, obj interface{}, next graphql.Resolver) (ret interface{}) {
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = nil
}
+ }()
+ res, err := ec.ResolverMiddleware(ctx, next)
+ if err != nil {
+ ec.Error(ctx, err)
+ return nil
+ }
+ return res
+}
- return e.complexity.CreateTimelineItem.History(childComplexity), true
+func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
+ if ec.DisableIntrospection {
+ return nil, errors.New("introspection disabled")
+ }
+ return introspection.WrapSchema(parsedSchema), nil
+}
- case "EditCommentOperation.hash":
- if e.complexity.EditCommentOperation.Hash == nil {
- break
- }
+func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
+ if ec.DisableIntrospection {
+ return nil, errors.New("introspection disabled")
+ }
+ return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
+}
- return e.complexity.EditCommentOperation.Hash(childComplexity), true
+var parsedSchema = gqlparser.MustLoadSchema(
+ &ast.Source{Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
+type Comment implements Authored {
+ """The author of this comment."""
+ author: Identity!
- case "EditCommentOperation.author":
- if e.complexity.EditCommentOperation.Author == nil {
- break
- }
+ """The message of this comment."""
+ message: String!
- return e.complexity.EditCommentOperation.Author(childComplexity), true
+ """All media's hash referenced in this comment"""
+ files: [Hash!]!
+}
- case "EditCommentOperation.date":
- if e.complexity.EditCommentOperation.Date == nil {
- break
- }
+type CommentConnection {
+ edges: [CommentEdge!]!
+ nodes: [Comment!]!
+ pageInfo: PageInfo!
+ totalCount: Int!
+}
- return e.complexity.EditCommentOperation.Date(childComplexity), true
+type CommentEdge {
+ cursor: String!
+ node: Comment!
+}
- case "EditCommentOperation.target":
- if e.complexity.EditCommentOperation.Target == nil {
- break
- }
+enum Status {
+ OPEN
+ CLOSED
+}
- return e.complexity.EditCommentOperation.Target(childComplexity), true
+type Bug {
+ """The identifier for this bug"""
+ id: String!
+ """The human version (truncated) identifier for this bug"""
+ humanId: String!
+ status: Status!
+ title: String!
+ labels: [Label!]!
+ author: Identity!
+ createdAt: Time!
+ lastEdit: Time!
- case "EditCommentOperation.message":
- if e.complexity.EditCommentOperation.Message == nil {
- break
- }
+ """The actors of the bug. Actors are Identity that have interacted with the bug."""
+ actors(
+ """Returns the elements in the list that come after the specified cursor."""
+ after: String
+ """Returns the elements in the list that come before the specified cursor."""
+ before: String
+ """Returns the first _n_ elements from the list."""
+ first: Int
+ """Returns the last _n_ elements from the list."""
+ last: Int
+ ): IdentityConnection!
- return e.complexity.EditCommentOperation.Message(childComplexity), true
+ """The participants of the bug. Participants are Identity that have created or
+ added a comment on the bug."""
+ participants(
+ """Returns the elements in the list that come after the specified cursor."""
+ after: String
+ """Returns the elements in the list that come before the specified cursor."""
+ before: String
+ """Returns the first _n_ elements from the list."""
+ first: Int
+ """Returns the last _n_ elements from the list."""
+ last: Int
+ ): IdentityConnection!
- case "EditCommentOperation.files":
- if e.complexity.EditCommentOperation.Files == nil {
- break
- }
-
- return e.complexity.EditCommentOperation.Files(childComplexity), true
+ comments(
+ """Returns the elements in the list that come after the specified cursor."""
+ after: String
+ """Returns the elements in the list that come before the specified cursor."""
+ before: String
+ """Returns the first _n_ elements from the list."""
+ first: Int
+ """Returns the last _n_ elements from the list."""
+ last: Int
+ ): CommentConnection!
- case "Identity.id":
- if e.complexity.Identity.Id == nil {
- break
- }
+ timeline(
+ """Returns the elements in the list that come after the specified cursor."""
+ after: String
+ """Returns the elements in the list that come before the specified cursor."""
+ before: String
+ """Returns the first _n_ elements from the list."""
+ first: Int
+ """Returns the last _n_ elements from the list."""
+ last: Int
+ ): TimelineItemConnection!
- return e.complexity.Identity.Id(childComplexity), true
+ operations(
+ """Returns the elements in the list that come after the specified cursor."""
+ after: String
+ """Returns the elements in the list that come before the specified cursor."""
+ before: String
+ """Returns the first _n_ elements from the list."""
+ first: Int
+ """Returns the last _n_ elements from the list."""
+ last: Int
+ ): OperationConnection!
+}
- case "Identity.humanId":
- if e.complexity.Identity.HumanId == nil {
- break
- }
+"""The connection type for Bug."""
+type BugConnection {
+ """A list of edges."""
+ edges: [BugEdge!]!
+ nodes: [Bug!]!
+ """Information to aid in pagination."""
+ pageInfo: PageInfo!
+ """Identifies the total count of items in the connection."""
+ totalCount: Int!
+}
- return e.complexity.Identity.HumanId(childComplexity), true
+"""An edge in a connection."""
+type BugEdge {
+ """A cursor for use in pagination."""
+ cursor: String!
+ """The item at the end of the edge."""
+ node: Bug!
+}
- case "Identity.name":
- if e.complexity.Identity.Name == nil {
- break
- }
+`},
+ &ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
+type Identity {
+ """The identifier for this identity"""
+ id: String!
+ """The human version (truncated) identifier for this identity"""
+ humanId: String!
+ """The name of the person, if known."""
+ name: String
+ """The email of the person, if known."""
+ email: String
+ """The login of the person, if known."""
+ login: String
+ """A string containing the either the name of the person, its login or both"""
+ displayName: String!
+ """An url to an avatar"""
+ avatarUrl: String
+ """isProtected is true if the chain of git commits started to be signed.
+ If that's the case, only signed commit with a valid key for this identity can be added."""
+ isProtected: Boolean!
+}
- return e.complexity.Identity.Name(childComplexity), true
+type IdentityConnection {
+ edges: [IdentityEdge!]!
+ nodes: [Identity!]!
+ pageInfo: PageInfo!
+ totalCount: Int!
+}
- case "Identity.email":
- if e.complexity.Identity.Email == nil {
- break
- }
+type IdentityEdge {
+ cursor: String!
+ node: Identity!
+}`},
+ &ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
+interface Operation {
+ """The hash of the operation"""
+ hash: Hash!
+ """The operations author."""
+ author: Identity!
+ """The datetime when this operation was issued."""
+ date: Time!
+}
- return e.complexity.Identity.Email(childComplexity), true
+# Connection
- case "Identity.login":
- if e.complexity.Identity.Login == nil {
- break
- }
+"""The connection type for an Operation"""
+type OperationConnection {
+ edges: [OperationEdge!]!
+ nodes: [Operation!]!
+ pageInfo: PageInfo!
+ totalCount: Int!
+}
- return e.complexity.Identity.Login(childComplexity), true
+"""Represent an Operation"""
+type OperationEdge {
+ cursor: String!
+ node: Operation!
+}
- case "Identity.displayName":
- if e.complexity.Identity.DisplayName == nil {
- break
- }
+# Operations
- return e.complexity.Identity.DisplayName(childComplexity), true
+type CreateOperation implements Operation & Authored {
+ """The hash of the operation"""
+ hash: Hash!
+ """The author of this object."""
+ author: Identity!
+ """The datetime when this operation was issued."""
+ date: Time!
- case "Identity.avatarUrl":
- if e.complexity.Identity.AvatarUrl == nil {
- break
- }
+ title: String!
+ message: String!
+ files: [Hash!]!
+}
- return e.complexity.Identity.AvatarUrl(childComplexity), true
+type SetTitleOperation implements Operation & Authored {
+ """The hash of the operation"""
+ hash: Hash!
+ """The author of this object."""
+ author: Identity!
+ """The datetime when this operation was issued."""
+ date: Time!
- case "Identity.isProtected":
- if e.complexity.Identity.IsProtected == nil {
- break
- }
+ title: String!
+ was: String!
+}
- return e.complexity.Identity.IsProtected(childComplexity), true
+type AddCommentOperation implements Operation & Authored {
+ """The hash of the operation"""
+ hash: Hash!
+ """The author of this object."""
+ author: Identity!
+ """The datetime when this operation was issued."""
+ date: Time!
- case "IdentityConnection.edges":
- if e.complexity.IdentityConnection.Edges == nil {
- break
- }
+ message: String!
+ files: [Hash!]!
+}
- return e.complexity.IdentityConnection.Edges(childComplexity), true
+type EditCommentOperation implements Operation & Authored {
+ """The hash of the operation"""
+ hash: Hash!
+ """The author of this object."""
+ author: Identity!
+ """The datetime when this operation was issued."""
+ date: Time!
- case "IdentityConnection.nodes":
- if e.complexity.IdentityConnection.Nodes == nil {
- break
- }
+ target: Hash!
+ message: String!
+ files: [Hash!]!
+}
- return e.complexity.IdentityConnection.Nodes(childComplexity), true
+type SetStatusOperation implements Operation & Authored {
+ """The hash of the operation"""
+ hash: Hash!
+ """The author of this object."""
+ author: Identity!
+ """The datetime when this operation was issued."""
+ date: Time!
- case "IdentityConnection.pageInfo":
- if e.complexity.IdentityConnection.PageInfo == nil {
- break
- }
+ status: Status!
+}
- return e.complexity.IdentityConnection.PageInfo(childComplexity), true
+type LabelChangeOperation implements Operation & Authored {
+ """The hash of the operation"""
+ hash: Hash!
+ """The author of this object."""
+ author: Identity!
+ """The datetime when this operation was issued."""
+ date: Time!
- case "IdentityConnection.totalCount":
- if e.complexity.IdentityConnection.TotalCount == nil {
- break
- }
+ added: [Label!]!
+ removed: [Label!]!
+}
+`},
+ &ast.Source{Name: "schema/repository.graphql", Input: `
+type Repository {
+ """All the bugs"""
+ allBugs(
+ """Returns the elements in the list that come after the specified cursor."""
+ after: String
+ """Returns the elements in the list that come before the specified cursor."""
+ before: String
+ """Returns the first _n_ elements from the list."""
+ first: Int
+ """Returns the last _n_ elements from the list."""
+ last: Int
+ """A query to select and order bugs"""
+ query: String
+ ): BugConnection!
- return e.complexity.IdentityConnection.TotalCount(childComplexity), true
+ bug(prefix: String!): Bug
- case "IdentityEdge.cursor":
- if e.complexity.IdentityEdge.Cursor == nil {
- break
- }
+ """All the identities"""
+ allIdentities(
+ """Returns the elements in the list that come after the specified cursor."""
+ after: String
+ """Returns the elements in the list that come before the specified cursor."""
+ before: String
+ """Returns the first _n_ elements from the list."""
+ first: Int
+ """Returns the last _n_ elements from the list."""
+ last: Int
+ ): IdentityConnection!
- return e.complexity.IdentityEdge.Cursor(childComplexity), true
+ identity(prefix: String!):Identity
- case "IdentityEdge.node":
- if e.complexity.IdentityEdge.Node == nil {
- break
- }
+ """The identity created or selected by the user as its own"""
+ userIdentity:Identity
+}`},
+ &ast.Source{Name: "schema/root.graphql", Input: `type Query {
+ defaultRepository: Repository
+ repository(id: String!): Repository
+}
- return e.complexity.IdentityEdge.Node(childComplexity), true
+type Mutation {
+ newBug(repoRef: String, title: String!, message: String!, files: [Hash!]): Bug!
- case "LabelChangeOperation.hash":
- if e.complexity.LabelChangeOperation.Hash == nil {
- break
- }
-
- return e.complexity.LabelChangeOperation.Hash(childComplexity), true
-
- case "LabelChangeOperation.author":
- if e.complexity.LabelChangeOperation.Author == nil {
- break
- }
-
- return e.complexity.LabelChangeOperation.Author(childComplexity), true
-
- case "LabelChangeOperation.date":
- if e.complexity.LabelChangeOperation.Date == nil {
- break
- }
+ addComment(repoRef: String, prefix: String!, message: String!, files: [Hash!]): Bug!
+ changeLabels(repoRef: String, prefix: String!, added: [String!], removed: [String!]): Bug!
+ open(repoRef: String, prefix: String!): Bug!
+ close(repoRef: String, prefix: String!): Bug!
+ setTitle(repoRef: String, prefix: String!, title: String!): Bug!
- return e.complexity.LabelChangeOperation.Date(childComplexity), true
+ commit(repoRef: String, prefix: String!): Bug!
+}
+`},
+ &ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
+interface TimelineItem {
+ """The hash of the source operation"""
+ hash: Hash!
+}
- case "LabelChangeOperation.added":
- if e.complexity.LabelChangeOperation.Added == nil {
- break
- }
+"""CommentHistoryStep hold one version of a message in the history"""
+type CommentHistoryStep {
+ message: String!
+ date: Time!
+}
- return e.complexity.LabelChangeOperation.Added(childComplexity), true
+# Connection
- case "LabelChangeOperation.removed":
- if e.complexity.LabelChangeOperation.Removed == nil {
- break
- }
+"""The connection type for TimelineItem"""
+type TimelineItemConnection {
+ edges: [TimelineItemEdge!]!
+ nodes: [TimelineItem!]!
+ pageInfo: PageInfo!
+ totalCount: Int!
+}
- return e.complexity.LabelChangeOperation.Removed(childComplexity), true
+"""Represent a TimelineItem"""
+type TimelineItemEdge {
+ cursor: String!
+ node: TimelineItem!
+}
- case "LabelChangeTimelineItem.hash":
- if e.complexity.LabelChangeTimelineItem.Hash == nil {
- break
- }
+# Items
- return e.complexity.LabelChangeTimelineItem.Hash(childComplexity), true
+"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
+type CreateTimelineItem implements TimelineItem {
+ """The hash of the source operation"""
+ hash: Hash!
+ author: Identity!
+ message: String!
+ messageIsEmpty: Boolean!
+ files: [Hash!]!
+ createdAt: Time!
+ lastEdit: Time!
+ edited: Boolean!
+ history: [CommentHistoryStep!]!
+}
- case "LabelChangeTimelineItem.author":
- if e.complexity.LabelChangeTimelineItem.Author == nil {
- break
- }
+"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
+type AddCommentTimelineItem implements TimelineItem {
+ """The hash of the source operation"""
+ hash: Hash!
+ author: Identity!
+ message: String!
+ messageIsEmpty: Boolean!
+ files: [Hash!]!
+ createdAt: Time!
+ lastEdit: Time!
+ edited: Boolean!
+ history: [CommentHistoryStep!]!
+}
- return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
+"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
+type LabelChangeTimelineItem implements TimelineItem {
+ """The hash of the source operation"""
+ hash: Hash!
+ author: Identity!
+ date: Time!
+ added: [Label!]!
+ removed: [Label!]!
+}
- case "LabelChangeTimelineItem.date":
- if e.complexity.LabelChangeTimelineItem.Date == nil {
- break
- }
+"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
+type SetStatusTimelineItem implements TimelineItem {
+ """The hash of the source operation"""
+ hash: Hash!
+ author: Identity!
+ date: Time!
+ status: Status!
+}
- return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
+"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
+type SetTitleTimelineItem implements TimelineItem {
+ """The hash of the source operation"""
+ hash: Hash!
+ author: Identity!
+ date: Time!
+ title: String!
+ was: String!
+}
+`},
+ &ast.Source{Name: "schema/types.graphql", Input: `scalar Time
+scalar Label
+scalar Hash
- case "LabelChangeTimelineItem.added":
- if e.complexity.LabelChangeTimelineItem.Added == nil {
- break
- }
+"""Information about pagination in a connection."""
+type PageInfo {
+ """When paginating forwards, are there more items?"""
+ hasNextPage: Boolean!
+ """When paginating backwards, are there more items?"""
+ hasPreviousPage: Boolean!
+ """When paginating backwards, the cursor to continue."""
+ startCursor: String!
+ """When paginating forwards, the cursor to continue."""
+ endCursor: String!
+}
- return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
+"""An object that has an author."""
+interface Authored {
+ """The author of this object."""
+ author: Identity!
+}`},
+)
- case "LabelChangeTimelineItem.removed":
- if e.complexity.LabelChangeTimelineItem.Removed == nil {
- break
- }
+// endregion ************************** generated!.gotpl **************************
- return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
+// region ***************************** args.gotpl *****************************
- case "Mutation.newBug":
- if e.complexity.Mutation.NewBug == nil {
- break
+func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 *string
+ if tmp, ok := rawArgs["after"]; ok {
+ arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- args, err := field_Mutation_newBug_args(rawArgs)
+ }
+ args["after"] = arg0
+ var arg1 *string
+ if tmp, ok := rawArgs["before"]; ok {
+ arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
if err != nil {
- return 0, false
+ return nil, err
}
-
- return e.complexity.Mutation.NewBug(childComplexity, args["repoRef"].(*string), args["title"].(string), args["message"].(string), args["files"].([]git.Hash)), true
-
- case "Mutation.addComment":
- if e.complexity.Mutation.AddComment == nil {
- break
+ }
+ args["before"] = arg1
+ var arg2 *int
+ if tmp, ok := rawArgs["first"]; ok {
+ arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- args, err := field_Mutation_addComment_args(rawArgs)
+ }
+ args["first"] = arg2
+ var arg3 *int
+ if tmp, ok := rawArgs["last"]; ok {
+ arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
if err != nil {
- return 0, false
+ return nil, err
}
+ }
+ args["last"] = arg3
+ return args, nil
+}
- return e.complexity.Mutation.AddComment(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["message"].(string), args["files"].([]git.Hash)), true
-
- case "Mutation.changeLabels":
- if e.complexity.Mutation.ChangeLabels == nil {
- break
+func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 *string
+ if tmp, ok := rawArgs["after"]; ok {
+ arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- args, err := field_Mutation_changeLabels_args(rawArgs)
+ }
+ args["after"] = arg0
+ var arg1 *string
+ if tmp, ok := rawArgs["before"]; ok {
+ arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
if err != nil {
- return 0, false
+ return nil, err
}
-
- return e.complexity.Mutation.ChangeLabels(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["added"].([]string), args["removed"].([]string)), true
-
- case "Mutation.open":
- if e.complexity.Mutation.Open == nil {
- break
+ }
+ args["before"] = arg1
+ var arg2 *int
+ if tmp, ok := rawArgs["first"]; ok {
+ arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- args, err := field_Mutation_open_args(rawArgs)
+ }
+ args["first"] = arg2
+ var arg3 *int
+ if tmp, ok := rawArgs["last"]; ok {
+ arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
if err != nil {
- return 0, false
+ return nil, err
}
+ }
+ args["last"] = arg3
+ return args, nil
+}
- return e.complexity.Mutation.Open(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
-
- case "Mutation.close":
- if e.complexity.Mutation.Close == nil {
- break
+func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 *string
+ if tmp, ok := rawArgs["after"]; ok {
+ arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- args, err := field_Mutation_close_args(rawArgs)
+ }
+ args["after"] = arg0
+ var arg1 *string
+ if tmp, ok := rawArgs["before"]; ok {
+ arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
if err != nil {
- return 0, false
+ return nil, err
}
-
- return e.complexity.Mutation.Close(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
-
- case "Mutation.setTitle":
- if e.complexity.Mutation.SetTitle == nil {
- break
+ }
+ args["before"] = arg1
+ var arg2 *int
+ if tmp, ok := rawArgs["first"]; ok {
+ arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- args, err := field_Mutation_setTitle_args(rawArgs)
+ }
+ args["first"] = arg2
+ var arg3 *int
+ if tmp, ok := rawArgs["last"]; ok {
+ arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
if err != nil {
- return 0, false
+ return nil, err
}
+ }
+ args["last"] = arg3
+ return args, nil
+}
- return e.complexity.Mutation.SetTitle(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["title"].(string)), true
-
- case "Mutation.commit":
- if e.complexity.Mutation.Commit == nil {
- break
+func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 *string
+ if tmp, ok := rawArgs["after"]; ok {
+ arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- args, err := field_Mutation_commit_args(rawArgs)
+ }
+ args["after"] = arg0
+ var arg1 *string
+ if tmp, ok := rawArgs["before"]; ok {
+ arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
if err != nil {
- return 0, false
+ return nil, err
}
-
- return e.complexity.Mutation.Commit(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
-
- case "OperationConnection.edges":
- if e.complexity.OperationConnection.Edges == nil {
- break
+ }
+ args["before"] = arg1
+ var arg2 *int
+ if tmp, ok := rawArgs["first"]; ok {
+ arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.OperationConnection.Edges(childComplexity), true
-
- case "OperationConnection.nodes":
- if e.complexity.OperationConnection.Nodes == nil {
- break
+ }
+ args["first"] = arg2
+ var arg3 *int
+ if tmp, ok := rawArgs["last"]; ok {
+ arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["last"] = arg3
+ return args, nil
+}
- return e.complexity.OperationConnection.Nodes(childComplexity), true
-
- case "OperationConnection.pageInfo":
- if e.complexity.OperationConnection.PageInfo == nil {
- break
+func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 *string
+ if tmp, ok := rawArgs["after"]; ok {
+ arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.OperationConnection.PageInfo(childComplexity), true
-
- case "OperationConnection.totalCount":
- if e.complexity.OperationConnection.TotalCount == nil {
- break
+ }
+ args["after"] = arg0
+ var arg1 *string
+ if tmp, ok := rawArgs["before"]; ok {
+ arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.OperationConnection.TotalCount(childComplexity), true
-
- case "OperationEdge.cursor":
- if e.complexity.OperationEdge.Cursor == nil {
- break
+ }
+ args["before"] = arg1
+ var arg2 *int
+ if tmp, ok := rawArgs["first"]; ok {
+ arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.OperationEdge.Cursor(childComplexity), true
-
- case "OperationEdge.node":
- if e.complexity.OperationEdge.Node == nil {
- break
+ }
+ args["first"] = arg2
+ var arg3 *int
+ if tmp, ok := rawArgs["last"]; ok {
+ arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["last"] = arg3
+ return args, nil
+}
- return e.complexity.OperationEdge.Node(childComplexity), true
-
- case "PageInfo.hasNextPage":
- if e.complexity.PageInfo.HasNextPage == nil {
- break
+func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 *string
+ if tmp, ok := rawArgs["repoRef"]; ok {
+ arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.PageInfo.HasNextPage(childComplexity), true
-
- case "PageInfo.hasPreviousPage":
- if e.complexity.PageInfo.HasPreviousPage == nil {
- break
+ }
+ args["repoRef"] = arg0
+ var arg1 string
+ if tmp, ok := rawArgs["prefix"]; ok {
+ arg1, err = ec.unmarshalNString2string(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
-
- case "PageInfo.startCursor":
- if e.complexity.PageInfo.StartCursor == nil {
- break
+ }
+ args["prefix"] = arg1
+ var arg2 string
+ if tmp, ok := rawArgs["message"]; ok {
+ arg2, err = ec.unmarshalNString2string(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.PageInfo.StartCursor(childComplexity), true
-
- case "PageInfo.endCursor":
- if e.complexity.PageInfo.EndCursor == nil {
- break
+ }
+ args["message"] = arg2
+ var arg3 []git.Hash
+ if tmp, ok := rawArgs["files"]; ok {
+ arg3, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["files"] = arg3
+ return args, nil
+}
- return e.complexity.PageInfo.EndCursor(childComplexity), true
-
- case "Query.defaultRepository":
- if e.complexity.Query.DefaultRepository == nil {
- break
+func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 *string
+ if tmp, ok := rawArgs["repoRef"]; ok {
+ arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.Query.DefaultRepository(childComplexity), true
-
- case "Query.repository":
- if e.complexity.Query.Repository == nil {
- break
+ }
+ args["repoRef"] = arg0
+ var arg1 string
+ if tmp, ok := rawArgs["prefix"]; ok {
+ arg1, err = ec.unmarshalNString2string(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- args, err := field_Query_repository_args(rawArgs)
+ }
+ args["prefix"] = arg1
+ var arg2 []string
+ if tmp, ok := rawArgs["added"]; ok {
+ arg2, err = ec.unmarshalOString2ᚕstring(ctx, tmp)
if err != nil {
- return 0, false
+ return nil, err
}
-
- return e.complexity.Query.Repository(childComplexity, args["id"].(string)), true
-
- case "Repository.allBugs":
- if e.complexity.Repository.AllBugs == nil {
- break
+ }
+ args["added"] = arg2
+ var arg3 []string
+ if tmp, ok := rawArgs["removed"]; ok {
+ arg3, err = ec.unmarshalOString2ᚕstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["removed"] = arg3
+ return args, nil
+}
- args, err := field_Repository_allBugs_args(rawArgs)
+func (ec *executionContext) field_Mutation_close_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 *string
+ if tmp, ok := rawArgs["repoRef"]; ok {
+ arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
if err != nil {
- return 0, false
+ return nil, err
}
-
- return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
-
- case "Repository.bug":
- if e.complexity.Repository.Bug == nil {
- break
+ }
+ args["repoRef"] = arg0
+ var arg1 string
+ if tmp, ok := rawArgs["prefix"]; ok {
+ arg1, err = ec.unmarshalNString2string(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["prefix"] = arg1
+ return args, nil
+}
- args, err := field_Repository_bug_args(rawArgs)
+func (ec *executionContext) field_Mutation_commit_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 *string
+ if tmp, ok := rawArgs["repoRef"]; ok {
+ arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
if err != nil {
- return 0, false
+ return nil, err
}
-
- return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
-
- case "Repository.allIdentities":
- if e.complexity.Repository.AllIdentities == nil {
- break
+ }
+ args["repoRef"] = arg0
+ var arg1 string
+ if tmp, ok := rawArgs["prefix"]; ok {
+ arg1, err = ec.unmarshalNString2string(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["prefix"] = arg1
+ return args, nil
+}
- args, err := field_Repository_allIdentities_args(rawArgs)
+func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 *string
+ if tmp, ok := rawArgs["repoRef"]; ok {
+ arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
if err != nil {
- return 0, false
+ return nil, err
}
-
- return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
-
- case "Repository.identity":
- if e.complexity.Repository.Identity == nil {
- break
+ }
+ args["repoRef"] = arg0
+ var arg1 string
+ if tmp, ok := rawArgs["title"]; ok {
+ arg1, err = ec.unmarshalNString2string(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- args, err := field_Repository_identity_args(rawArgs)
+ }
+ args["title"] = arg1
+ var arg2 string
+ if tmp, ok := rawArgs["message"]; ok {
+ arg2, err = ec.unmarshalNString2string(ctx, tmp)
if err != nil {
- return 0, false
+ return nil, err
}
-
- return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
-
- case "Repository.userIdentity":
- if e.complexity.Repository.UserIdentity == nil {
- break
+ }
+ args["message"] = arg2
+ var arg3 []git.Hash
+ if tmp, ok := rawArgs["files"]; ok {
+ arg3, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["files"] = arg3
+ return args, nil
+}
- return e.complexity.Repository.UserIdentity(childComplexity), true
-
- case "SetStatusOperation.hash":
- if e.complexity.SetStatusOperation.Hash == nil {
- break
- }
-
- return e.complexity.SetStatusOperation.Hash(childComplexity), true
-
- case "SetStatusOperation.author":
- if e.complexity.SetStatusOperation.Author == nil {
- break
+func (ec *executionContext) field_Mutation_open_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 *string
+ if tmp, ok := rawArgs["repoRef"]; ok {
+ arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.SetStatusOperation.Author(childComplexity), true
-
- case "SetStatusOperation.date":
- if e.complexity.SetStatusOperation.Date == nil {
- break
+ }
+ args["repoRef"] = arg0
+ var arg1 string
+ if tmp, ok := rawArgs["prefix"]; ok {
+ arg1, err = ec.unmarshalNString2string(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["prefix"] = arg1
+ return args, nil
+}
- return e.complexity.SetStatusOperation.Date(childComplexity), true
-
- case "SetStatusOperation.status":
- if e.complexity.SetStatusOperation.Status == nil {
- break
+func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 *string
+ if tmp, ok := rawArgs["repoRef"]; ok {
+ arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.SetStatusOperation.Status(childComplexity), true
-
- case "SetStatusTimelineItem.hash":
- if e.complexity.SetStatusTimelineItem.Hash == nil {
- break
+ }
+ args["repoRef"] = arg0
+ var arg1 string
+ if tmp, ok := rawArgs["prefix"]; ok {
+ arg1, err = ec.unmarshalNString2string(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.SetStatusTimelineItem.Hash(childComplexity), true
-
- case "SetStatusTimelineItem.author":
- if e.complexity.SetStatusTimelineItem.Author == nil {
- break
+ }
+ args["prefix"] = arg1
+ var arg2 string
+ if tmp, ok := rawArgs["title"]; ok {
+ arg2, err = ec.unmarshalNString2string(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["title"] = arg2
+ return args, nil
+}
- return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
-
- case "SetStatusTimelineItem.date":
- if e.complexity.SetStatusTimelineItem.Date == nil {
- break
+func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 string
+ if tmp, ok := rawArgs["name"]; ok {
+ arg0, err = ec.unmarshalNString2string(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["name"] = arg0
+ return args, nil
+}
- return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
-
- case "SetStatusTimelineItem.status":
- if e.complexity.SetStatusTimelineItem.Status == nil {
- break
+func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 string
+ if tmp, ok := rawArgs["id"]; ok {
+ arg0, err = ec.unmarshalNString2string(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["id"] = arg0
+ return args, nil
+}
- return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
-
- case "SetTitleOperation.hash":
- if e.complexity.SetTitleOperation.Hash == nil {
- break
+func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 *string
+ if tmp, ok := rawArgs["after"]; ok {
+ arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.SetTitleOperation.Hash(childComplexity), true
-
- case "SetTitleOperation.author":
- if e.complexity.SetTitleOperation.Author == nil {
- break
+ }
+ args["after"] = arg0
+ var arg1 *string
+ if tmp, ok := rawArgs["before"]; ok {
+ arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.SetTitleOperation.Author(childComplexity), true
-
- case "SetTitleOperation.date":
- if e.complexity.SetTitleOperation.Date == nil {
- break
+ }
+ args["before"] = arg1
+ var arg2 *int
+ if tmp, ok := rawArgs["first"]; ok {
+ arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.SetTitleOperation.Date(childComplexity), true
-
- case "SetTitleOperation.title":
- if e.complexity.SetTitleOperation.Title == nil {
- break
+ }
+ args["first"] = arg2
+ var arg3 *int
+ if tmp, ok := rawArgs["last"]; ok {
+ arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.SetTitleOperation.Title(childComplexity), true
-
- case "SetTitleOperation.was":
- if e.complexity.SetTitleOperation.Was == nil {
- break
+ }
+ args["last"] = arg3
+ var arg4 *string
+ if tmp, ok := rawArgs["query"]; ok {
+ arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["query"] = arg4
+ return args, nil
+}
- return e.complexity.SetTitleOperation.Was(childComplexity), true
-
- case "SetTitleTimelineItem.hash":
- if e.complexity.SetTitleTimelineItem.Hash == nil {
- break
+func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 *string
+ if tmp, ok := rawArgs["after"]; ok {
+ arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.SetTitleTimelineItem.Hash(childComplexity), true
-
- case "SetTitleTimelineItem.author":
- if e.complexity.SetTitleTimelineItem.Author == nil {
- break
+ }
+ args["after"] = arg0
+ var arg1 *string
+ if tmp, ok := rawArgs["before"]; ok {
+ arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
-
- case "SetTitleTimelineItem.date":
- if e.complexity.SetTitleTimelineItem.Date == nil {
- break
+ }
+ args["before"] = arg1
+ var arg2 *int
+ if tmp, ok := rawArgs["first"]; ok {
+ arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+ if err != nil {
+ return nil, err
}
-
- return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
-
- case "SetTitleTimelineItem.title":
- if e.complexity.SetTitleTimelineItem.Title == nil {
- break
+ }
+ args["first"] = arg2
+ var arg3 *int
+ if tmp, ok := rawArgs["last"]; ok {
+ arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["last"] = arg3
+ return args, nil
+}
- return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
-
- case "SetTitleTimelineItem.was":
- if e.complexity.SetTitleTimelineItem.Was == nil {
- break
+func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 string
+ if tmp, ok := rawArgs["prefix"]; ok {
+ arg0, err = ec.unmarshalNString2string(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["prefix"] = arg0
+ return args, nil
+}
- return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
-
- case "TimelineItemConnection.edges":
- if e.complexity.TimelineItemConnection.Edges == nil {
- break
+func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 string
+ if tmp, ok := rawArgs["prefix"]; ok {
+ arg0, err = ec.unmarshalNString2string(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["prefix"] = arg0
+ return args, nil
+}
- return e.complexity.TimelineItemConnection.Edges(childComplexity), true
-
- case "TimelineItemConnection.nodes":
- if e.complexity.TimelineItemConnection.Nodes == nil {
- break
+func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 bool
+ if tmp, ok := rawArgs["includeDeprecated"]; ok {
+ arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["includeDeprecated"] = arg0
+ return args, nil
+}
- return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
-
- case "TimelineItemConnection.pageInfo":
- if e.complexity.TimelineItemConnection.PageInfo == nil {
- break
+func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+ var err error
+ args := map[string]interface{}{}
+ var arg0 bool
+ if tmp, ok := rawArgs["includeDeprecated"]; ok {
+ arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
+ if err != nil {
+ return nil, err
}
+ }
+ args["includeDeprecated"] = arg0
+ return args, nil
+}
- return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
+// endregion ***************************** args.gotpl *****************************
- case "TimelineItemConnection.totalCount":
- if e.complexity.TimelineItemConnection.TotalCount == nil {
- break
+// region **************************** field.gotpl *****************************
+
+func (ec *executionContext) _AddCommentOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "AddCommentOperation",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Hash()
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(git.Hash)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "AddCommentOperation",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Author, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(identity.Interface)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "AddCommentOperation",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.AddCommentOperation().Date(rctx, obj)
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(*time.Time)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "AddCommentOperation",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Message, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "AddCommentOperation",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Files, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.([]git.Hash)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _AddCommentTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "AddCommentTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Hash(), nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(git.Hash)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "AddCommentTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Author, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(identity.Interface)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "AddCommentTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Message, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "AddCommentTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.MessageIsEmpty(), nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(bool)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNBoolean2bool(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "AddCommentTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Files, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.([]git.Hash)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "AddCommentTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(*time.Time)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "AddCommentTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(*time.Time)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "AddCommentTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Edited(), nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(bool)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNBoolean2bool(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "AddCommentTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.History, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.([]bug.CommentHistoryStep)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Bug",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Id(), nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Bug",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.HumanId(), nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Bug",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.Bug().Status(rctx, obj)
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(models.Status)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Bug",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Title, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Bug",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Labels, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.([]bug.Label)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Bug",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Author, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(identity.Interface)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Bug",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.CreatedAt, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(time.Time)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Bug",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.Bug().LastEdit(rctx, obj)
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(*time.Time)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Bug",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ rawArgs := field.ArgumentMap(ec.Variables)
+ args, err := ec.field_Bug_actors_args(ctx, rawArgs)
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ rctx.Args = args
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(*models.IdentityConnection)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Bug",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ rawArgs := field.ArgumentMap(ec.Variables)
+ args, err := ec.field_Bug_participants_args(ctx, rawArgs)
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ rctx.Args = args
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(*models.IdentityConnection)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Bug",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ rawArgs := field.ArgumentMap(ec.Variables)
+ args, err := ec.field_Bug_comments_args(ctx, rawArgs)
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ rctx.Args = args
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(*models.CommentConnection)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Bug",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ rawArgs := field.ArgumentMap(ec.Variables)
+ args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ rctx.Args = args
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(*models.TimelineItemConnection)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Bug",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ rawArgs := field.ArgumentMap(ec.Variables)
+ args, err := ec.field_Bug_operations_args(ctx, rawArgs)
+ if err != nil {
+ ec.Error(ctx, err)
+ return graphql.Null
+ }
+ rctx.Args = args
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(*models.OperationConnection)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "BugConnection",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Edges, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.([]models.BugEdge)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNBugEdge2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "BugConnection",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Nodes, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.([]bug.Snapshot)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNBug2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "BugConnection",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.PageInfo, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(models.PageInfo)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "BugConnection",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.TotalCount, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(int)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNInt2int(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "BugEdge",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Cursor, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "BugEdge",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Node, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(bug.Snapshot)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Comment",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Author, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(identity.Interface)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Comment",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Message, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "Comment",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Files, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.([]git.Hash)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CommentConnection",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Edges, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.([]models.CommentEdge)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNCommentEdge2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CommentConnection",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Nodes, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.([]bug.Comment)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNComment2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CommentConnection",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.PageInfo, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(models.PageInfo)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CommentConnection",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.TotalCount, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(int)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNInt2int(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CommentEdge",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Cursor, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CommentEdge",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Node, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(bug.Comment)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CommentHistoryStep",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Message, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CommentHistoryStep",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(*time.Time)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CreateOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CreateOperation",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Hash()
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(git.Hash)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CreateOperation",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Author, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(identity.Interface)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CreateOperation",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.CreateOperation().Date(rctx, obj)
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(*time.Time)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CreateOperation",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Title, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CreateOperation",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Message, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNString2string(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CreateOperation",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Files, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.([]git.Hash)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CreateTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CreateTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Hash(), nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(git.Hash)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CreateTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Author, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
}
+ return graphql.Null
+ }
+ res := resTmp.(identity.Interface)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
+}
- return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
-
- case "TimelineItemEdge.cursor":
- if e.complexity.TimelineItemEdge.Cursor == nil {
- break
+func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CreateTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Message, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
}
+ return graphql.Null
+ }
+ res := resTmp.(string)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNString2string(ctx, field.Selections, res)
+}
- return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
-
- case "TimelineItemEdge.node":
- if e.complexity.TimelineItemEdge.Node == nil {
- break
+func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CreateTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.MessageIsEmpty(), nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
}
-
- return e.complexity.TimelineItemEdge.Node(childComplexity), true
-
+ return graphql.Null
}
- return 0, false
+ res := resTmp.(bool)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}
-func (e *executableSchema) Query(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
- ec := executionContext{graphql.GetRequestContext(ctx), e}
-
- buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
- data := ec._Query(ctx, op.SelectionSet)
- var buf bytes.Buffer
- data.MarshalGQL(&buf)
- return buf.Bytes()
+func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CreateTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Files, nil
})
-
- return &graphql.Response{
- Data: buf,
- Errors: ec.Errors,
- Extensions: ec.Extensions}
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.([]git.Hash)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
}
-func (e *executableSchema) Mutation(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
- ec := executionContext{graphql.GetRequestContext(ctx), e}
-
- buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
- data := ec._Mutation(ctx, op.SelectionSet)
- var buf bytes.Buffer
- data.MarshalGQL(&buf)
- return buf.Bytes()
+func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CreateTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
})
-
- return &graphql.Response{
- Data: buf,
- Errors: ec.Errors,
- Extensions: ec.Extensions,
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
}
+ res := resTmp.(*time.Time)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
}
-func (e *executableSchema) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response {
- return graphql.OneShot(graphql.ErrorResponse(ctx, "subscriptions are not supported"))
+func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CreateTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(*time.Time)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
}
-type executionContext struct {
- *graphql.RequestContext
- *executableSchema
+func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CreateTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
+ }
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.Edited(), nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
+ return graphql.Null
+ }
+ res := resTmp.(bool)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}
-var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
-
-// nolint: gocyclo, errcheck, gas, goconst
-func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
- fields := graphql.CollectFields(ctx, sel, addCommentOperationImplementors)
-
- var wg sync.WaitGroup
- out := graphql.NewOrderedMap(len(fields))
- invalid := false
- for i, field := range fields {
- out.Keys[i] = field.Alias
-
- switch field.Name {
- case "__typename":
- out.Values[i] = graphql.MarshalString("AddCommentOperation")
- case "hash":
- out.Values[i] = ec._AddCommentOperation_hash(ctx, field, obj)
- if out.Values[i] == graphql.Null {
- invalid = true
- }
- case "author":
- out.Values[i] = ec._AddCommentOperation_author(ctx, field, obj)
- if out.Values[i] == graphql.Null {
- invalid = true
- }
- case "date":
- wg.Add(1)
- go func(i int, field graphql.CollectedField) {
- out.Values[i] = ec._AddCommentOperation_date(ctx, field, obj)
- if out.Values[i] == graphql.Null {
- invalid = true
- }
- wg.Done()
- }(i, field)
- case "message":
- out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
- if out.Values[i] == graphql.Null {
- invalid = true
- }
- case "files":
- out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
- if out.Values[i] == graphql.Null {
- invalid = true
- }
- default:
- panic("unknown field " + strconv.Quote(field.Name))
- }
+func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
+ ctx = ec.Tracer.StartFieldExecution(ctx, field)
+ defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+ rctx := &graphql.ResolverContext{
+ Object: "CreateTimelineItem",
+ Field: field,
+ Args: nil,
+ IsMethod: false,
}
- wg.Wait()
- if invalid {
+ ctx = graphql.WithResolverContext(ctx, rctx)
+ ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+ resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+ ctx = rctx // use context from middleware stack in children
+ return obj.History, nil
+ })
+ if resTmp == nil {
+ if !ec.HasError(rctx) {
+ ec.Errorf(ctx, "must not be null")
+ }
return graphql.Null
}
- return out
+ res := resTmp.([]bug.CommentHistoryStep)
+ rctx.Result = res
+ ctx = ec.Tracer.StartFieldChildExecution(ctx)
+ return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, field.Selections, res)
}
-// nolint: vetshadow
-func (ec *executionContext) _AddCommentOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
+func (ec *executionContext) _EditCommentOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
ctx = ec.Tracer.StartFieldExecution(ctx, field)
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
rctx := &graphql.ResolverContext{
- Object: "AddCommentOperation",
- Args: nil,
- Field: field,
+ Object: "EditCommentOperation",
+ Field: field,
+ Args: nil,
+ IsMethod: true,
}
ctx = graphql.WithResolverContext(ctx, rctx)
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)