mirror of
https://github.com/MichaelMure/git-bug.git
synced 2024-12-15 10:12:06 +03:00
12774 lines
402 KiB
Go
12774 lines
402 KiB
Go
// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
|
|
|
|
package graph
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"image/color"
|
|
"strconv"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
"github.com/99designs/gqlgen/graphql"
|
|
"github.com/99designs/gqlgen/graphql/introspection"
|
|
"github.com/MichaelMure/git-bug/bug"
|
|
"github.com/MichaelMure/git-bug/graphql/models"
|
|
"github.com/MichaelMure/git-bug/identity"
|
|
"github.com/MichaelMure/git-bug/util/git"
|
|
"github.com/vektah/gqlparser"
|
|
"github.com/vektah/gqlparser/ast"
|
|
)
|
|
|
|
// region ************************** generated!.gotpl **************************
|
|
|
|
// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
|
|
func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
|
|
return &executableSchema{
|
|
resolvers: cfg.Resolvers,
|
|
directives: cfg.Directives,
|
|
complexity: cfg.Complexity,
|
|
}
|
|
}
|
|
|
|
type Config struct {
|
|
Resolvers ResolverRoot
|
|
Directives DirectiveRoot
|
|
Complexity ComplexityRoot
|
|
}
|
|
|
|
type ResolverRoot interface {
|
|
AddCommentOperation() AddCommentOperationResolver
|
|
AddCommentTimelineItem() AddCommentTimelineItemResolver
|
|
Bug() BugResolver
|
|
Color() ColorResolver
|
|
CommentHistoryStep() CommentHistoryStepResolver
|
|
CreateOperation() CreateOperationResolver
|
|
CreateTimelineItem() CreateTimelineItemResolver
|
|
EditCommentOperation() EditCommentOperationResolver
|
|
Identity() IdentityResolver
|
|
Label() LabelResolver
|
|
LabelChangeOperation() LabelChangeOperationResolver
|
|
LabelChangeResult() LabelChangeResultResolver
|
|
LabelChangeTimelineItem() LabelChangeTimelineItemResolver
|
|
Mutation() MutationResolver
|
|
Query() QueryResolver
|
|
Repository() RepositoryResolver
|
|
SetStatusOperation() SetStatusOperationResolver
|
|
SetStatusTimelineItem() SetStatusTimelineItemResolver
|
|
SetTitleOperation() SetTitleOperationResolver
|
|
SetTitleTimelineItem() SetTitleTimelineItemResolver
|
|
}
|
|
|
|
type DirectiveRoot struct {
|
|
}
|
|
|
|
type ComplexityRoot struct {
|
|
AddCommentOperation struct {
|
|
Author func(childComplexity int) int
|
|
Date func(childComplexity int) int
|
|
Files func(childComplexity int) int
|
|
Hash func(childComplexity int) int
|
|
Message func(childComplexity int) int
|
|
}
|
|
|
|
AddCommentPayload struct {
|
|
Bug func(childComplexity int) int
|
|
ClientMutationID func(childComplexity int) int
|
|
Operation func(childComplexity int) int
|
|
}
|
|
|
|
AddCommentTimelineItem struct {
|
|
Author func(childComplexity int) int
|
|
CreatedAt 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 {
|
|
Actors func(childComplexity int, after *string, before *string, first *int, last *int) int
|
|
Author func(childComplexity int) int
|
|
Comments func(childComplexity int, after *string, before *string, first *int, last *int) int
|
|
CreatedAt func(childComplexity int) int
|
|
HumanId func(childComplexity int) int
|
|
Id func(childComplexity int) int
|
|
Labels func(childComplexity int) int
|
|
LastEdit func(childComplexity int) int
|
|
Operations func(childComplexity int, after *string, before *string, first *int, last *int) int
|
|
Participants func(childComplexity int, after *string, before *string, first *int, last *int) int
|
|
Status func(childComplexity int) int
|
|
Timeline func(childComplexity int, after *string, before *string, first *int, last *int) int
|
|
Title func(childComplexity int) int
|
|
}
|
|
|
|
BugConnection struct {
|
|
Edges func(childComplexity int) int
|
|
Nodes func(childComplexity int) int
|
|
PageInfo func(childComplexity int) int
|
|
TotalCount func(childComplexity int) int
|
|
}
|
|
|
|
BugEdge struct {
|
|
Cursor func(childComplexity int) int
|
|
Node func(childComplexity int) int
|
|
}
|
|
|
|
ChangeLabelPayload struct {
|
|
Bug func(childComplexity int) int
|
|
ClientMutationID func(childComplexity int) int
|
|
Operation func(childComplexity int) int
|
|
Results func(childComplexity int) int
|
|
}
|
|
|
|
CloseBugPayload struct {
|
|
Bug func(childComplexity int) int
|
|
ClientMutationID func(childComplexity int) int
|
|
Operation func(childComplexity int) int
|
|
}
|
|
|
|
Color struct {
|
|
B func(childComplexity int) int
|
|
G func(childComplexity int) int
|
|
R func(childComplexity int) int
|
|
}
|
|
|
|
Comment struct {
|
|
Author func(childComplexity int) int
|
|
Files func(childComplexity int) int
|
|
Message func(childComplexity int) int
|
|
}
|
|
|
|
CommentConnection struct {
|
|
Edges func(childComplexity int) int
|
|
Nodes func(childComplexity int) int
|
|
PageInfo func(childComplexity int) int
|
|
TotalCount func(childComplexity int) int
|
|
}
|
|
|
|
CommentEdge struct {
|
|
Cursor func(childComplexity int) int
|
|
Node func(childComplexity int) int
|
|
}
|
|
|
|
CommentHistoryStep struct {
|
|
Date func(childComplexity int) int
|
|
Message func(childComplexity int) int
|
|
}
|
|
|
|
CommitAsNeededPayload struct {
|
|
Bug func(childComplexity int) int
|
|
ClientMutationID func(childComplexity int) int
|
|
}
|
|
|
|
CommitPayload struct {
|
|
Bug func(childComplexity int) int
|
|
ClientMutationID func(childComplexity int) int
|
|
}
|
|
|
|
CreateOperation struct {
|
|
Author func(childComplexity int) int
|
|
Date 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 {
|
|
Author func(childComplexity int) int
|
|
CreatedAt 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 {
|
|
Author func(childComplexity int) int
|
|
Date 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 {
|
|
AvatarURL func(childComplexity int) int
|
|
DisplayName 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 {
|
|
Edges func(childComplexity int) int
|
|
Nodes func(childComplexity int) int
|
|
PageInfo func(childComplexity int) int
|
|
TotalCount func(childComplexity int) int
|
|
}
|
|
|
|
IdentityEdge struct {
|
|
Cursor func(childComplexity int) int
|
|
Node func(childComplexity int) int
|
|
}
|
|
|
|
Label struct {
|
|
Color func(childComplexity int) int
|
|
Name func(childComplexity int) int
|
|
}
|
|
|
|
LabelChangeOperation struct {
|
|
Added func(childComplexity int) int
|
|
Author func(childComplexity int) int
|
|
Date func(childComplexity int) int
|
|
Hash func(childComplexity int) int
|
|
Removed func(childComplexity int) int
|
|
}
|
|
|
|
LabelChangeResult struct {
|
|
Label func(childComplexity int) int
|
|
Status func(childComplexity int) int
|
|
}
|
|
|
|
LabelChangeTimelineItem struct {
|
|
Added func(childComplexity int) int
|
|
Author func(childComplexity int) int
|
|
Date func(childComplexity int) int
|
|
Hash func(childComplexity int) int
|
|
Removed func(childComplexity int) int
|
|
}
|
|
|
|
Mutation struct {
|
|
AddComment func(childComplexity int, input models.AddCommentInput) int
|
|
ChangeLabels func(childComplexity int, input *models.ChangeLabelInput) int
|
|
CloseBug func(childComplexity int, input models.CloseBugInput) int
|
|
Commit func(childComplexity int, input models.CommitInput) int
|
|
CommitAsNeeded func(childComplexity int, input models.CommitAsNeededInput) int
|
|
NewBug func(childComplexity int, input models.NewBugInput) int
|
|
OpenBug func(childComplexity int, input models.OpenBugInput) int
|
|
SetTitle func(childComplexity int, input models.SetTitleInput) int
|
|
}
|
|
|
|
NewBugPayload struct {
|
|
Bug func(childComplexity int) int
|
|
ClientMutationID func(childComplexity int) int
|
|
Operation func(childComplexity int) int
|
|
}
|
|
|
|
OpenBugPayload struct {
|
|
Bug func(childComplexity int) int
|
|
ClientMutationID func(childComplexity int) int
|
|
Operation func(childComplexity int) int
|
|
}
|
|
|
|
OperationConnection struct {
|
|
Edges func(childComplexity int) int
|
|
Nodes func(childComplexity int) int
|
|
PageInfo func(childComplexity int) int
|
|
TotalCount func(childComplexity int) int
|
|
}
|
|
|
|
OperationEdge struct {
|
|
Cursor func(childComplexity int) int
|
|
Node func(childComplexity int) int
|
|
}
|
|
|
|
PageInfo struct {
|
|
EndCursor func(childComplexity int) int
|
|
HasNextPage func(childComplexity int) int
|
|
HasPreviousPage func(childComplexity int) int
|
|
StartCursor func(childComplexity int) int
|
|
}
|
|
|
|
Query struct {
|
|
DefaultRepository func(childComplexity int) int
|
|
Repository func(childComplexity int, ref string) int
|
|
}
|
|
|
|
Repository struct {
|
|
AllBugs func(childComplexity int, after *string, before *string, first *int, last *int, query *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
|
|
ValidLabels func(childComplexity int) int
|
|
}
|
|
|
|
SetStatusOperation struct {
|
|
Author func(childComplexity int) int
|
|
Date func(childComplexity int) int
|
|
Hash func(childComplexity int) int
|
|
Status func(childComplexity int) int
|
|
}
|
|
|
|
SetStatusTimelineItem struct {
|
|
Author func(childComplexity int) int
|
|
Date func(childComplexity int) int
|
|
Hash func(childComplexity int) int
|
|
Status func(childComplexity int) int
|
|
}
|
|
|
|
SetTitleOperation struct {
|
|
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
|
|
}
|
|
|
|
SetTitlePayload struct {
|
|
Bug func(childComplexity int) int
|
|
ClientMutationID func(childComplexity int) int
|
|
Operation func(childComplexity int) int
|
|
}
|
|
|
|
SetTitleTimelineItem struct {
|
|
Author func(childComplexity int) int
|
|
Date func(childComplexity int) int
|
|
Hash func(childComplexity int) int
|
|
Title func(childComplexity int) int
|
|
Was func(childComplexity int) int
|
|
}
|
|
|
|
TimelineItemConnection struct {
|
|
Edges func(childComplexity int) int
|
|
Nodes func(childComplexity int) int
|
|
PageInfo func(childComplexity int) int
|
|
TotalCount func(childComplexity int) int
|
|
}
|
|
|
|
TimelineItemEdge struct {
|
|
Cursor func(childComplexity int) int
|
|
Node func(childComplexity int) int
|
|
}
|
|
}
|
|
|
|
type AddCommentOperationResolver interface {
|
|
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)
|
|
}
|
|
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)
|
|
}
|
|
type ColorResolver interface {
|
|
R(ctx context.Context, obj *color.RGBA) (int, error)
|
|
G(ctx context.Context, obj *color.RGBA) (int, error)
|
|
B(ctx context.Context, obj *color.RGBA) (int, error)
|
|
}
|
|
type CommentHistoryStepResolver interface {
|
|
Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
|
|
}
|
|
type CreateOperationResolver interface {
|
|
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)
|
|
}
|
|
type EditCommentOperationResolver interface {
|
|
Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
|
|
}
|
|
type IdentityResolver interface {
|
|
ID(ctx context.Context, obj *identity.Interface) (string, error)
|
|
HumanID(ctx context.Context, obj *identity.Interface) (string, error)
|
|
Name(ctx context.Context, obj *identity.Interface) (*string, error)
|
|
Email(ctx context.Context, obj *identity.Interface) (*string, error)
|
|
Login(ctx context.Context, obj *identity.Interface) (*string, error)
|
|
DisplayName(ctx context.Context, obj *identity.Interface) (string, error)
|
|
AvatarURL(ctx context.Context, obj *identity.Interface) (*string, error)
|
|
IsProtected(ctx context.Context, obj *identity.Interface) (bool, error)
|
|
}
|
|
type LabelResolver interface {
|
|
Name(ctx context.Context, obj *bug.Label) (string, error)
|
|
Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
|
|
}
|
|
type LabelChangeOperationResolver interface {
|
|
Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
|
|
}
|
|
type LabelChangeResultResolver interface {
|
|
Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
|
|
}
|
|
type LabelChangeTimelineItemResolver interface {
|
|
Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
|
|
}
|
|
type MutationResolver interface {
|
|
NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
|
|
AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
|
|
ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
|
|
OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
|
|
CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
|
|
SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
|
|
Commit(ctx context.Context, input models.CommitInput) (*models.CommitPayload, error)
|
|
CommitAsNeeded(ctx context.Context, input models.CommitAsNeededInput) (*models.CommitAsNeededPayload, error)
|
|
}
|
|
type QueryResolver interface {
|
|
DefaultRepository(ctx context.Context) (*models.Repository, error)
|
|
Repository(ctx context.Context, ref 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)
|
|
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)
|
|
ValidLabels(ctx context.Context, obj *models.Repository) ([]bug.Label, error)
|
|
}
|
|
type SetStatusOperationResolver interface {
|
|
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)
|
|
Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
|
|
}
|
|
type SetTitleOperationResolver interface {
|
|
Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
|
|
}
|
|
type SetTitleTimelineItemResolver interface {
|
|
Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
|
|
}
|
|
|
|
type executableSchema struct {
|
|
resolvers ResolverRoot
|
|
directives DirectiveRoot
|
|
complexity ComplexityRoot
|
|
}
|
|
|
|
func (e *executableSchema) Schema() *ast.Schema {
|
|
return parsedSchema
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
return e.complexity.AddCommentOperation.Author(childComplexity), true
|
|
|
|
case "AddCommentOperation.date":
|
|
if e.complexity.AddCommentOperation.Date == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AddCommentOperation.Date(childComplexity), true
|
|
|
|
case "AddCommentOperation.files":
|
|
if e.complexity.AddCommentOperation.Files == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AddCommentOperation.Files(childComplexity), true
|
|
|
|
case "AddCommentOperation.hash":
|
|
if e.complexity.AddCommentOperation.Hash == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AddCommentOperation.Hash(childComplexity), true
|
|
|
|
case "AddCommentOperation.message":
|
|
if e.complexity.AddCommentOperation.Message == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AddCommentOperation.Message(childComplexity), true
|
|
|
|
case "AddCommentPayload.bug":
|
|
if e.complexity.AddCommentPayload.Bug == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AddCommentPayload.Bug(childComplexity), true
|
|
|
|
case "AddCommentPayload.clientMutationId":
|
|
if e.complexity.AddCommentPayload.ClientMutationID == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
|
|
|
|
case "AddCommentPayload.operation":
|
|
if e.complexity.AddCommentPayload.Operation == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AddCommentPayload.Operation(childComplexity), true
|
|
|
|
case "AddCommentTimelineItem.author":
|
|
if e.complexity.AddCommentTimelineItem.Author == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
|
|
|
|
case "AddCommentTimelineItem.createdAt":
|
|
if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
|
|
|
|
case "AddCommentTimelineItem.edited":
|
|
if e.complexity.AddCommentTimelineItem.Edited == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
|
|
|
|
case "AddCommentTimelineItem.files":
|
|
if e.complexity.AddCommentTimelineItem.Files == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
|
|
|
|
case "AddCommentTimelineItem.hash":
|
|
if e.complexity.AddCommentTimelineItem.Hash == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AddCommentTimelineItem.Hash(childComplexity), true
|
|
|
|
case "AddCommentTimelineItem.history":
|
|
if e.complexity.AddCommentTimelineItem.History == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AddCommentTimelineItem.History(childComplexity), true
|
|
|
|
case "AddCommentTimelineItem.lastEdit":
|
|
if e.complexity.AddCommentTimelineItem.LastEdit == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
|
|
|
|
case "AddCommentTimelineItem.message":
|
|
if e.complexity.AddCommentTimelineItem.Message == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
|
|
|
|
case "AddCommentTimelineItem.messageIsEmpty":
|
|
if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
|
|
break
|
|
}
|
|
|
|
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 0, false
|
|
}
|
|
|
|
return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
|
|
|
|
case "Bug.author":
|
|
if e.complexity.Bug.Author == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.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 0, false
|
|
}
|
|
|
|
return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
|
|
|
|
case "Bug.createdAt":
|
|
if e.complexity.Bug.CreatedAt == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Bug.CreatedAt(childComplexity), true
|
|
|
|
case "Bug.humanId":
|
|
if e.complexity.Bug.HumanId == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Bug.HumanId(childComplexity), true
|
|
|
|
case "Bug.id":
|
|
if e.complexity.Bug.Id == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Bug.Id(childComplexity), true
|
|
|
|
case "Bug.labels":
|
|
if e.complexity.Bug.Labels == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Bug.Labels(childComplexity), true
|
|
|
|
case "Bug.lastEdit":
|
|
if e.complexity.Bug.LastEdit == nil {
|
|
break
|
|
}
|
|
|
|
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 0, false
|
|
}
|
|
|
|
return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
|
|
|
|
case "Bug.participants":
|
|
if e.complexity.Bug.Participants == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
|
|
|
|
case "Bug.status":
|
|
if e.complexity.Bug.Status == nil {
|
|
break
|
|
}
|
|
|
|
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 0, false
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
return e.complexity.Bug.Title(childComplexity), true
|
|
|
|
case "BugConnection.edges":
|
|
if e.complexity.BugConnection.Edges == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.BugConnection.Edges(childComplexity), true
|
|
|
|
case "BugConnection.nodes":
|
|
if e.complexity.BugConnection.Nodes == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.BugConnection.Nodes(childComplexity), true
|
|
|
|
case "BugConnection.pageInfo":
|
|
if e.complexity.BugConnection.PageInfo == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.BugConnection.PageInfo(childComplexity), true
|
|
|
|
case "BugConnection.totalCount":
|
|
if e.complexity.BugConnection.TotalCount == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.BugConnection.TotalCount(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 {
|
|
break
|
|
}
|
|
|
|
return e.complexity.BugEdge.Node(childComplexity), true
|
|
|
|
case "ChangeLabelPayload.bug":
|
|
if e.complexity.ChangeLabelPayload.Bug == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
|
|
|
|
case "ChangeLabelPayload.clientMutationId":
|
|
if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
|
|
|
|
case "ChangeLabelPayload.operation":
|
|
if e.complexity.ChangeLabelPayload.Operation == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
|
|
|
|
case "ChangeLabelPayload.results":
|
|
if e.complexity.ChangeLabelPayload.Results == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.ChangeLabelPayload.Results(childComplexity), true
|
|
|
|
case "CloseBugPayload.bug":
|
|
if e.complexity.CloseBugPayload.Bug == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CloseBugPayload.Bug(childComplexity), true
|
|
|
|
case "CloseBugPayload.clientMutationId":
|
|
if e.complexity.CloseBugPayload.ClientMutationID == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
|
|
|
|
case "CloseBugPayload.operation":
|
|
if e.complexity.CloseBugPayload.Operation == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CloseBugPayload.Operation(childComplexity), true
|
|
|
|
case "Color.B":
|
|
if e.complexity.Color.B == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Color.B(childComplexity), true
|
|
|
|
case "Color.G":
|
|
if e.complexity.Color.G == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Color.G(childComplexity), true
|
|
|
|
case "Color.R":
|
|
if e.complexity.Color.R == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Color.R(childComplexity), true
|
|
|
|
case "Comment.author":
|
|
if e.complexity.Comment.Author == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Comment.Author(childComplexity), true
|
|
|
|
case "Comment.files":
|
|
if e.complexity.Comment.Files == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Comment.Files(childComplexity), true
|
|
|
|
case "Comment.message":
|
|
if e.complexity.Comment.Message == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Comment.Message(childComplexity), true
|
|
|
|
case "CommentConnection.edges":
|
|
if e.complexity.CommentConnection.Edges == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CommentConnection.Edges(childComplexity), true
|
|
|
|
case "CommentConnection.nodes":
|
|
if e.complexity.CommentConnection.Nodes == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CommentConnection.Nodes(childComplexity), true
|
|
|
|
case "CommentConnection.pageInfo":
|
|
if e.complexity.CommentConnection.PageInfo == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CommentConnection.PageInfo(childComplexity), true
|
|
|
|
case "CommentConnection.totalCount":
|
|
if e.complexity.CommentConnection.TotalCount == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CommentConnection.TotalCount(childComplexity), true
|
|
|
|
case "CommentEdge.cursor":
|
|
if e.complexity.CommentEdge.Cursor == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CommentEdge.Cursor(childComplexity), true
|
|
|
|
case "CommentEdge.node":
|
|
if e.complexity.CommentEdge.Node == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CommentEdge.Node(childComplexity), true
|
|
|
|
case "CommentHistoryStep.date":
|
|
if e.complexity.CommentHistoryStep.Date == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CommentHistoryStep.Date(childComplexity), true
|
|
|
|
case "CommentHistoryStep.message":
|
|
if e.complexity.CommentHistoryStep.Message == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CommentHistoryStep.Message(childComplexity), true
|
|
|
|
case "CommitAsNeededPayload.bug":
|
|
if e.complexity.CommitAsNeededPayload.Bug == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CommitAsNeededPayload.Bug(childComplexity), true
|
|
|
|
case "CommitAsNeededPayload.clientMutationId":
|
|
if e.complexity.CommitAsNeededPayload.ClientMutationID == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CommitAsNeededPayload.ClientMutationID(childComplexity), true
|
|
|
|
case "CommitPayload.bug":
|
|
if e.complexity.CommitPayload.Bug == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CommitPayload.Bug(childComplexity), true
|
|
|
|
case "CommitPayload.clientMutationId":
|
|
if e.complexity.CommitPayload.ClientMutationID == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CommitPayload.ClientMutationID(childComplexity), true
|
|
|
|
case "CreateOperation.author":
|
|
if e.complexity.CreateOperation.Author == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CreateOperation.Author(childComplexity), true
|
|
|
|
case "CreateOperation.date":
|
|
if e.complexity.CreateOperation.Date == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CreateOperation.Date(childComplexity), true
|
|
|
|
case "CreateOperation.files":
|
|
if e.complexity.CreateOperation.Files == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CreateOperation.Files(childComplexity), true
|
|
|
|
case "CreateOperation.hash":
|
|
if e.complexity.CreateOperation.Hash == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CreateOperation.Hash(childComplexity), true
|
|
|
|
case "CreateOperation.message":
|
|
if e.complexity.CreateOperation.Message == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CreateOperation.Message(childComplexity), true
|
|
|
|
case "CreateOperation.title":
|
|
if e.complexity.CreateOperation.Title == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CreateOperation.Title(childComplexity), true
|
|
|
|
case "CreateTimelineItem.author":
|
|
if e.complexity.CreateTimelineItem.Author == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CreateTimelineItem.Author(childComplexity), true
|
|
|
|
case "CreateTimelineItem.createdAt":
|
|
if e.complexity.CreateTimelineItem.CreatedAt == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
|
|
|
|
case "CreateTimelineItem.edited":
|
|
if e.complexity.CreateTimelineItem.Edited == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CreateTimelineItem.Edited(childComplexity), true
|
|
|
|
case "CreateTimelineItem.files":
|
|
if e.complexity.CreateTimelineItem.Files == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CreateTimelineItem.Files(childComplexity), true
|
|
|
|
case "CreateTimelineItem.hash":
|
|
if e.complexity.CreateTimelineItem.Hash == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CreateTimelineItem.Hash(childComplexity), true
|
|
|
|
case "CreateTimelineItem.history":
|
|
if e.complexity.CreateTimelineItem.History == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CreateTimelineItem.History(childComplexity), true
|
|
|
|
case "CreateTimelineItem.lastEdit":
|
|
if e.complexity.CreateTimelineItem.LastEdit == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
|
|
|
|
case "CreateTimelineItem.message":
|
|
if e.complexity.CreateTimelineItem.Message == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CreateTimelineItem.Message(childComplexity), true
|
|
|
|
case "CreateTimelineItem.messageIsEmpty":
|
|
if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
|
|
|
|
case "EditCommentOperation.author":
|
|
if e.complexity.EditCommentOperation.Author == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.EditCommentOperation.Author(childComplexity), true
|
|
|
|
case "EditCommentOperation.date":
|
|
if e.complexity.EditCommentOperation.Date == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.EditCommentOperation.Date(childComplexity), true
|
|
|
|
case "EditCommentOperation.files":
|
|
if e.complexity.EditCommentOperation.Files == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.EditCommentOperation.Files(childComplexity), true
|
|
|
|
case "EditCommentOperation.hash":
|
|
if e.complexity.EditCommentOperation.Hash == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.EditCommentOperation.Hash(childComplexity), true
|
|
|
|
case "EditCommentOperation.message":
|
|
if e.complexity.EditCommentOperation.Message == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.EditCommentOperation.Message(childComplexity), true
|
|
|
|
case "EditCommentOperation.target":
|
|
if e.complexity.EditCommentOperation.Target == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.EditCommentOperation.Target(childComplexity), true
|
|
|
|
case "Identity.avatarUrl":
|
|
if e.complexity.Identity.AvatarURL == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Identity.AvatarURL(childComplexity), true
|
|
|
|
case "Identity.displayName":
|
|
if e.complexity.Identity.DisplayName == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Identity.DisplayName(childComplexity), true
|
|
|
|
case "Identity.email":
|
|
if e.complexity.Identity.Email == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Identity.Email(childComplexity), true
|
|
|
|
case "Identity.humanId":
|
|
if e.complexity.Identity.HumanID == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Identity.HumanID(childComplexity), true
|
|
|
|
case "Identity.id":
|
|
if e.complexity.Identity.ID == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Identity.ID(childComplexity), true
|
|
|
|
case "Identity.isProtected":
|
|
if e.complexity.Identity.IsProtected == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Identity.IsProtected(childComplexity), true
|
|
|
|
case "Identity.login":
|
|
if e.complexity.Identity.Login == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Identity.Login(childComplexity), true
|
|
|
|
case "Identity.name":
|
|
if e.complexity.Identity.Name == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Identity.Name(childComplexity), true
|
|
|
|
case "IdentityConnection.edges":
|
|
if e.complexity.IdentityConnection.Edges == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.IdentityConnection.Edges(childComplexity), true
|
|
|
|
case "IdentityConnection.nodes":
|
|
if e.complexity.IdentityConnection.Nodes == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.IdentityConnection.Nodes(childComplexity), true
|
|
|
|
case "IdentityConnection.pageInfo":
|
|
if e.complexity.IdentityConnection.PageInfo == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.IdentityConnection.PageInfo(childComplexity), true
|
|
|
|
case "IdentityConnection.totalCount":
|
|
if e.complexity.IdentityConnection.TotalCount == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.IdentityConnection.TotalCount(childComplexity), true
|
|
|
|
case "IdentityEdge.cursor":
|
|
if e.complexity.IdentityEdge.Cursor == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.IdentityEdge.Cursor(childComplexity), true
|
|
|
|
case "IdentityEdge.node":
|
|
if e.complexity.IdentityEdge.Node == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.IdentityEdge.Node(childComplexity), true
|
|
|
|
case "Label.color":
|
|
if e.complexity.Label.Color == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Label.Color(childComplexity), true
|
|
|
|
case "Label.name":
|
|
if e.complexity.Label.Name == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Label.Name(childComplexity), true
|
|
|
|
case "LabelChangeOperation.added":
|
|
if e.complexity.LabelChangeOperation.Added == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.LabelChangeOperation.Added(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
|
|
}
|
|
|
|
return e.complexity.LabelChangeOperation.Date(childComplexity), true
|
|
|
|
case "LabelChangeOperation.hash":
|
|
if e.complexity.LabelChangeOperation.Hash == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.LabelChangeOperation.Hash(childComplexity), true
|
|
|
|
case "LabelChangeOperation.removed":
|
|
if e.complexity.LabelChangeOperation.Removed == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.LabelChangeOperation.Removed(childComplexity), true
|
|
|
|
case "LabelChangeResult.label":
|
|
if e.complexity.LabelChangeResult.Label == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.LabelChangeResult.Label(childComplexity), true
|
|
|
|
case "LabelChangeResult.status":
|
|
if e.complexity.LabelChangeResult.Status == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.LabelChangeResult.Status(childComplexity), true
|
|
|
|
case "LabelChangeTimelineItem.added":
|
|
if e.complexity.LabelChangeTimelineItem.Added == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
|
|
|
|
case "LabelChangeTimelineItem.author":
|
|
if e.complexity.LabelChangeTimelineItem.Author == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
|
|
|
|
case "LabelChangeTimelineItem.date":
|
|
if e.complexity.LabelChangeTimelineItem.Date == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
|
|
|
|
case "LabelChangeTimelineItem.hash":
|
|
if e.complexity.LabelChangeTimelineItem.Hash == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.LabelChangeTimelineItem.Hash(childComplexity), true
|
|
|
|
case "LabelChangeTimelineItem.removed":
|
|
if e.complexity.LabelChangeTimelineItem.Removed == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
|
|
|
|
case "Mutation.addComment":
|
|
if e.complexity.Mutation.AddComment == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
|
|
|
|
case "Mutation.changeLabels":
|
|
if e.complexity.Mutation.ChangeLabels == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
|
|
|
|
case "Mutation.closeBug":
|
|
if e.complexity.Mutation.CloseBug == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
|
|
|
|
case "Mutation.commit":
|
|
if e.complexity.Mutation.Commit == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_commit_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.Commit(childComplexity, args["input"].(models.CommitInput)), true
|
|
|
|
case "Mutation.commitAsNeeded":
|
|
if e.complexity.Mutation.CommitAsNeeded == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_commitAsNeeded_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.CommitAsNeeded(childComplexity, args["input"].(models.CommitAsNeededInput)), true
|
|
|
|
case "Mutation.newBug":
|
|
if e.complexity.Mutation.NewBug == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
|
|
|
|
case "Mutation.openBug":
|
|
if e.complexity.Mutation.OpenBug == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
|
|
|
|
case "Mutation.setTitle":
|
|
if e.complexity.Mutation.SetTitle == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
|
|
|
|
case "NewBugPayload.bug":
|
|
if e.complexity.NewBugPayload.Bug == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.NewBugPayload.Bug(childComplexity), true
|
|
|
|
case "NewBugPayload.clientMutationId":
|
|
if e.complexity.NewBugPayload.ClientMutationID == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
|
|
|
|
case "NewBugPayload.operation":
|
|
if e.complexity.NewBugPayload.Operation == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.NewBugPayload.Operation(childComplexity), true
|
|
|
|
case "OpenBugPayload.bug":
|
|
if e.complexity.OpenBugPayload.Bug == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.OpenBugPayload.Bug(childComplexity), true
|
|
|
|
case "OpenBugPayload.clientMutationId":
|
|
if e.complexity.OpenBugPayload.ClientMutationID == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
|
|
|
|
case "OpenBugPayload.operation":
|
|
if e.complexity.OpenBugPayload.Operation == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.OpenBugPayload.Operation(childComplexity), true
|
|
|
|
case "OperationConnection.edges":
|
|
if e.complexity.OperationConnection.Edges == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.OperationConnection.Edges(childComplexity), true
|
|
|
|
case "OperationConnection.nodes":
|
|
if e.complexity.OperationConnection.Nodes == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.OperationConnection.Nodes(childComplexity), true
|
|
|
|
case "OperationConnection.pageInfo":
|
|
if e.complexity.OperationConnection.PageInfo == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.OperationConnection.PageInfo(childComplexity), true
|
|
|
|
case "OperationConnection.totalCount":
|
|
if e.complexity.OperationConnection.TotalCount == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.OperationConnection.TotalCount(childComplexity), true
|
|
|
|
case "OperationEdge.cursor":
|
|
if e.complexity.OperationEdge.Cursor == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.OperationEdge.Cursor(childComplexity), true
|
|
|
|
case "OperationEdge.node":
|
|
if e.complexity.OperationEdge.Node == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.OperationEdge.Node(childComplexity), true
|
|
|
|
case "PageInfo.endCursor":
|
|
if e.complexity.PageInfo.EndCursor == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PageInfo.EndCursor(childComplexity), true
|
|
|
|
case "PageInfo.hasNextPage":
|
|
if e.complexity.PageInfo.HasNextPage == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PageInfo.HasNextPage(childComplexity), true
|
|
|
|
case "PageInfo.hasPreviousPage":
|
|
if e.complexity.PageInfo.HasPreviousPage == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
|
|
|
|
case "PageInfo.startCursor":
|
|
if e.complexity.PageInfo.StartCursor == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.PageInfo.StartCursor(childComplexity), true
|
|
|
|
case "Query.defaultRepository":
|
|
if e.complexity.Query.DefaultRepository == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Query.DefaultRepository(childComplexity), true
|
|
|
|
case "Query.repository":
|
|
if e.complexity.Query.Repository == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Query.Repository(childComplexity, args["ref"].(string)), true
|
|
|
|
case "Repository.allBugs":
|
|
if e.complexity.Repository.AllBugs == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
|
|
|
|
case "Repository.allIdentities":
|
|
if e.complexity.Repository.AllIdentities == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
|
|
|
|
case "Repository.bug":
|
|
if e.complexity.Repository.Bug == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
|
|
|
|
case "Repository.identity":
|
|
if e.complexity.Repository.Identity == nil {
|
|
break
|
|
}
|
|
|
|
args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
|
|
return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
|
|
|
|
case "Repository.userIdentity":
|
|
if e.complexity.Repository.UserIdentity == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Repository.UserIdentity(childComplexity), true
|
|
|
|
case "Repository.validLabels":
|
|
if e.complexity.Repository.ValidLabels == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.Repository.ValidLabels(childComplexity), true
|
|
|
|
case "SetStatusOperation.author":
|
|
if e.complexity.SetStatusOperation.Author == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetStatusOperation.Author(childComplexity), true
|
|
|
|
case "SetStatusOperation.date":
|
|
if e.complexity.SetStatusOperation.Date == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetStatusOperation.Date(childComplexity), true
|
|
|
|
case "SetStatusOperation.hash":
|
|
if e.complexity.SetStatusOperation.Hash == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetStatusOperation.Hash(childComplexity), true
|
|
|
|
case "SetStatusOperation.status":
|
|
if e.complexity.SetStatusOperation.Status == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetStatusOperation.Status(childComplexity), true
|
|
|
|
case "SetStatusTimelineItem.author":
|
|
if e.complexity.SetStatusTimelineItem.Author == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
|
|
|
|
case "SetStatusTimelineItem.date":
|
|
if e.complexity.SetStatusTimelineItem.Date == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
|
|
|
|
case "SetStatusTimelineItem.hash":
|
|
if e.complexity.SetStatusTimelineItem.Hash == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetStatusTimelineItem.Hash(childComplexity), true
|
|
|
|
case "SetStatusTimelineItem.status":
|
|
if e.complexity.SetStatusTimelineItem.Status == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
|
|
|
|
case "SetTitleOperation.author":
|
|
if e.complexity.SetTitleOperation.Author == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetTitleOperation.Author(childComplexity), true
|
|
|
|
case "SetTitleOperation.date":
|
|
if e.complexity.SetTitleOperation.Date == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetTitleOperation.Date(childComplexity), true
|
|
|
|
case "SetTitleOperation.hash":
|
|
if e.complexity.SetTitleOperation.Hash == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetTitleOperation.Hash(childComplexity), true
|
|
|
|
case "SetTitleOperation.title":
|
|
if e.complexity.SetTitleOperation.Title == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetTitleOperation.Title(childComplexity), true
|
|
|
|
case "SetTitleOperation.was":
|
|
if e.complexity.SetTitleOperation.Was == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetTitleOperation.Was(childComplexity), true
|
|
|
|
case "SetTitlePayload.bug":
|
|
if e.complexity.SetTitlePayload.Bug == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetTitlePayload.Bug(childComplexity), true
|
|
|
|
case "SetTitlePayload.clientMutationId":
|
|
if e.complexity.SetTitlePayload.ClientMutationID == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
|
|
|
|
case "SetTitlePayload.operation":
|
|
if e.complexity.SetTitlePayload.Operation == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetTitlePayload.Operation(childComplexity), true
|
|
|
|
case "SetTitleTimelineItem.author":
|
|
if e.complexity.SetTitleTimelineItem.Author == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
|
|
|
|
case "SetTitleTimelineItem.date":
|
|
if e.complexity.SetTitleTimelineItem.Date == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
|
|
|
|
case "SetTitleTimelineItem.hash":
|
|
if e.complexity.SetTitleTimelineItem.Hash == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetTitleTimelineItem.Hash(childComplexity), true
|
|
|
|
case "SetTitleTimelineItem.title":
|
|
if e.complexity.SetTitleTimelineItem.Title == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
|
|
|
|
case "SetTitleTimelineItem.was":
|
|
if e.complexity.SetTitleTimelineItem.Was == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
|
|
|
|
case "TimelineItemConnection.edges":
|
|
if e.complexity.TimelineItemConnection.Edges == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.TimelineItemConnection.Edges(childComplexity), true
|
|
|
|
case "TimelineItemConnection.nodes":
|
|
if e.complexity.TimelineItemConnection.Nodes == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
|
|
|
|
case "TimelineItemConnection.pageInfo":
|
|
if e.complexity.TimelineItemConnection.PageInfo == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
|
|
|
|
case "TimelineItemConnection.totalCount":
|
|
if e.complexity.TimelineItemConnection.TotalCount == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
|
|
|
|
case "TimelineItemEdge.cursor":
|
|
if e.complexity.TimelineItemEdge.Cursor == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
|
|
|
|
case "TimelineItemEdge.node":
|
|
if e.complexity.TimelineItemEdge.Node == nil {
|
|
break
|
|
}
|
|
|
|
return e.complexity.TimelineItemEdge.Node(childComplexity), true
|
|
|
|
}
|
|
return 0, false
|
|
}
|
|
|
|
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()
|
|
})
|
|
|
|
return &graphql.Response{
|
|
Data: buf,
|
|
Errors: ec.Errors,
|
|
Extensions: ec.Extensions,
|
|
}
|
|
}
|
|
|
|
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()
|
|
})
|
|
|
|
return &graphql.Response{
|
|
Data: buf,
|
|
Errors: ec.Errors,
|
|
Extensions: ec.Extensions,
|
|
}
|
|
}
|
|
|
|
func (e *executableSchema) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response {
|
|
return graphql.OneShot(graphql.ErrorResponse(ctx, "subscriptions are not supported"))
|
|
}
|
|
|
|
type executionContext struct {
|
|
*graphql.RequestContext
|
|
*executableSchema
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
|
|
if ec.DisableIntrospection {
|
|
return nil, errors.New("introspection disabled")
|
|
}
|
|
return introspection.WrapSchema(parsedSchema), nil
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
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!
|
|
|
|
"""The message of this comment."""
|
|
message: String!
|
|
|
|
"""All media's hash referenced in this comment"""
|
|
files: [Hash!]!
|
|
}
|
|
|
|
type CommentConnection {
|
|
edges: [CommentEdge!]!
|
|
nodes: [Comment!]!
|
|
pageInfo: PageInfo!
|
|
totalCount: Int!
|
|
}
|
|
|
|
type CommentEdge {
|
|
cursor: String!
|
|
node: Comment!
|
|
}
|
|
|
|
enum Status {
|
|
OPEN
|
|
CLOSED
|
|
}
|
|
|
|
type Bug implements Authored {
|
|
"""The identifier for this bug"""
|
|
id: String!
|
|
"""The human version (truncated) identifier for this bug"""
|
|
humanId: String!
|
|
status: Status!
|
|
title: String!
|
|
labels: [Label!]!
|
|
author: Identity!
|
|
createdAt: Time!
|
|
lastEdit: Time!
|
|
|
|
"""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!
|
|
|
|
"""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!
|
|
|
|
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!
|
|
|
|
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!
|
|
|
|
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!
|
|
}
|
|
|
|
"""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!
|
|
}
|
|
|
|
"""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!
|
|
}
|
|
`},
|
|
&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!
|
|
}
|
|
|
|
type IdentityConnection {
|
|
edges: [IdentityEdge!]!
|
|
nodes: [Identity!]!
|
|
pageInfo: PageInfo!
|
|
totalCount: Int!
|
|
}
|
|
|
|
type IdentityEdge {
|
|
cursor: String!
|
|
node: Identity!
|
|
}`},
|
|
&ast.Source{Name: "schema/mutations.graphql", Input: `input NewBugInput {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
""""The name of the repository. If not set, the default repository is used."""
|
|
repoRef: String
|
|
"""The title of the new bug."""
|
|
title: String!
|
|
"""The first message of the new bug."""
|
|
message: String!
|
|
"""The collection of file's hash required for the first message."""
|
|
files: [Hash!]
|
|
}
|
|
|
|
type NewBugPayload {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
"""The created bug."""
|
|
bug: Bug!
|
|
"""The resulting operation."""
|
|
operation: CreateOperation!
|
|
}
|
|
|
|
input AddCommentInput {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
""""The name of the repository. If not set, the default repository is used."""
|
|
repoRef: String
|
|
"""The bug ID's prefix."""
|
|
prefix: String!
|
|
"""The first message of the new bug."""
|
|
message: String!
|
|
"""The collection of file's hash required for the first message."""
|
|
files: [Hash!]
|
|
}
|
|
|
|
type AddCommentPayload {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
"""The affected bug."""
|
|
bug: Bug!
|
|
"""The resulting operation."""
|
|
operation: AddCommentOperation!
|
|
}
|
|
|
|
input ChangeLabelInput {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
""""The name of the repository. If not set, the default repository is used."""
|
|
repoRef: String
|
|
"""The bug ID's prefix."""
|
|
prefix: String!
|
|
"""The list of label to add."""
|
|
added: [String!]
|
|
"""The list of label to remove."""
|
|
Removed: [String!]
|
|
}
|
|
|
|
enum LabelChangeStatus {
|
|
ADDED
|
|
REMOVED
|
|
DUPLICATE_IN_OP
|
|
ALREADY_EXIST
|
|
DOESNT_EXIST
|
|
}
|
|
|
|
type LabelChangeResult {
|
|
"""The source label."""
|
|
label: Label!
|
|
"""The effect this label had."""
|
|
status: LabelChangeStatus!
|
|
}
|
|
|
|
type ChangeLabelPayload {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
"""The affected bug."""
|
|
bug: Bug!
|
|
"""The resulting operation."""
|
|
operation: LabelChangeOperation!
|
|
"""The effect each source label had."""
|
|
results: [LabelChangeResult]!
|
|
}
|
|
|
|
input OpenBugInput {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
""""The name of the repository. If not set, the default repository is used."""
|
|
repoRef: String
|
|
"""The bug ID's prefix."""
|
|
prefix: String!
|
|
}
|
|
|
|
type OpenBugPayload {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
"""The affected bug."""
|
|
bug: Bug!
|
|
"""The resulting operation."""
|
|
operation: SetStatusOperation!
|
|
}
|
|
|
|
input CloseBugInput {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
""""The name of the repository. If not set, the default repository is used."""
|
|
repoRef: String
|
|
"""The bug ID's prefix."""
|
|
prefix: String!
|
|
}
|
|
|
|
type CloseBugPayload {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
"""The affected bug."""
|
|
bug: Bug!
|
|
"""The resulting operation."""
|
|
operation: SetStatusOperation!
|
|
}
|
|
|
|
input SetTitleInput {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
""""The name of the repository. If not set, the default repository is used."""
|
|
repoRef: String
|
|
"""The bug ID's prefix."""
|
|
prefix: String!
|
|
"""The new title."""
|
|
title: String!
|
|
}
|
|
|
|
type SetTitlePayload {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
"""The affected bug."""
|
|
bug: Bug!
|
|
"""The resulting operation"""
|
|
operation: SetTitleOperation!
|
|
}
|
|
|
|
input CommitInput {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
""""The name of the repository. If not set, the default repository is used."""
|
|
repoRef: String
|
|
"""The bug ID's prefix."""
|
|
prefix: String!
|
|
}
|
|
|
|
type CommitPayload {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
"""The affected bug."""
|
|
bug: Bug!
|
|
}
|
|
|
|
input CommitAsNeededInput {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
""""The name of the repository. If not set, the default repository is used."""
|
|
repoRef: String
|
|
"""The bug ID's prefix."""
|
|
prefix: String!
|
|
}
|
|
|
|
type CommitAsNeededPayload {
|
|
"""A unique identifier for the client performing the mutation."""
|
|
clientMutationId: String
|
|
"""The affected bug."""
|
|
bug: Bug!
|
|
}
|
|
`},
|
|
&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!
|
|
}
|
|
|
|
# Connection
|
|
|
|
"""The connection type for an Operation"""
|
|
type OperationConnection {
|
|
edges: [OperationEdge!]!
|
|
nodes: [Operation!]!
|
|
pageInfo: PageInfo!
|
|
totalCount: Int!
|
|
}
|
|
|
|
"""Represent an Operation"""
|
|
type OperationEdge {
|
|
cursor: String!
|
|
node: Operation!
|
|
}
|
|
|
|
# Operations
|
|
|
|
type CreateOperation implements Operation & Authored {
|
|
"""The hash of the operation"""
|
|
hash: Hash!
|
|
"""The author of this object."""
|
|
author: Identity!
|
|
"""The datetime when this operation was issued."""
|
|
date: Time!
|
|
|
|
title: String!
|
|
message: String!
|
|
files: [Hash!]!
|
|
}
|
|
|
|
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!
|
|
|
|
title: String!
|
|
was: String!
|
|
}
|
|
|
|
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!
|
|
|
|
message: String!
|
|
files: [Hash!]!
|
|
}
|
|
|
|
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!
|
|
|
|
target: Hash!
|
|
message: String!
|
|
files: [Hash!]!
|
|
}
|
|
|
|
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!
|
|
|
|
status: Status!
|
|
}
|
|
|
|
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!
|
|
|
|
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!
|
|
|
|
bug(prefix: String!): Bug
|
|
|
|
"""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!
|
|
|
|
identity(prefix: String!): Identity
|
|
|
|
"""The identity created or selected by the user as its own"""
|
|
userIdentity: Identity
|
|
|
|
"""List of valid labels."""
|
|
validLabels: [Label!]!
|
|
}`},
|
|
&ast.Source{Name: "schema/root.graphql", Input: `type Query {
|
|
"""The default unnamend repository."""
|
|
defaultRepository: Repository
|
|
"""Access a repository by reference/name."""
|
|
repository(ref: String!): Repository
|
|
}
|
|
|
|
type Mutation {
|
|
"""Create a new bug"""
|
|
newBug(input: NewBugInput!): NewBugPayload!
|
|
"""Add a new comment to a bug"""
|
|
addComment(input: AddCommentInput!): AddCommentPayload!
|
|
"""Add or remove a set of label on a bug"""
|
|
changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
|
|
"""Change a bug's status to open"""
|
|
openBug(input: OpenBugInput!): OpenBugPayload!
|
|
"""Change a bug's status to closed"""
|
|
closeBug(input: CloseBugInput!): CloseBugPayload!
|
|
"""Change a bug's titlel"""
|
|
setTitle(input: SetTitleInput!): SetTitlePayload!
|
|
"""Commit write the pending operations into storage. This mutation fail if nothing is pending"""
|
|
commit(input: CommitInput!): CommitPayload!
|
|
"""Commit write the pending operations into storage. This mutation succed if nothing is pending"""
|
|
commitAsNeeded(input: CommitAsNeededInput!): CommitAsNeededPayload!
|
|
}
|
|
`},
|
|
&ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
|
|
interface TimelineItem {
|
|
"""The hash of the source operation"""
|
|
hash: Hash!
|
|
}
|
|
|
|
"""CommentHistoryStep hold one version of a message in the history"""
|
|
type CommentHistoryStep {
|
|
message: String!
|
|
date: Time!
|
|
}
|
|
|
|
# Connection
|
|
|
|
"""The connection type for TimelineItem"""
|
|
type TimelineItemConnection {
|
|
edges: [TimelineItemEdge!]!
|
|
nodes: [TimelineItem!]!
|
|
pageInfo: PageInfo!
|
|
totalCount: Int!
|
|
}
|
|
|
|
"""Represent a TimelineItem"""
|
|
type TimelineItemEdge {
|
|
cursor: String!
|
|
node: TimelineItem!
|
|
}
|
|
|
|
# Items
|
|
|
|
"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
|
|
type CreateTimelineItem implements TimelineItem & Authored {
|
|
"""The hash of the source operation"""
|
|
hash: Hash!
|
|
author: Identity!
|
|
message: String!
|
|
messageIsEmpty: Boolean!
|
|
files: [Hash!]!
|
|
createdAt: Time!
|
|
lastEdit: Time!
|
|
edited: Boolean!
|
|
history: [CommentHistoryStep!]!
|
|
}
|
|
|
|
"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
|
|
type AddCommentTimelineItem implements TimelineItem & Authored {
|
|
"""The hash of the source operation"""
|
|
hash: Hash!
|
|
author: Identity!
|
|
message: String!
|
|
messageIsEmpty: Boolean!
|
|
files: [Hash!]!
|
|
createdAt: Time!
|
|
lastEdit: Time!
|
|
edited: Boolean!
|
|
history: [CommentHistoryStep!]!
|
|
}
|
|
|
|
"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
|
|
type LabelChangeTimelineItem implements TimelineItem & Authored {
|
|
"""The hash of the source operation"""
|
|
hash: Hash!
|
|
author: Identity!
|
|
date: Time!
|
|
added: [Label!]!
|
|
removed: [Label!]!
|
|
}
|
|
|
|
"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
|
|
type SetStatusTimelineItem implements TimelineItem & Authored {
|
|
"""The hash of the source operation"""
|
|
hash: Hash!
|
|
author: Identity!
|
|
date: Time!
|
|
status: Status!
|
|
}
|
|
|
|
"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
|
|
type SetTitleTimelineItem implements TimelineItem & Authored {
|
|
"""The 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 Hash
|
|
|
|
"""Defines a color by red, green and blue components."""
|
|
type Color {
|
|
"""Red component of the color."""
|
|
R: Int!
|
|
"""Green component of the color."""
|
|
G: Int!
|
|
"""Blue component of the color."""
|
|
B: Int!
|
|
}
|
|
|
|
"""Label for a bug."""
|
|
type Label {
|
|
"""The name of the label."""
|
|
name: String!
|
|
"""Color of the label."""
|
|
color: Color!
|
|
}
|
|
|
|
"""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!
|
|
}
|
|
|
|
"""An object that has an author."""
|
|
interface Authored {
|
|
"""The author of this object."""
|
|
author: Identity!
|
|
}
|
|
`},
|
|
)
|
|
|
|
// endregion ************************** generated!.gotpl **************************
|
|
|
|
// region ***************************** args.gotpl *****************************
|
|
|
|
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["after"] = arg0
|
|
var arg1 *string
|
|
if tmp, ok := rawArgs["before"]; ok {
|
|
arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
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["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
|
|
}
|
|
|
|
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["after"] = arg0
|
|
var arg1 *string
|
|
if tmp, ok := rawArgs["before"]; ok {
|
|
arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
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["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
|
|
}
|
|
|
|
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["after"] = arg0
|
|
var arg1 *string
|
|
if tmp, ok := rawArgs["before"]; ok {
|
|
arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
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["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
|
|
}
|
|
|
|
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["after"] = arg0
|
|
var arg1 *string
|
|
if tmp, ok := rawArgs["before"]; ok {
|
|
arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
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["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
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|
|
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
|
|
}
|
|
}
|
|
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["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
|
|
}
|
|
|
|
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 models.AddCommentInput
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["input"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
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 *models.ChangeLabelInput
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["input"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
var err error
|
|
args := map[string]interface{}{}
|
|
var arg0 models.CloseBugInput
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["input"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Mutation_commitAsNeeded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
var err error
|
|
args := map[string]interface{}{}
|
|
var arg0 models.CommitAsNeededInput
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
arg0, err = ec.unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["input"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
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 models.CommitInput
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
arg0, err = ec.unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["input"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
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 models.NewBugInput
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["input"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
|
|
var err error
|
|
args := map[string]interface{}{}
|
|
var arg0 models.OpenBugInput
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["input"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
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 models.SetTitleInput
|
|
if tmp, ok := rawArgs["input"]; ok {
|
|
arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["input"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
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["ref"]; ok {
|
|
arg0, err = ec.unmarshalNString2string(ctx, tmp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
args["ref"] = arg0
|
|
return args, nil
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|
|
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
|
|
}
|
|
}
|
|
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["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
|
|
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
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|
|
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
|
|
}
|
|
}
|
|
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["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
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
// endregion ***************************** args.gotpl *****************************
|
|
|
|
// 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) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "AddCommentPayload",
|
|
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.ClientMutationID, nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "AddCommentPayload",
|
|
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.Bug, 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) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "AddCommentPayload",
|
|
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.Operation, nil
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*bug.AddCommentOperation)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(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.marshalNPageInfo2ᚖgithubᚗ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.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "ChangeLabelPayload",
|
|
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.ClientMutationID, nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "ChangeLabelPayload",
|
|
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.Bug, 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) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "ChangeLabelPayload",
|
|
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.Operation, nil
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*bug.LabelChangeOperation)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "ChangeLabelPayload",
|
|
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.Results, nil
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]*bug.LabelChangeResult)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "CloseBugPayload",
|
|
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.ClientMutationID, nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "CloseBugPayload",
|
|
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.Bug, 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) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "CloseBugPayload",
|
|
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.Operation, nil
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*bug.SetStatusOperation)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Color",
|
|
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.Color().R(rctx, obj)
|
|
})
|
|
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) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Color",
|
|
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.Color().G(rctx, obj)
|
|
})
|
|
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) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Color",
|
|
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.Color().B(rctx, obj)
|
|
})
|
|
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) _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.marshalNPageInfo2ᚖgithubᚗ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.marshalNComment2ᚖgithubᚗ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) _CommitAsNeededPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "CommitAsNeededPayload",
|
|
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.ClientMutationID, nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _CommitAsNeededPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "CommitAsNeededPayload",
|
|
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.Bug, 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) _CommitPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "CommitPayload",
|
|
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.ClientMutationID, nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _CommitPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "CommitPayload",
|
|
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.Bug, 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) _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)
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
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 graphql.Null
|
|
}
|
|
res := resTmp.(bool)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
|
|
}
|
|
|
|
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
|
|
})
|
|
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_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)
|
|
})
|
|
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) _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)
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
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,
|
|
}
|
|
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) _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: "EditCommentOperation",
|
|
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) _EditCommentOperation_author(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: "EditCommentOperation",
|
|
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) _EditCommentOperation_date(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: "EditCommentOperation",
|
|
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.EditCommentOperation().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) _EditCommentOperation_target(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: "EditCommentOperation",
|
|
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.Target, 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) _EditCommentOperation_message(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: "EditCommentOperation",
|
|
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) _EditCommentOperation_files(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: "EditCommentOperation",
|
|
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) _Identity_id(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Identity",
|
|
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.Identity().ID(rctx, obj)
|
|
})
|
|
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) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Identity",
|
|
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.Identity().HumanID(rctx, obj)
|
|
})
|
|
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) _Identity_name(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Identity",
|
|
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.Identity().Name(rctx, obj)
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Identity",
|
|
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.Identity().Email(rctx, obj)
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Identity_login(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Identity",
|
|
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.Identity().Login(rctx, obj)
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Identity",
|
|
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.Identity().DisplayName(rctx, obj)
|
|
})
|
|
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) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Identity",
|
|
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.Identity().AvatarURL(rctx, obj)
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Identity",
|
|
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.Identity().IsProtected(rctx, obj)
|
|
})
|
|
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) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "IdentityConnection",
|
|
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.IdentityEdge)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "IdentityConnection",
|
|
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.([]identity.Interface)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "IdentityConnection",
|
|
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.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "IdentityConnection",
|
|
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) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "IdentityEdge",
|
|
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) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "IdentityEdge",
|
|
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.(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) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Label",
|
|
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.Label().Name(rctx, obj)
|
|
})
|
|
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) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Label",
|
|
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.Label().Color(rctx, obj)
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*color.RGBA)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _LabelChangeOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "LabelChangeOperation",
|
|
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) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "LabelChangeOperation",
|
|
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) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "LabelChangeOperation",
|
|
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.LabelChangeOperation().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) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "LabelChangeOperation",
|
|
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.Added, 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) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "LabelChangeOperation",
|
|
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.Removed, 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) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "LabelChangeResult",
|
|
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.Label, 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.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "LabelChangeResult",
|
|
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.LabelChangeResult().Status(rctx, obj)
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(models.LabelChangeStatus)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _LabelChangeTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "LabelChangeTimelineItem",
|
|
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) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "LabelChangeTimelineItem",
|
|
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) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "LabelChangeTimelineItem",
|
|
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.LabelChangeTimelineItem().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) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "LabelChangeTimelineItem",
|
|
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.Added, 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) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "LabelChangeTimelineItem",
|
|
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.Removed, 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) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_newBug_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, nil, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.NewBugPayload)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_addComment_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, nil, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.AddCommentPayload)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_changeLabels_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, nil, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.ChangeLabelPayload)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_openBug_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, nil, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.OpenBugPayload)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_closeBug_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, nil, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.CloseBugPayload)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_setTitle_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, nil, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.SetTitlePayload)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_commit(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_commit_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, nil, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().Commit(rctx, args["input"].(models.CommitInput))
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.CommitPayload)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Mutation_commitAsNeeded(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Mutation_commitAsNeeded_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, nil, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Mutation().CommitAsNeeded(rctx, args["input"].(models.CommitAsNeededInput))
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.CommitAsNeededPayload)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "NewBugPayload",
|
|
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.ClientMutationID, nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "NewBugPayload",
|
|
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.Bug, 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) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "NewBugPayload",
|
|
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.Operation, nil
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*bug.CreateOperation)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "OpenBugPayload",
|
|
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.ClientMutationID, nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "OpenBugPayload",
|
|
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.Bug, 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) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "OpenBugPayload",
|
|
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.Operation, nil
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*bug.SetStatusOperation)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "OperationConnection",
|
|
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.OperationEdge)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "OperationConnection",
|
|
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.Operation)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "OperationConnection",
|
|
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.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "OperationConnection",
|
|
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) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "OperationEdge",
|
|
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) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "OperationEdge",
|
|
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.Operation)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PageInfo",
|
|
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.HasNextPage, 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) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PageInfo",
|
|
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.HasPreviousPage, 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) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PageInfo",
|
|
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.StartCursor, 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) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "PageInfo",
|
|
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.EndCursor, 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) _Query_defaultRepository(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Query",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Query().DefaultRepository(rctx)
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.Repository)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Query",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Query_repository_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, nil, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.resolvers.Query().Repository(rctx, args["ref"].(string))
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.Repository)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Query",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Query___type_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, nil, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.introspectType(args["name"].(string))
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*introspection.Type)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Query",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
|
|
resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
|
|
ctx = rctx // use context from middleware stack in children
|
|
return ec.introspectSchema()
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*introspection.Schema)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalO__Schema2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Repository",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Repository_allBugs_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.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*models.BugConnection)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Repository",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Repository_bug_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.Repository().Bug(rctx, obj, args["prefix"].(string))
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*bug.Snapshot)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Repository",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Repository_allIdentities_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.Repository().AllIdentities(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) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Repository",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field_Repository_identity_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.Repository().Identity(rctx, obj, args["prefix"].(string))
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(identity.Interface)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Repository",
|
|
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.Repository().UserIdentity(rctx, obj)
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(identity.Interface)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "Repository",
|
|
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.Repository().ValidLabels(rctx, obj)
|
|
})
|
|
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) _SetStatusOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetStatusOperation",
|
|
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) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetStatusOperation",
|
|
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) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetStatusOperation",
|
|
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.SetStatusOperation().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) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetStatusOperation",
|
|
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.SetStatusOperation().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) _SetStatusTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetStatusTimelineItem",
|
|
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) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetStatusTimelineItem",
|
|
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) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetStatusTimelineItem",
|
|
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.SetStatusTimelineItem().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) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetStatusTimelineItem",
|
|
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.SetStatusTimelineItem().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) _SetTitleOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetTitleOperation",
|
|
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) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetTitleOperation",
|
|
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) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetTitleOperation",
|
|
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.SetTitleOperation().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) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetTitleOperation",
|
|
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) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetTitleOperation",
|
|
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.Was, 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) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetTitlePayload",
|
|
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.ClientMutationID, nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetTitlePayload",
|
|
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.Bug, 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) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetTitlePayload",
|
|
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.Operation, nil
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*bug.SetTitleOperation)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _SetTitleTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetTitleTimelineItem",
|
|
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) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetTitleTimelineItem",
|
|
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) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetTitleTimelineItem",
|
|
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.SetTitleTimelineItem().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) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetTitleTimelineItem",
|
|
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) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "SetTitleTimelineItem",
|
|
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.Was, 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) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "TimelineItemConnection",
|
|
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.TimelineItemEdge)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "TimelineItemConnection",
|
|
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.TimelineItem)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "TimelineItemConnection",
|
|
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.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "TimelineItemConnection",
|
|
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) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "TimelineItemEdge",
|
|
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) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "TimelineItemEdge",
|
|
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.TimelineItem)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Directive",
|
|
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.Name, 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) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Directive",
|
|
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.Description, nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Directive",
|
|
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.Locations, 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.marshalN__DirectiveLocation2ᚕstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Directive",
|
|
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.Args, nil
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]introspection.InputValue)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalN__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__EnumValue",
|
|
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.Name, 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) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__EnumValue",
|
|
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.Description, nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__EnumValue",
|
|
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.IsDeprecated(), 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) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__EnumValue",
|
|
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.DeprecationReason(), nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Field",
|
|
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.Name, 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) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Field",
|
|
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.Description, nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Field",
|
|
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.Args, nil
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]introspection.InputValue)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalN__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Field",
|
|
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.Type, nil
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*introspection.Type)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Field",
|
|
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.IsDeprecated(), 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) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Field",
|
|
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.DeprecationReason(), nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__InputValue",
|
|
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.Name, 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) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__InputValue",
|
|
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.Description, nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__InputValue",
|
|
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.Type, nil
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*introspection.Type)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__InputValue",
|
|
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.DefaultValue, nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Schema",
|
|
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.Types(), nil
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]introspection.Type)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalN__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Schema",
|
|
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.QueryType(), nil
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*introspection.Type)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Schema",
|
|
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.MutationType(), nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*introspection.Type)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Schema",
|
|
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.SubscriptionType(), nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*introspection.Type)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Schema",
|
|
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.Directives(), nil
|
|
})
|
|
if resTmp == nil {
|
|
if !ec.HasError(rctx) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]introspection.Directive)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalN__Directive2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
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.Kind(), 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.marshalN__TypeKind2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
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.Name(), nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
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.Description(), nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(string)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalOString2string(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field___Type_fields_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 obj.Fields(args["includeDeprecated"].(bool)), nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]introspection.Field)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalO__Field2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
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.Interfaces(), nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]introspection.Type)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalO__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
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.PossibleTypes(), nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]introspection.Type)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalO__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
Field: field,
|
|
Args: nil,
|
|
IsMethod: true,
|
|
}
|
|
ctx = graphql.WithResolverContext(ctx, rctx)
|
|
rawArgs := field.ArgumentMap(ec.Variables)
|
|
args, err := ec.field___Type_enumValues_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 obj.EnumValues(args["includeDeprecated"].(bool)), nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]introspection.EnumValue)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
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.InputFields(), nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.([]introspection.InputValue)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalO__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
|
|
}
|
|
|
|
func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
|
|
ctx = ec.Tracer.StartFieldExecution(ctx, field)
|
|
defer func() { ec.Tracer.EndFieldExecution(ctx) }()
|
|
rctx := &graphql.ResolverContext{
|
|
Object: "__Type",
|
|
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.OfType(), nil
|
|
})
|
|
if resTmp == nil {
|
|
return graphql.Null
|
|
}
|
|
res := resTmp.(*introspection.Type)
|
|
rctx.Result = res
|
|
ctx = ec.Tracer.StartFieldChildExecution(ctx)
|
|
return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
|
|
}
|
|
|
|
// endregion **************************** field.gotpl *****************************
|
|
|
|
// region **************************** input.gotpl *****************************
|
|
|
|
func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
|
|
var it models.AddCommentInput
|
|
var asMap = v.(map[string]interface{})
|
|
|
|
for k, v := range asMap {
|
|
switch k {
|
|
case "clientMutationId":
|
|
var err error
|
|
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "repoRef":
|
|
var err error
|
|
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "prefix":
|
|
var err error
|
|
it.Prefix, err = ec.unmarshalNString2string(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "message":
|
|
var err error
|
|
it.Message, err = ec.unmarshalNString2string(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "files":
|
|
var err error
|
|
it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
}
|
|
}
|
|
|
|
return it, nil
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
|
|
var it models.ChangeLabelInput
|
|
var asMap = v.(map[string]interface{})
|
|
|
|
for k, v := range asMap {
|
|
switch k {
|
|
case "clientMutationId":
|
|
var err error
|
|
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "repoRef":
|
|
var err error
|
|
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "prefix":
|
|
var err error
|
|
it.Prefix, err = ec.unmarshalNString2string(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "added":
|
|
var err error
|
|
it.Added, err = ec.unmarshalOString2ᚕstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "Removed":
|
|
var err error
|
|
it.Removed, err = ec.unmarshalOString2ᚕstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
}
|
|
}
|
|
|
|
return it, nil
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
|
|
var it models.CloseBugInput
|
|
var asMap = v.(map[string]interface{})
|
|
|
|
for k, v := range asMap {
|
|
switch k {
|
|
case "clientMutationId":
|
|
var err error
|
|
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "repoRef":
|
|
var err error
|
|
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "prefix":
|
|
var err error
|
|
it.Prefix, err = ec.unmarshalNString2string(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
}
|
|
}
|
|
|
|
return it, nil
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalInputCommitAsNeededInput(ctx context.Context, v interface{}) (models.CommitAsNeededInput, error) {
|
|
var it models.CommitAsNeededInput
|
|
var asMap = v.(map[string]interface{})
|
|
|
|
for k, v := range asMap {
|
|
switch k {
|
|
case "clientMutationId":
|
|
var err error
|
|
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "repoRef":
|
|
var err error
|
|
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "prefix":
|
|
var err error
|
|
it.Prefix, err = ec.unmarshalNString2string(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
}
|
|
}
|
|
|
|
return it, nil
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalInputCommitInput(ctx context.Context, v interface{}) (models.CommitInput, error) {
|
|
var it models.CommitInput
|
|
var asMap = v.(map[string]interface{})
|
|
|
|
for k, v := range asMap {
|
|
switch k {
|
|
case "clientMutationId":
|
|
var err error
|
|
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "repoRef":
|
|
var err error
|
|
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "prefix":
|
|
var err error
|
|
it.Prefix, err = ec.unmarshalNString2string(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
}
|
|
}
|
|
|
|
return it, nil
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
|
|
var it models.NewBugInput
|
|
var asMap = v.(map[string]interface{})
|
|
|
|
for k, v := range asMap {
|
|
switch k {
|
|
case "clientMutationId":
|
|
var err error
|
|
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "repoRef":
|
|
var err error
|
|
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "title":
|
|
var err error
|
|
it.Title, err = ec.unmarshalNString2string(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "message":
|
|
var err error
|
|
it.Message, err = ec.unmarshalNString2string(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "files":
|
|
var err error
|
|
it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
}
|
|
}
|
|
|
|
return it, nil
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
|
|
var it models.OpenBugInput
|
|
var asMap = v.(map[string]interface{})
|
|
|
|
for k, v := range asMap {
|
|
switch k {
|
|
case "clientMutationId":
|
|
var err error
|
|
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "repoRef":
|
|
var err error
|
|
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "prefix":
|
|
var err error
|
|
it.Prefix, err = ec.unmarshalNString2string(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
}
|
|
}
|
|
|
|
return it, nil
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
|
|
var it models.SetTitleInput
|
|
var asMap = v.(map[string]interface{})
|
|
|
|
for k, v := range asMap {
|
|
switch k {
|
|
case "clientMutationId":
|
|
var err error
|
|
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "repoRef":
|
|
var err error
|
|
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "prefix":
|
|
var err error
|
|
it.Prefix, err = ec.unmarshalNString2string(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
case "title":
|
|
var err error
|
|
it.Title, err = ec.unmarshalNString2string(ctx, v)
|
|
if err != nil {
|
|
return it, err
|
|
}
|
|
}
|
|
}
|
|
|
|
return it, nil
|
|
}
|
|
|
|
// endregion **************************** input.gotpl *****************************
|
|
|
|
// region ************************** interface.gotpl ***************************
|
|
|
|
func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj *models.Authored) graphql.Marshaler {
|
|
switch obj := (*obj).(type) {
|
|
case nil:
|
|
return graphql.Null
|
|
case bug.Comment:
|
|
return ec._Comment(ctx, sel, &obj)
|
|
case *bug.Comment:
|
|
return ec._Comment(ctx, sel, obj)
|
|
case *bug.Snapshot:
|
|
return ec._Bug(ctx, sel, obj)
|
|
case *bug.CreateOperation:
|
|
return ec._CreateOperation(ctx, sel, obj)
|
|
case *bug.SetTitleOperation:
|
|
return ec._SetTitleOperation(ctx, sel, obj)
|
|
case *bug.AddCommentOperation:
|
|
return ec._AddCommentOperation(ctx, sel, obj)
|
|
case *bug.EditCommentOperation:
|
|
return ec._EditCommentOperation(ctx, sel, obj)
|
|
case *bug.SetStatusOperation:
|
|
return ec._SetStatusOperation(ctx, sel, obj)
|
|
case *bug.LabelChangeOperation:
|
|
return ec._LabelChangeOperation(ctx, sel, obj)
|
|
case *bug.CreateTimelineItem:
|
|
return ec._CreateTimelineItem(ctx, sel, obj)
|
|
case *bug.AddCommentTimelineItem:
|
|
return ec._AddCommentTimelineItem(ctx, sel, obj)
|
|
case *bug.LabelChangeTimelineItem:
|
|
return ec._LabelChangeTimelineItem(ctx, sel, obj)
|
|
case *bug.SetStatusTimelineItem:
|
|
return ec._SetStatusTimelineItem(ctx, sel, obj)
|
|
case *bug.SetTitleTimelineItem:
|
|
return ec._SetTitleTimelineItem(ctx, sel, obj)
|
|
default:
|
|
panic(fmt.Errorf("unexpected type %T", obj))
|
|
}
|
|
}
|
|
|
|
func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj *bug.Operation) graphql.Marshaler {
|
|
switch obj := (*obj).(type) {
|
|
case nil:
|
|
return graphql.Null
|
|
case *bug.CreateOperation:
|
|
return ec._CreateOperation(ctx, sel, obj)
|
|
case *bug.SetTitleOperation:
|
|
return ec._SetTitleOperation(ctx, sel, obj)
|
|
case *bug.AddCommentOperation:
|
|
return ec._AddCommentOperation(ctx, sel, obj)
|
|
case *bug.EditCommentOperation:
|
|
return ec._EditCommentOperation(ctx, sel, obj)
|
|
case *bug.SetStatusOperation:
|
|
return ec._SetStatusOperation(ctx, sel, obj)
|
|
case *bug.LabelChangeOperation:
|
|
return ec._LabelChangeOperation(ctx, sel, obj)
|
|
default:
|
|
panic(fmt.Errorf("unexpected type %T", obj))
|
|
}
|
|
}
|
|
|
|
func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.TimelineItem) graphql.Marshaler {
|
|
switch obj := (*obj).(type) {
|
|
case nil:
|
|
return graphql.Null
|
|
case *bug.CreateTimelineItem:
|
|
return ec._CreateTimelineItem(ctx, sel, obj)
|
|
case *bug.AddCommentTimelineItem:
|
|
return ec._AddCommentTimelineItem(ctx, sel, obj)
|
|
case bug.LabelChangeTimelineItem:
|
|
return ec._LabelChangeTimelineItem(ctx, sel, &obj)
|
|
case *bug.LabelChangeTimelineItem:
|
|
return ec._LabelChangeTimelineItem(ctx, sel, obj)
|
|
case bug.SetStatusTimelineItem:
|
|
return ec._SetStatusTimelineItem(ctx, sel, &obj)
|
|
case *bug.SetStatusTimelineItem:
|
|
return ec._SetStatusTimelineItem(ctx, sel, obj)
|
|
case bug.SetTitleTimelineItem:
|
|
return ec._SetTitleTimelineItem(ctx, sel, &obj)
|
|
case *bug.SetTitleTimelineItem:
|
|
return ec._SetTitleTimelineItem(ctx, sel, obj)
|
|
default:
|
|
panic(fmt.Errorf("unexpected type %T", obj))
|
|
}
|
|
}
|
|
|
|
// endregion ************************** interface.gotpl ***************************
|
|
|
|
// region **************************** object.gotpl ****************************
|
|
|
|
var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
|
|
|
|
func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, addCommentOperationImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
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 {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "author":
|
|
out.Values[i] = ec._AddCommentOperation_author(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "date":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._AddCommentOperation_date(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "message":
|
|
out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "files":
|
|
out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var addCommentPayloadImplementors = []string{"AddCommentPayload"}
|
|
|
|
func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, addCommentPayloadImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("AddCommentPayload")
|
|
case "clientMutationId":
|
|
out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
|
|
case "bug":
|
|
out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "operation":
|
|
out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
|
|
|
|
func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, addCommentTimelineItemImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
|
|
case "hash":
|
|
out.Values[i] = ec._AddCommentTimelineItem_hash(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "author":
|
|
out.Values[i] = ec._AddCommentTimelineItem_author(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "message":
|
|
out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "messageIsEmpty":
|
|
out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "files":
|
|
out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "createdAt":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "lastEdit":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "edited":
|
|
out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "history":
|
|
out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var bugImplementors = []string{"Bug", "Authored"}
|
|
|
|
func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj *bug.Snapshot) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, bugImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("Bug")
|
|
case "id":
|
|
out.Values[i] = ec._Bug_id(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "humanId":
|
|
out.Values[i] = ec._Bug_humanId(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "status":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Bug_status(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "title":
|
|
out.Values[i] = ec._Bug_title(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "labels":
|
|
out.Values[i] = ec._Bug_labels(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "author":
|
|
out.Values[i] = ec._Bug_author(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "createdAt":
|
|
out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "lastEdit":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Bug_lastEdit(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "actors":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Bug_actors(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "participants":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Bug_participants(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "comments":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Bug_comments(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "timeline":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Bug_timeline(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "operations":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Bug_operations(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var bugConnectionImplementors = []string{"BugConnection"}
|
|
|
|
func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, bugConnectionImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("BugConnection")
|
|
case "edges":
|
|
out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "nodes":
|
|
out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "pageInfo":
|
|
out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "totalCount":
|
|
out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var bugEdgeImplementors = []string{"BugEdge"}
|
|
|
|
func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, bugEdgeImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("BugEdge")
|
|
case "cursor":
|
|
out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "node":
|
|
out.Values[i] = ec._BugEdge_node(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
|
|
|
|
func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, changeLabelPayloadImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
|
|
case "clientMutationId":
|
|
out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
|
|
case "bug":
|
|
out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "operation":
|
|
out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "results":
|
|
out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var closeBugPayloadImplementors = []string{"CloseBugPayload"}
|
|
|
|
func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, closeBugPayloadImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("CloseBugPayload")
|
|
case "clientMutationId":
|
|
out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
|
|
case "bug":
|
|
out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "operation":
|
|
out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var colorImplementors = []string{"Color"}
|
|
|
|
func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, colorImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("Color")
|
|
case "R":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Color_R(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "G":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Color_G(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "B":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Color_B(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var commentImplementors = []string{"Comment", "Authored"}
|
|
|
|
func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, commentImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("Comment")
|
|
case "author":
|
|
out.Values[i] = ec._Comment_author(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "message":
|
|
out.Values[i] = ec._Comment_message(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "files":
|
|
out.Values[i] = ec._Comment_files(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var commentConnectionImplementors = []string{"CommentConnection"}
|
|
|
|
func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, commentConnectionImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("CommentConnection")
|
|
case "edges":
|
|
out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "nodes":
|
|
out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "pageInfo":
|
|
out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "totalCount":
|
|
out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var commentEdgeImplementors = []string{"CommentEdge"}
|
|
|
|
func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, commentEdgeImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("CommentEdge")
|
|
case "cursor":
|
|
out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "node":
|
|
out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
|
|
|
|
func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, commentHistoryStepImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("CommentHistoryStep")
|
|
case "message":
|
|
out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "date":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._CommentHistoryStep_date(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var commitAsNeededPayloadImplementors = []string{"CommitAsNeededPayload"}
|
|
|
|
func (ec *executionContext) _CommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitAsNeededPayload) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, commitAsNeededPayloadImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("CommitAsNeededPayload")
|
|
case "clientMutationId":
|
|
out.Values[i] = ec._CommitAsNeededPayload_clientMutationId(ctx, field, obj)
|
|
case "bug":
|
|
out.Values[i] = ec._CommitAsNeededPayload_bug(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var commitPayloadImplementors = []string{"CommitPayload"}
|
|
|
|
func (ec *executionContext) _CommitPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitPayload) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, commitPayloadImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("CommitPayload")
|
|
case "clientMutationId":
|
|
out.Values[i] = ec._CommitPayload_clientMutationId(ctx, field, obj)
|
|
case "bug":
|
|
out.Values[i] = ec._CommitPayload_bug(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
|
|
|
|
func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, createOperationImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("CreateOperation")
|
|
case "hash":
|
|
out.Values[i] = ec._CreateOperation_hash(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "author":
|
|
out.Values[i] = ec._CreateOperation_author(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "date":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._CreateOperation_date(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "title":
|
|
out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "message":
|
|
out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "files":
|
|
out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
|
|
|
|
func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, createTimelineItemImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("CreateTimelineItem")
|
|
case "hash":
|
|
out.Values[i] = ec._CreateTimelineItem_hash(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "author":
|
|
out.Values[i] = ec._CreateTimelineItem_author(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "message":
|
|
out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "messageIsEmpty":
|
|
out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "files":
|
|
out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "createdAt":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "lastEdit":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "edited":
|
|
out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "history":
|
|
out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
|
|
|
|
func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, editCommentOperationImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("EditCommentOperation")
|
|
case "hash":
|
|
out.Values[i] = ec._EditCommentOperation_hash(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "author":
|
|
out.Values[i] = ec._EditCommentOperation_author(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "date":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._EditCommentOperation_date(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "target":
|
|
out.Values[i] = ec._EditCommentOperation_target(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "message":
|
|
out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "files":
|
|
out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var identityImplementors = []string{"Identity"}
|
|
|
|
func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj *identity.Interface) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, identityImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("Identity")
|
|
case "id":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Identity_id(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "humanId":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Identity_humanId(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "name":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Identity_name(ctx, field, obj)
|
|
return res
|
|
})
|
|
case "email":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Identity_email(ctx, field, obj)
|
|
return res
|
|
})
|
|
case "login":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Identity_login(ctx, field, obj)
|
|
return res
|
|
})
|
|
case "displayName":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Identity_displayName(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "avatarUrl":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Identity_avatarUrl(ctx, field, obj)
|
|
return res
|
|
})
|
|
case "isProtected":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Identity_isProtected(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var identityConnectionImplementors = []string{"IdentityConnection"}
|
|
|
|
func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, identityConnectionImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("IdentityConnection")
|
|
case "edges":
|
|
out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "nodes":
|
|
out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "pageInfo":
|
|
out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "totalCount":
|
|
out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var identityEdgeImplementors = []string{"IdentityEdge"}
|
|
|
|
func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, identityEdgeImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("IdentityEdge")
|
|
case "cursor":
|
|
out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "node":
|
|
out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var labelImplementors = []string{"Label"}
|
|
|
|
func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, labelImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("Label")
|
|
case "name":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Label_name(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "color":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Label_color(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
|
|
|
|
func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeOperationImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("LabelChangeOperation")
|
|
case "hash":
|
|
out.Values[i] = ec._LabelChangeOperation_hash(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "author":
|
|
out.Values[i] = ec._LabelChangeOperation_author(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "date":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._LabelChangeOperation_date(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "added":
|
|
out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "removed":
|
|
out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var labelChangeResultImplementors = []string{"LabelChangeResult"}
|
|
|
|
func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeResultImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("LabelChangeResult")
|
|
case "label":
|
|
out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "status":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._LabelChangeResult_status(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
|
|
|
|
func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeTimelineItemImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
|
|
case "hash":
|
|
out.Values[i] = ec._LabelChangeTimelineItem_hash(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "author":
|
|
out.Values[i] = ec._LabelChangeTimelineItem_author(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "date":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "added":
|
|
out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "removed":
|
|
out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var mutationImplementors = []string{"Mutation"}
|
|
|
|
func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, mutationImplementors)
|
|
|
|
ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
|
|
Object: "Mutation",
|
|
})
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("Mutation")
|
|
case "newBug":
|
|
out.Values[i] = ec._Mutation_newBug(ctx, field)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "addComment":
|
|
out.Values[i] = ec._Mutation_addComment(ctx, field)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "changeLabels":
|
|
out.Values[i] = ec._Mutation_changeLabels(ctx, field)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "openBug":
|
|
out.Values[i] = ec._Mutation_openBug(ctx, field)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "closeBug":
|
|
out.Values[i] = ec._Mutation_closeBug(ctx, field)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "setTitle":
|
|
out.Values[i] = ec._Mutation_setTitle(ctx, field)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "commit":
|
|
out.Values[i] = ec._Mutation_commit(ctx, field)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "commitAsNeeded":
|
|
out.Values[i] = ec._Mutation_commitAsNeeded(ctx, field)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var newBugPayloadImplementors = []string{"NewBugPayload"}
|
|
|
|
func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, newBugPayloadImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("NewBugPayload")
|
|
case "clientMutationId":
|
|
out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
|
|
case "bug":
|
|
out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "operation":
|
|
out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var openBugPayloadImplementors = []string{"OpenBugPayload"}
|
|
|
|
func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, openBugPayloadImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("OpenBugPayload")
|
|
case "clientMutationId":
|
|
out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
|
|
case "bug":
|
|
out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "operation":
|
|
out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var operationConnectionImplementors = []string{"OperationConnection"}
|
|
|
|
func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, operationConnectionImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("OperationConnection")
|
|
case "edges":
|
|
out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "nodes":
|
|
out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "pageInfo":
|
|
out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "totalCount":
|
|
out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var operationEdgeImplementors = []string{"OperationEdge"}
|
|
|
|
func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, operationEdgeImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("OperationEdge")
|
|
case "cursor":
|
|
out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "node":
|
|
out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var pageInfoImplementors = []string{"PageInfo"}
|
|
|
|
func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, pageInfoImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("PageInfo")
|
|
case "hasNextPage":
|
|
out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "hasPreviousPage":
|
|
out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "startCursor":
|
|
out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "endCursor":
|
|
out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var queryImplementors = []string{"Query"}
|
|
|
|
func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, queryImplementors)
|
|
|
|
ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
|
|
Object: "Query",
|
|
})
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("Query")
|
|
case "defaultRepository":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Query_defaultRepository(ctx, field)
|
|
return res
|
|
})
|
|
case "repository":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Query_repository(ctx, field)
|
|
return res
|
|
})
|
|
case "__type":
|
|
out.Values[i] = ec._Query___type(ctx, field)
|
|
case "__schema":
|
|
out.Values[i] = ec._Query___schema(ctx, field)
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var repositoryImplementors = []string{"Repository"}
|
|
|
|
func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, repositoryImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("Repository")
|
|
case "allBugs":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Repository_allBugs(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "bug":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Repository_bug(ctx, field, obj)
|
|
return res
|
|
})
|
|
case "allIdentities":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Repository_allIdentities(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "identity":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Repository_identity(ctx, field, obj)
|
|
return res
|
|
})
|
|
case "userIdentity":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Repository_userIdentity(ctx, field, obj)
|
|
return res
|
|
})
|
|
case "validLabels":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._Repository_validLabels(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
|
|
|
|
func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, setStatusOperationImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("SetStatusOperation")
|
|
case "hash":
|
|
out.Values[i] = ec._SetStatusOperation_hash(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "author":
|
|
out.Values[i] = ec._SetStatusOperation_author(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "date":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._SetStatusOperation_date(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "status":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._SetStatusOperation_status(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
|
|
|
|
func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, setStatusTimelineItemImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
|
|
case "hash":
|
|
out.Values[i] = ec._SetStatusTimelineItem_hash(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "author":
|
|
out.Values[i] = ec._SetStatusTimelineItem_author(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "date":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._SetStatusTimelineItem_date(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "status":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._SetStatusTimelineItem_status(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
|
|
|
|
func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, setTitleOperationImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("SetTitleOperation")
|
|
case "hash":
|
|
out.Values[i] = ec._SetTitleOperation_hash(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "author":
|
|
out.Values[i] = ec._SetTitleOperation_author(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "date":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._SetTitleOperation_date(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "title":
|
|
out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "was":
|
|
out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var setTitlePayloadImplementors = []string{"SetTitlePayload"}
|
|
|
|
func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, setTitlePayloadImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("SetTitlePayload")
|
|
case "clientMutationId":
|
|
out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
|
|
case "bug":
|
|
out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "operation":
|
|
out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
|
|
|
|
func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, setTitleTimelineItemImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
|
|
case "hash":
|
|
out.Values[i] = ec._SetTitleTimelineItem_hash(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "author":
|
|
out.Values[i] = ec._SetTitleTimelineItem_author(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "date":
|
|
field := field
|
|
out.Concurrently(i, func() (res graphql.Marshaler) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
}
|
|
}()
|
|
res = ec._SetTitleTimelineItem_date(ctx, field, obj)
|
|
if res == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
return res
|
|
})
|
|
case "title":
|
|
out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
case "was":
|
|
out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
atomic.AddUint32(&invalids, 1)
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
|
|
|
|
func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, timelineItemConnectionImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("TimelineItemConnection")
|
|
case "edges":
|
|
out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "nodes":
|
|
out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "pageInfo":
|
|
out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "totalCount":
|
|
out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
|
|
|
|
func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, timelineItemEdgeImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("TimelineItemEdge")
|
|
case "cursor":
|
|
out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "node":
|
|
out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var __DirectiveImplementors = []string{"__Directive"}
|
|
|
|
func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, __DirectiveImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("__Directive")
|
|
case "name":
|
|
out.Values[i] = ec.___Directive_name(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "description":
|
|
out.Values[i] = ec.___Directive_description(ctx, field, obj)
|
|
case "locations":
|
|
out.Values[i] = ec.___Directive_locations(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "args":
|
|
out.Values[i] = ec.___Directive_args(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var __EnumValueImplementors = []string{"__EnumValue"}
|
|
|
|
func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, __EnumValueImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("__EnumValue")
|
|
case "name":
|
|
out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "description":
|
|
out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
|
|
case "isDeprecated":
|
|
out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "deprecationReason":
|
|
out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var __FieldImplementors = []string{"__Field"}
|
|
|
|
func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, __FieldImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("__Field")
|
|
case "name":
|
|
out.Values[i] = ec.___Field_name(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "description":
|
|
out.Values[i] = ec.___Field_description(ctx, field, obj)
|
|
case "args":
|
|
out.Values[i] = ec.___Field_args(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "type":
|
|
out.Values[i] = ec.___Field_type(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "isDeprecated":
|
|
out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "deprecationReason":
|
|
out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var __InputValueImplementors = []string{"__InputValue"}
|
|
|
|
func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, __InputValueImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("__InputValue")
|
|
case "name":
|
|
out.Values[i] = ec.___InputValue_name(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "description":
|
|
out.Values[i] = ec.___InputValue_description(ctx, field, obj)
|
|
case "type":
|
|
out.Values[i] = ec.___InputValue_type(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "defaultValue":
|
|
out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var __SchemaImplementors = []string{"__Schema"}
|
|
|
|
func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, __SchemaImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("__Schema")
|
|
case "types":
|
|
out.Values[i] = ec.___Schema_types(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "queryType":
|
|
out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "mutationType":
|
|
out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
|
|
case "subscriptionType":
|
|
out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
|
|
case "directives":
|
|
out.Values[i] = ec.___Schema_directives(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
var __TypeImplementors = []string{"__Type"}
|
|
|
|
func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
|
|
fields := graphql.CollectFields(ec.RequestContext, sel, __TypeImplementors)
|
|
|
|
out := graphql.NewFieldSet(fields)
|
|
var invalids uint32
|
|
for i, field := range fields {
|
|
switch field.Name {
|
|
case "__typename":
|
|
out.Values[i] = graphql.MarshalString("__Type")
|
|
case "kind":
|
|
out.Values[i] = ec.___Type_kind(ctx, field, obj)
|
|
if out.Values[i] == graphql.Null {
|
|
invalids++
|
|
}
|
|
case "name":
|
|
out.Values[i] = ec.___Type_name(ctx, field, obj)
|
|
case "description":
|
|
out.Values[i] = ec.___Type_description(ctx, field, obj)
|
|
case "fields":
|
|
out.Values[i] = ec.___Type_fields(ctx, field, obj)
|
|
case "interfaces":
|
|
out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
|
|
case "possibleTypes":
|
|
out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
|
|
case "enumValues":
|
|
out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
|
|
case "inputFields":
|
|
out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
|
|
case "ofType":
|
|
out.Values[i] = ec.___Type_ofType(ctx, field, obj)
|
|
default:
|
|
panic("unknown field " + strconv.Quote(field.Name))
|
|
}
|
|
}
|
|
out.Dispatch()
|
|
if invalids > 0 {
|
|
return graphql.Null
|
|
}
|
|
return out
|
|
}
|
|
|
|
// endregion **************************** object.gotpl ****************************
|
|
|
|
// region ***************************** type.gotpl *****************************
|
|
|
|
func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
|
|
return ec.unmarshalInputAddCommentInput(ctx, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
|
|
return ec._AddCommentOperation(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._AddCommentOperation(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
|
|
return ec._AddCommentPayload(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._AddCommentPayload(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
|
|
return graphql.UnmarshalBoolean(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
|
|
res := graphql.MarshalBoolean(v)
|
|
if res == graphql.Null {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
|
|
return ec._Bug(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNBug2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v []*bug.Snapshot) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._Bug(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
|
|
return ec._BugConnection(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._BugConnection(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
|
|
return ec._BugEdge(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._BugEdge(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
|
|
return ec._ChangeLabelPayload(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._ChangeLabelPayload(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
|
|
return ec.unmarshalInputCloseBugInput(ctx, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
|
|
return ec._CloseBugPayload(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._CloseBugPayload(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
|
|
return ec._Color(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._Color(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
|
|
return ec._Comment(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._Comment(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
|
|
return ec._CommentConnection(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._CommentConnection(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
|
|
return ec._CommentEdge(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._CommentEdge(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
|
|
return ec._CommentHistoryStep(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx context.Context, v interface{}) (models.CommitAsNeededInput, error) {
|
|
return ec.unmarshalInputCommitAsNeededInput(ctx, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNCommitAsNeededPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitAsNeededPayload) graphql.Marshaler {
|
|
return ec._CommitAsNeededPayload(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitAsNeededPayload) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._CommitAsNeededPayload(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx context.Context, v interface{}) (models.CommitInput, error) {
|
|
return ec.unmarshalInputCommitInput(ctx, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNCommitPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitPayload) graphql.Marshaler {
|
|
return ec._CommitPayload(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitPayload) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._CommitPayload(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
|
|
return ec._CreateOperation(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._CreateOperation(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) (git.Hash, error) {
|
|
var res git.Hash
|
|
return res, res.UnmarshalGQL(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v git.Hash) graphql.Marshaler {
|
|
return v
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) ([]git.Hash, error) {
|
|
var vSlice []interface{}
|
|
if v != nil {
|
|
if tmp1, ok := v.([]interface{}); ok {
|
|
vSlice = tmp1
|
|
} else {
|
|
vSlice = []interface{}{v}
|
|
}
|
|
}
|
|
var err error
|
|
res := make([]git.Hash, len(vSlice))
|
|
for i := range vSlice {
|
|
res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
for i := range v {
|
|
ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
|
|
}
|
|
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
|
|
return ec._Identity(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v []identity.Interface) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
|
|
return ec._IdentityConnection(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._IdentityConnection(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
|
|
return ec._IdentityEdge(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._IdentityEdge(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
|
|
return graphql.UnmarshalInt(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
|
|
res := graphql.MarshalInt(v)
|
|
if res == graphql.Null {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
|
|
return ec._Label(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
|
|
return ec._LabelChangeOperation(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._LabelChangeOperation(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
|
|
var res models.LabelChangeStatus
|
|
return res, res.UnmarshalGQL(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
|
|
return v
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
|
|
return ec.unmarshalInputNewBugInput(ctx, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
|
|
return ec._NewBugPayload(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._NewBugPayload(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
|
|
return ec.unmarshalInputOpenBugInput(ctx, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
|
|
return ec._OpenBugPayload(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._OpenBugPayload(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
|
|
return ec._Operation(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
|
|
return ec._OperationConnection(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._OperationConnection(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
|
|
return ec._OperationEdge(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._OperationEdge(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
|
|
return ec._PageInfo(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._PageInfo(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
|
|
return ec._SetStatusOperation(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._SetStatusOperation(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
|
|
return ec.unmarshalInputSetTitleInput(ctx, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
|
|
return ec._SetTitleOperation(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._SetTitleOperation(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
|
|
return ec._SetTitlePayload(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._SetTitlePayload(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
|
|
var res models.Status
|
|
return res, res.UnmarshalGQL(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
|
|
return v
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
|
|
return graphql.UnmarshalString(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
|
|
res := graphql.MarshalString(v)
|
|
if res == graphql.Null {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
|
|
return graphql.UnmarshalTime(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
|
|
res := graphql.MarshalTime(v)
|
|
if res == graphql.Null {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
|
|
if v == nil {
|
|
return nil, nil
|
|
}
|
|
res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
|
|
return &res, err
|
|
}
|
|
|
|
func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
|
|
return ec._TimelineItem(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
|
|
return ec._TimelineItemConnection(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._TimelineItemConnection(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
|
|
return ec._TimelineItemEdge(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec._TimelineItemEdge(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalN__Directive2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
|
|
return ec.___Directive(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalN__Directive2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
|
|
return graphql.UnmarshalString(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
|
|
res := graphql.MarshalString(v)
|
|
if res == graphql.Null {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstring(ctx context.Context, v interface{}) ([]string, error) {
|
|
var vSlice []interface{}
|
|
if v != nil {
|
|
if tmp1, ok := v.([]interface{}); ok {
|
|
vSlice = tmp1
|
|
} else {
|
|
vSlice = []interface{}{v}
|
|
}
|
|
}
|
|
var err error
|
|
res := make([]string, len(vSlice))
|
|
for i := range vSlice {
|
|
res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
|
|
return ec.___EnumValue(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalN__Field2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
|
|
return ec.___Field(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
|
|
return ec.___InputValue(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalN__InputValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalN__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
|
|
return ec.___Type(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalN__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
|
|
if v == nil {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
return graphql.Null
|
|
}
|
|
return ec.___Type(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
|
|
return graphql.UnmarshalString(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
|
|
res := graphql.MarshalString(v)
|
|
if res == graphql.Null {
|
|
if !ec.HasError(graphql.GetResolverContext(ctx)) {
|
|
ec.Errorf(ctx, "must not be null")
|
|
}
|
|
}
|
|
return res
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
|
|
return graphql.UnmarshalBoolean(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
|
|
return graphql.MarshalBoolean(v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
|
|
if v == nil {
|
|
return nil, nil
|
|
}
|
|
res, err := ec.unmarshalOBoolean2bool(ctx, v)
|
|
return &res, err
|
|
}
|
|
|
|
func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec.marshalOBoolean2bool(ctx, sel, *v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
|
|
return ec._Bug(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec._Bug(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
|
|
return ec.unmarshalInputChangeLabelInput(ctx, v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
|
|
if v == nil {
|
|
return nil, nil
|
|
}
|
|
res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
|
|
return &res, err
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) ([]git.Hash, error) {
|
|
var vSlice []interface{}
|
|
if v != nil {
|
|
if tmp1, ok := v.([]interface{}); ok {
|
|
vSlice = tmp1
|
|
} else {
|
|
vSlice = []interface{}{v}
|
|
}
|
|
}
|
|
var err error
|
|
res := make([]git.Hash, len(vSlice))
|
|
for i := range vSlice {
|
|
res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
ret := make(graphql.Array, len(v))
|
|
for i := range v {
|
|
ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
|
|
}
|
|
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
|
|
return ec._Identity(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
|
|
return graphql.UnmarshalInt(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
|
|
return graphql.MarshalInt(v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
|
|
if v == nil {
|
|
return nil, nil
|
|
}
|
|
res, err := ec.unmarshalOInt2int(ctx, v)
|
|
return &res, err
|
|
}
|
|
|
|
func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec.marshalOInt2int(ctx, sel, *v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
|
|
return ec._LabelChangeResult(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec._LabelChangeResult(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
|
|
return ec._Repository(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec._Repository(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
|
|
return graphql.UnmarshalString(v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
|
|
return graphql.MarshalString(v)
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOString2ᚕstring(ctx context.Context, v interface{}) ([]string, error) {
|
|
var vSlice []interface{}
|
|
if v != nil {
|
|
if tmp1, ok := v.([]interface{}); ok {
|
|
vSlice = tmp1
|
|
} else {
|
|
vSlice = []interface{}{v}
|
|
}
|
|
}
|
|
var err error
|
|
res := make([]string, len(vSlice))
|
|
for i := range vSlice {
|
|
res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (ec *executionContext) marshalOString2ᚕstring(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
ret := make(graphql.Array, len(v))
|
|
for i := range v {
|
|
ret[i] = ec.marshalNString2string(ctx, sel, v[i])
|
|
}
|
|
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
|
|
if v == nil {
|
|
return nil, nil
|
|
}
|
|
res, err := ec.unmarshalOString2string(ctx, v)
|
|
return &res, err
|
|
}
|
|
|
|
func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec.marshalOString2string(ctx, sel, *v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalN__Field2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalN__InputValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalO__Schema2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
|
|
return ec.___Schema(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec.___Schema(ctx, sel, v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalO__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
|
|
return ec.___Type(ctx, sel, &v)
|
|
}
|
|
|
|
func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
ret := make(graphql.Array, len(v))
|
|
var wg sync.WaitGroup
|
|
isLen1 := len(v) == 1
|
|
if !isLen1 {
|
|
wg.Add(len(v))
|
|
}
|
|
for i := range v {
|
|
i := i
|
|
rctx := &graphql.ResolverContext{
|
|
Index: &i,
|
|
Result: &v[i],
|
|
}
|
|
ctx := graphql.WithResolverContext(ctx, rctx)
|
|
f := func(i int) {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
ec.Error(ctx, ec.Recover(ctx, r))
|
|
ret = nil
|
|
}
|
|
}()
|
|
if !isLen1 {
|
|
defer wg.Done()
|
|
}
|
|
ret[i] = ec.marshalN__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
|
|
}
|
|
if isLen1 {
|
|
f(i)
|
|
} else {
|
|
go f(i)
|
|
}
|
|
|
|
}
|
|
wg.Wait()
|
|
return ret
|
|
}
|
|
|
|
func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
|
|
if v == nil {
|
|
return graphql.Null
|
|
}
|
|
return ec.___Type(ctx, sel, v)
|
|
}
|
|
|
|
// endregion ***************************** type.gotpl *****************************
|