// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
package graph
import (
"context"
"errors"
"fmt"
"strconv"
"sync"
"github.com/99designs/gqlgen/graphql"
"github.com/MichaelMure/git-bug/api/graphql/models"
"github.com/MichaelMure/git-bug/entities/bug"
"github.com/vektah/gqlparser/v2/ast"
)
// region ************************** generated!.gotpl **************************
// endregion ************************** generated!.gotpl **************************
// region ***************************** args.gotpl *****************************
// endregion ***************************** args.gotpl *****************************
// region ************************** directives.gotpl **************************
// endregion ************************** directives.gotpl **************************
// region **************************** field.gotpl *****************************
func (ec *executionContext) _AddCommentAndCloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_AddCommentAndCloseBugPayload_clientMutationId(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.ClientMutationID, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*string)
fc.Result = res
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_AddCommentAndCloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "AddCommentAndCloseBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
return nil, errors.New("field of type String does not have child fields")
},
}
return fc, nil
}
func (ec *executionContext) _AddCommentAndCloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_AddCommentAndCloseBugPayload_bug(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Bug, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(models.BugWrapper)
fc.Result = res
return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_AddCommentAndCloseBugPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "AddCommentAndCloseBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_Bug_id(ctx, field)
case "humanId":
return ec.fieldContext_Bug_humanId(ctx, field)
case "status":
return ec.fieldContext_Bug_status(ctx, field)
case "title":
return ec.fieldContext_Bug_title(ctx, field)
case "labels":
return ec.fieldContext_Bug_labels(ctx, field)
case "author":
return ec.fieldContext_Bug_author(ctx, field)
case "createdAt":
return ec.fieldContext_Bug_createdAt(ctx, field)
case "lastEdit":
return ec.fieldContext_Bug_lastEdit(ctx, field)
case "actors":
return ec.fieldContext_Bug_actors(ctx, field)
case "participants":
return ec.fieldContext_Bug_participants(ctx, field)
case "comments":
return ec.fieldContext_Bug_comments(ctx, field)
case "timeline":
return ec.fieldContext_Bug_timeline(ctx, field)
case "operations":
return ec.fieldContext_Bug_operations(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _AddCommentAndCloseBugPayload_commentOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_AddCommentAndCloseBugPayload_commentOperation(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.CommentOperation, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(*bug.AddCommentOperation)
fc.Result = res
return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_AddCommentAndCloseBugPayload_commentOperation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "AddCommentAndCloseBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_AddCommentOperation_id(ctx, field)
case "author":
return ec.fieldContext_AddCommentOperation_author(ctx, field)
case "date":
return ec.fieldContext_AddCommentOperation_date(ctx, field)
case "message":
return ec.fieldContext_AddCommentOperation_message(ctx, field)
case "files":
return ec.fieldContext_AddCommentOperation_files(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type AddCommentOperation", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _AddCommentAndCloseBugPayload_statusOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndCloseBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_AddCommentAndCloseBugPayload_statusOperation(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.StatusOperation, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(*bug.SetStatusOperation)
fc.Result = res
return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_AddCommentAndCloseBugPayload_statusOperation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "AddCommentAndCloseBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_SetStatusOperation_id(ctx, field)
case "author":
return ec.fieldContext_SetStatusOperation_author(ctx, field)
case "date":
return ec.fieldContext_SetStatusOperation_date(ctx, field)
case "status":
return ec.fieldContext_SetStatusOperation_status(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type SetStatusOperation", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _AddCommentAndReopenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_AddCommentAndReopenBugPayload_clientMutationId(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.ClientMutationID, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*string)
fc.Result = res
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_AddCommentAndReopenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "AddCommentAndReopenBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
return nil, errors.New("field of type String does not have child fields")
},
}
return fc, nil
}
func (ec *executionContext) _AddCommentAndReopenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_AddCommentAndReopenBugPayload_bug(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Bug, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(models.BugWrapper)
fc.Result = res
return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_AddCommentAndReopenBugPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "AddCommentAndReopenBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_Bug_id(ctx, field)
case "humanId":
return ec.fieldContext_Bug_humanId(ctx, field)
case "status":
return ec.fieldContext_Bug_status(ctx, field)
case "title":
return ec.fieldContext_Bug_title(ctx, field)
case "labels":
return ec.fieldContext_Bug_labels(ctx, field)
case "author":
return ec.fieldContext_Bug_author(ctx, field)
case "createdAt":
return ec.fieldContext_Bug_createdAt(ctx, field)
case "lastEdit":
return ec.fieldContext_Bug_lastEdit(ctx, field)
case "actors":
return ec.fieldContext_Bug_actors(ctx, field)
case "participants":
return ec.fieldContext_Bug_participants(ctx, field)
case "comments":
return ec.fieldContext_Bug_comments(ctx, field)
case "timeline":
return ec.fieldContext_Bug_timeline(ctx, field)
case "operations":
return ec.fieldContext_Bug_operations(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _AddCommentAndReopenBugPayload_commentOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_AddCommentAndReopenBugPayload_commentOperation(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.CommentOperation, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(*bug.AddCommentOperation)
fc.Result = res
return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_AddCommentAndReopenBugPayload_commentOperation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "AddCommentAndReopenBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_AddCommentOperation_id(ctx, field)
case "author":
return ec.fieldContext_AddCommentOperation_author(ctx, field)
case "date":
return ec.fieldContext_AddCommentOperation_date(ctx, field)
case "message":
return ec.fieldContext_AddCommentOperation_message(ctx, field)
case "files":
return ec.fieldContext_AddCommentOperation_files(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type AddCommentOperation", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _AddCommentAndReopenBugPayload_statusOperation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentAndReopenBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_AddCommentAndReopenBugPayload_statusOperation(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.StatusOperation, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(*bug.SetStatusOperation)
fc.Result = res
return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_AddCommentAndReopenBugPayload_statusOperation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "AddCommentAndReopenBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_SetStatusOperation_id(ctx, field)
case "author":
return ec.fieldContext_SetStatusOperation_author(ctx, field)
case "date":
return ec.fieldContext_SetStatusOperation_date(ctx, field)
case "status":
return ec.fieldContext_SetStatusOperation_status(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type SetStatusOperation", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_AddCommentPayload_clientMutationId(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.ClientMutationID, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*string)
fc.Result = res
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "AddCommentPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
return nil, errors.New("field of type String does not have child fields")
},
}
return fc, nil
}
func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_AddCommentPayload_bug(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Bug, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(models.BugWrapper)
fc.Result = res
return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "AddCommentPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_Bug_id(ctx, field)
case "humanId":
return ec.fieldContext_Bug_humanId(ctx, field)
case "status":
return ec.fieldContext_Bug_status(ctx, field)
case "title":
return ec.fieldContext_Bug_title(ctx, field)
case "labels":
return ec.fieldContext_Bug_labels(ctx, field)
case "author":
return ec.fieldContext_Bug_author(ctx, field)
case "createdAt":
return ec.fieldContext_Bug_createdAt(ctx, field)
case "lastEdit":
return ec.fieldContext_Bug_lastEdit(ctx, field)
case "actors":
return ec.fieldContext_Bug_actors(ctx, field)
case "participants":
return ec.fieldContext_Bug_participants(ctx, field)
case "comments":
return ec.fieldContext_Bug_comments(ctx, field)
case "timeline":
return ec.fieldContext_Bug_timeline(ctx, field)
case "operations":
return ec.fieldContext_Bug_operations(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_AddCommentPayload_operation(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Operation, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(*bug.AddCommentOperation)
fc.Result = res
return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "AddCommentPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_AddCommentOperation_id(ctx, field)
case "author":
return ec.fieldContext_AddCommentOperation_author(ctx, field)
case "date":
return ec.fieldContext_AddCommentOperation_date(ctx, field)
case "message":
return ec.fieldContext_AddCommentOperation_message(ctx, field)
case "files":
return ec.fieldContext_AddCommentOperation_files(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type AddCommentOperation", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_ChangeLabelPayload_clientMutationId(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.ClientMutationID, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*string)
fc.Result = res
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "ChangeLabelPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
return nil, errors.New("field of type String does not have child fields")
},
}
return fc, nil
}
func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_ChangeLabelPayload_bug(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Bug, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(models.BugWrapper)
fc.Result = res
return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "ChangeLabelPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_Bug_id(ctx, field)
case "humanId":
return ec.fieldContext_Bug_humanId(ctx, field)
case "status":
return ec.fieldContext_Bug_status(ctx, field)
case "title":
return ec.fieldContext_Bug_title(ctx, field)
case "labels":
return ec.fieldContext_Bug_labels(ctx, field)
case "author":
return ec.fieldContext_Bug_author(ctx, field)
case "createdAt":
return ec.fieldContext_Bug_createdAt(ctx, field)
case "lastEdit":
return ec.fieldContext_Bug_lastEdit(ctx, field)
case "actors":
return ec.fieldContext_Bug_actors(ctx, field)
case "participants":
return ec.fieldContext_Bug_participants(ctx, field)
case "comments":
return ec.fieldContext_Bug_comments(ctx, field)
case "timeline":
return ec.fieldContext_Bug_timeline(ctx, field)
case "operations":
return ec.fieldContext_Bug_operations(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_ChangeLabelPayload_operation(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Operation, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(*bug.LabelChangeOperation)
fc.Result = res
return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "ChangeLabelPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_LabelChangeOperation_id(ctx, field)
case "author":
return ec.fieldContext_LabelChangeOperation_author(ctx, field)
case "date":
return ec.fieldContext_LabelChangeOperation_date(ctx, field)
case "added":
return ec.fieldContext_LabelChangeOperation_added(ctx, field)
case "removed":
return ec.fieldContext_LabelChangeOperation_removed(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type LabelChangeOperation", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_ChangeLabelPayload_results(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Results, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.([]*bug.LabelChangeResult)
fc.Result = res
return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "ChangeLabelPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "label":
return ec.fieldContext_LabelChangeResult_label(ctx, field)
case "status":
return ec.fieldContext_LabelChangeResult_status(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type LabelChangeResult", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_CloseBugPayload_clientMutationId(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.ClientMutationID, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*string)
fc.Result = res
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "CloseBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
return nil, errors.New("field of type String does not have child fields")
},
}
return fc, nil
}
func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_CloseBugPayload_bug(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Bug, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(models.BugWrapper)
fc.Result = res
return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "CloseBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_Bug_id(ctx, field)
case "humanId":
return ec.fieldContext_Bug_humanId(ctx, field)
case "status":
return ec.fieldContext_Bug_status(ctx, field)
case "title":
return ec.fieldContext_Bug_title(ctx, field)
case "labels":
return ec.fieldContext_Bug_labels(ctx, field)
case "author":
return ec.fieldContext_Bug_author(ctx, field)
case "createdAt":
return ec.fieldContext_Bug_createdAt(ctx, field)
case "lastEdit":
return ec.fieldContext_Bug_lastEdit(ctx, field)
case "actors":
return ec.fieldContext_Bug_actors(ctx, field)
case "participants":
return ec.fieldContext_Bug_participants(ctx, field)
case "comments":
return ec.fieldContext_Bug_comments(ctx, field)
case "timeline":
return ec.fieldContext_Bug_timeline(ctx, field)
case "operations":
return ec.fieldContext_Bug_operations(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_CloseBugPayload_operation(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Operation, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(*bug.SetStatusOperation)
fc.Result = res
return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "CloseBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_SetStatusOperation_id(ctx, field)
case "author":
return ec.fieldContext_SetStatusOperation_author(ctx, field)
case "date":
return ec.fieldContext_SetStatusOperation_date(ctx, field)
case "status":
return ec.fieldContext_SetStatusOperation_status(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type SetStatusOperation", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _EditCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_EditCommentPayload_clientMutationId(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.ClientMutationID, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*string)
fc.Result = res
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_EditCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "EditCommentPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
return nil, errors.New("field of type String does not have child fields")
},
}
return fc, nil
}
func (ec *executionContext) _EditCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_EditCommentPayload_bug(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Bug, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(models.BugWrapper)
fc.Result = res
return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_EditCommentPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "EditCommentPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_Bug_id(ctx, field)
case "humanId":
return ec.fieldContext_Bug_humanId(ctx, field)
case "status":
return ec.fieldContext_Bug_status(ctx, field)
case "title":
return ec.fieldContext_Bug_title(ctx, field)
case "labels":
return ec.fieldContext_Bug_labels(ctx, field)
case "author":
return ec.fieldContext_Bug_author(ctx, field)
case "createdAt":
return ec.fieldContext_Bug_createdAt(ctx, field)
case "lastEdit":
return ec.fieldContext_Bug_lastEdit(ctx, field)
case "actors":
return ec.fieldContext_Bug_actors(ctx, field)
case "participants":
return ec.fieldContext_Bug_participants(ctx, field)
case "comments":
return ec.fieldContext_Bug_comments(ctx, field)
case "timeline":
return ec.fieldContext_Bug_timeline(ctx, field)
case "operations":
return ec.fieldContext_Bug_operations(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _EditCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.EditCommentPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_EditCommentPayload_operation(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Operation, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(*bug.EditCommentOperation)
fc.Result = res
return ec.marshalNEditCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐEditCommentOperation(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_EditCommentPayload_operation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "EditCommentPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_EditCommentOperation_id(ctx, field)
case "author":
return ec.fieldContext_EditCommentOperation_author(ctx, field)
case "date":
return ec.fieldContext_EditCommentOperation_date(ctx, field)
case "target":
return ec.fieldContext_EditCommentOperation_target(ctx, field)
case "message":
return ec.fieldContext_EditCommentOperation_message(ctx, field)
case "files":
return ec.fieldContext_EditCommentOperation_files(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type EditCommentOperation", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_LabelChangeResult_label(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Label, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(bug.Label)
fc.Result = res
return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐLabel(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_LabelChangeResult_label(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "LabelChangeResult",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "name":
return ec.fieldContext_Label_name(ctx, field)
case "color":
return ec.fieldContext_Label_color(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_LabelChangeResult_status(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Status, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(bug.LabelChangeStatus)
fc.Result = res
return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeStatus(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_LabelChangeResult_status(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "LabelChangeResult",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
return nil, errors.New("field of type LabelChangeStatus does not have child fields")
},
}
return fc, nil
}
func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_NewBugPayload_clientMutationId(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.ClientMutationID, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*string)
fc.Result = res
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "NewBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
return nil, errors.New("field of type String does not have child fields")
},
}
return fc, nil
}
func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_NewBugPayload_bug(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Bug, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(models.BugWrapper)
fc.Result = res
return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_NewBugPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "NewBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_Bug_id(ctx, field)
case "humanId":
return ec.fieldContext_Bug_humanId(ctx, field)
case "status":
return ec.fieldContext_Bug_status(ctx, field)
case "title":
return ec.fieldContext_Bug_title(ctx, field)
case "labels":
return ec.fieldContext_Bug_labels(ctx, field)
case "author":
return ec.fieldContext_Bug_author(ctx, field)
case "createdAt":
return ec.fieldContext_Bug_createdAt(ctx, field)
case "lastEdit":
return ec.fieldContext_Bug_lastEdit(ctx, field)
case "actors":
return ec.fieldContext_Bug_actors(ctx, field)
case "participants":
return ec.fieldContext_Bug_participants(ctx, field)
case "comments":
return ec.fieldContext_Bug_comments(ctx, field)
case "timeline":
return ec.fieldContext_Bug_timeline(ctx, field)
case "operations":
return ec.fieldContext_Bug_operations(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_NewBugPayload_operation(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Operation, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(*bug.CreateOperation)
fc.Result = res
return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐCreateOperation(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_NewBugPayload_operation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "NewBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_CreateOperation_id(ctx, field)
case "author":
return ec.fieldContext_CreateOperation_author(ctx, field)
case "date":
return ec.fieldContext_CreateOperation_date(ctx, field)
case "title":
return ec.fieldContext_CreateOperation_title(ctx, field)
case "message":
return ec.fieldContext_CreateOperation_message(ctx, field)
case "files":
return ec.fieldContext_CreateOperation_files(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type CreateOperation", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_OpenBugPayload_clientMutationId(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.ClientMutationID, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*string)
fc.Result = res
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "OpenBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
return nil, errors.New("field of type String does not have child fields")
},
}
return fc, nil
}
func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_OpenBugPayload_bug(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Bug, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(models.BugWrapper)
fc.Result = res
return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "OpenBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_Bug_id(ctx, field)
case "humanId":
return ec.fieldContext_Bug_humanId(ctx, field)
case "status":
return ec.fieldContext_Bug_status(ctx, field)
case "title":
return ec.fieldContext_Bug_title(ctx, field)
case "labels":
return ec.fieldContext_Bug_labels(ctx, field)
case "author":
return ec.fieldContext_Bug_author(ctx, field)
case "createdAt":
return ec.fieldContext_Bug_createdAt(ctx, field)
case "lastEdit":
return ec.fieldContext_Bug_lastEdit(ctx, field)
case "actors":
return ec.fieldContext_Bug_actors(ctx, field)
case "participants":
return ec.fieldContext_Bug_participants(ctx, field)
case "comments":
return ec.fieldContext_Bug_comments(ctx, field)
case "timeline":
return ec.fieldContext_Bug_timeline(ctx, field)
case "operations":
return ec.fieldContext_Bug_operations(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_OpenBugPayload_operation(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Operation, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(*bug.SetStatusOperation)
fc.Result = res
return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "OpenBugPayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_SetStatusOperation_id(ctx, field)
case "author":
return ec.fieldContext_SetStatusOperation_author(ctx, field)
case "date":
return ec.fieldContext_SetStatusOperation_date(ctx, field)
case "status":
return ec.fieldContext_SetStatusOperation_status(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type SetStatusOperation", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_SetTitlePayload_clientMutationId(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.ClientMutationID, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*string)
fc.Result = res
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "SetTitlePayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
return nil, errors.New("field of type String does not have child fields")
},
}
return fc, nil
}
func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_SetTitlePayload_bug(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Bug, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(models.BugWrapper)
fc.Result = res
return ec.marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "SetTitlePayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_Bug_id(ctx, field)
case "humanId":
return ec.fieldContext_Bug_humanId(ctx, field)
case "status":
return ec.fieldContext_Bug_status(ctx, field)
case "title":
return ec.fieldContext_Bug_title(ctx, field)
case "labels":
return ec.fieldContext_Bug_labels(ctx, field)
case "author":
return ec.fieldContext_Bug_author(ctx, field)
case "createdAt":
return ec.fieldContext_Bug_createdAt(ctx, field)
case "lastEdit":
return ec.fieldContext_Bug_lastEdit(ctx, field)
case "actors":
return ec.fieldContext_Bug_actors(ctx, field)
case "participants":
return ec.fieldContext_Bug_participants(ctx, field)
case "comments":
return ec.fieldContext_Bug_comments(ctx, field)
case "timeline":
return ec.fieldContext_Bug_timeline(ctx, field)
case "operations":
return ec.fieldContext_Bug_operations(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
},
}
return fc, nil
}
func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
fc, err := ec.fieldContext_SetTitlePayload_operation(ctx, field)
if err != nil {
return graphql.Null
}
ctx = graphql.WithFieldContext(ctx, fc)
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Operation, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
res := resTmp.(*bug.SetTitleOperation)
fc.Result = res
return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
}
func (ec *executionContext) fieldContext_SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
fc = &graphql.FieldContext{
Object: "SetTitlePayload",
Field: field,
IsMethod: false,
IsResolver: false,
Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
switch field.Name {
case "id":
return ec.fieldContext_SetTitleOperation_id(ctx, field)
case "author":
return ec.fieldContext_SetTitleOperation_author(ctx, field)
case "date":
return ec.fieldContext_SetTitleOperation_date(ctx, field)
case "title":
return ec.fieldContext_SetTitleOperation_title(ctx, field)
case "was":
return ec.fieldContext_SetTitleOperation_was(ctx, field)
}
return nil, fmt.Errorf("no field named %q was found under type SetTitleOperation", field.Name)
},
}
return fc, nil
}
// endregion **************************** field.gotpl *****************************
// region **************************** input.gotpl *****************************
func (ec *executionContext) unmarshalInputAddCommentAndCloseBugInput(ctx context.Context, obj interface{}) (models.AddCommentAndCloseBugInput, error) {
var it models.AddCommentAndCloseBugInput
asMap := map[string]interface{}{}
for k, v := range obj.(map[string]interface{}) {
asMap[k] = v
}
fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "message", "files"}
for _, k := range fieldsInOrder {
v, ok := asMap[k]
if !ok {
continue
}
switch k {
case "clientMutationId":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "prefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
it.Prefix, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
case "message":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
it.Message, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
case "files":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
if err != nil {
return it, err
}
}
}
return it, nil
}
func (ec *executionContext) unmarshalInputAddCommentAndReopenBugInput(ctx context.Context, obj interface{}) (models.AddCommentAndReopenBugInput, error) {
var it models.AddCommentAndReopenBugInput
asMap := map[string]interface{}{}
for k, v := range obj.(map[string]interface{}) {
asMap[k] = v
}
fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "message", "files"}
for _, k := range fieldsInOrder {
v, ok := asMap[k]
if !ok {
continue
}
switch k {
case "clientMutationId":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "prefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
it.Prefix, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
case "message":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
it.Message, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
case "files":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
if err != nil {
return it, err
}
}
}
return it, nil
}
func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
var it models.AddCommentInput
asMap := map[string]interface{}{}
for k, v := range obj.(map[string]interface{}) {
asMap[k] = v
}
fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "message", "files"}
for _, k := range fieldsInOrder {
v, ok := asMap[k]
if !ok {
continue
}
switch k {
case "clientMutationId":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "prefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
it.Prefix, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
case "message":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
it.Message, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
case "files":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
if err != nil {
return it, err
}
}
}
return it, nil
}
func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
var it models.ChangeLabelInput
asMap := map[string]interface{}{}
for k, v := range obj.(map[string]interface{}) {
asMap[k] = v
}
fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "added", "Removed"}
for _, k := range fieldsInOrder {
v, ok := asMap[k]
if !ok {
continue
}
switch k {
case "clientMutationId":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "prefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
it.Prefix, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
case "added":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("added"))
it.Added, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
if err != nil {
return it, err
}
case "Removed":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Removed"))
it.Removed, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
if err != nil {
return it, err
}
}
}
return it, nil
}
func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
var it models.CloseBugInput
asMap := map[string]interface{}{}
for k, v := range obj.(map[string]interface{}) {
asMap[k] = v
}
fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix"}
for _, k := range fieldsInOrder {
v, ok := asMap[k]
if !ok {
continue
}
switch k {
case "clientMutationId":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "prefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
it.Prefix, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
}
}
return it, nil
}
func (ec *executionContext) unmarshalInputEditCommentInput(ctx context.Context, obj interface{}) (models.EditCommentInput, error) {
var it models.EditCommentInput
asMap := map[string]interface{}{}
for k, v := range obj.(map[string]interface{}) {
asMap[k] = v
}
fieldsInOrder := [...]string{"clientMutationId", "repoRef", "targetPrefix", "message", "files"}
for _, k := range fieldsInOrder {
v, ok := asMap[k]
if !ok {
continue
}
switch k {
case "clientMutationId":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "targetPrefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("targetPrefix"))
it.TargetPrefix, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
case "message":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
it.Message, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
case "files":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
if err != nil {
return it, err
}
}
}
return it, nil
}
func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
var it models.NewBugInput
asMap := map[string]interface{}{}
for k, v := range obj.(map[string]interface{}) {
asMap[k] = v
}
fieldsInOrder := [...]string{"clientMutationId", "repoRef", "title", "message", "files"}
for _, k := range fieldsInOrder {
v, ok := asMap[k]
if !ok {
continue
}
switch k {
case "clientMutationId":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "title":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
it.Title, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
case "message":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
it.Message, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
case "files":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
if err != nil {
return it, err
}
}
}
return it, nil
}
func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
var it models.OpenBugInput
asMap := map[string]interface{}{}
for k, v := range obj.(map[string]interface{}) {
asMap[k] = v
}
fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix"}
for _, k := range fieldsInOrder {
v, ok := asMap[k]
if !ok {
continue
}
switch k {
case "clientMutationId":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "prefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
it.Prefix, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
}
}
return it, nil
}
func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
var it models.SetTitleInput
asMap := map[string]interface{}{}
for k, v := range obj.(map[string]interface{}) {
asMap[k] = v
}
fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "title"}
for _, k := range fieldsInOrder {
v, ok := asMap[k]
if !ok {
continue
}
switch k {
case "clientMutationId":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "prefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
it.Prefix, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
case "title":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
it.Title, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
}
}
return it, nil
}
// endregion **************************** input.gotpl *****************************
// region ************************** interface.gotpl ***************************
// endregion ************************** interface.gotpl ***************************
// region **************************** object.gotpl ****************************
var addCommentAndCloseBugPayloadImplementors = []string{"AddCommentAndCloseBugPayload"}
func (ec *executionContext) _AddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentAndCloseBugPayload) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, addCommentAndCloseBugPayloadImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("AddCommentAndCloseBugPayload")
case "clientMutationId":
out.Values[i] = ec._AddCommentAndCloseBugPayload_clientMutationId(ctx, field, obj)
case "bug":
out.Values[i] = ec._AddCommentAndCloseBugPayload_bug(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "commentOperation":
out.Values[i] = ec._AddCommentAndCloseBugPayload_commentOperation(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "statusOperation":
out.Values[i] = ec._AddCommentAndCloseBugPayload_statusOperation(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 addCommentAndReopenBugPayloadImplementors = []string{"AddCommentAndReopenBugPayload"}
func (ec *executionContext) _AddCommentAndReopenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentAndReopenBugPayload) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, addCommentAndReopenBugPayloadImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("AddCommentAndReopenBugPayload")
case "clientMutationId":
out.Values[i] = ec._AddCommentAndReopenBugPayload_clientMutationId(ctx, field, obj)
case "bug":
out.Values[i] = ec._AddCommentAndReopenBugPayload_bug(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "commentOperation":
out.Values[i] = ec._AddCommentAndReopenBugPayload_commentOperation(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "statusOperation":
out.Values[i] = ec._AddCommentAndReopenBugPayload_statusOperation(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 addCommentPayloadImplementors = []string{"AddCommentPayload"}
func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, 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 changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, 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.OperationContext, 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 editCommentPayloadImplementors = []string{"EditCommentPayload"}
func (ec *executionContext) _EditCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.EditCommentPayload) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, editCommentPayloadImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("EditCommentPayload")
case "clientMutationId":
out.Values[i] = ec._EditCommentPayload_clientMutationId(ctx, field, obj)
case "bug":
out.Values[i] = ec._EditCommentPayload_bug(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "operation":
out.Values[i] = ec._EditCommentPayload_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 labelChangeResultImplementors = []string{"LabelChangeResult"}
func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
out := graphql.NewFieldSet(fields)
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 {
invalids++
}
case "status":
out.Values[i] = ec._LabelChangeResult_status(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 newBugPayloadImplementors = []string{"NewBugPayload"}
func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, 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.OperationContext, 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 setTitlePayloadImplementors = []string{"SetTitlePayload"}
func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, 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
}
// endregion **************************** object.gotpl ****************************
// region ***************************** type.gotpl *****************************
func (ec *executionContext) unmarshalNAddCommentAndCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugInput(ctx context.Context, v interface{}) (models.AddCommentAndCloseBugInput, error) {
res, err := ec.unmarshalInputAddCommentAndCloseBugInput(ctx, v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNAddCommentAndCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentAndCloseBugPayload) graphql.Marshaler {
return ec._AddCommentAndCloseBugPayload(ctx, sel, &v)
}
func (ec *executionContext) marshalNAddCommentAndCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentAndCloseBugPayload) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "the requested element is null which the schema does not allow")
}
return graphql.Null
}
return ec._AddCommentAndCloseBugPayload(ctx, sel, v)
}
func (ec *executionContext) unmarshalNAddCommentAndReopenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugInput(ctx context.Context, v interface{}) (models.AddCommentAndReopenBugInput, error) {
res, err := ec.unmarshalInputAddCommentAndReopenBugInput(ctx, v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNAddCommentAndReopenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentAndReopenBugPayload) graphql.Marshaler {
return ec._AddCommentAndReopenBugPayload(ctx, sel, &v)
}
func (ec *executionContext) marshalNAddCommentAndReopenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentAndReopenBugPayload) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "the requested element is null which the schema does not allow")
}
return graphql.Null
}
return ec._AddCommentAndReopenBugPayload(ctx, sel, v)
}
func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
res, err := ec.unmarshalInputAddCommentInput(ctx, v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋ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ᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "the requested element is null which the schema does not allow")
}
return graphql.Null
}
return ec._AddCommentPayload(ctx, sel, v)
}
func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋ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ᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "the requested element is null which the schema does not allow")
}
return graphql.Null
}
return ec._ChangeLabelPayload(ctx, sel, v)
}
func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
res, err := ec.unmarshalInputCloseBugInput(ctx, v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋ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ᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "the requested element is null which the schema does not allow")
}
return graphql.Null
}
return ec._CloseBugPayload(ctx, sel, v)
}
func (ec *executionContext) unmarshalNEditCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentInput(ctx context.Context, v interface{}) (models.EditCommentInput, error) {
res, err := ec.unmarshalInputEditCommentInput(ctx, v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNEditCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.EditCommentPayload) graphql.Marshaler {
return ec._EditCommentPayload(ctx, sel, &v)
}
func (ec *executionContext) marshalNEditCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.EditCommentPayload) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "the requested element is null which the schema does not allow")
}
return graphql.Null
}
return ec._EditCommentPayload(ctx, sel, v)
}
func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeResult(ctx, sel, v[i])
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeStatus(ctx context.Context, v interface{}) (bug.LabelChangeStatus, error) {
var res bug.LabelChangeStatus
err := res.UnmarshalGQL(v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeStatus) graphql.Marshaler {
return v
}
func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
res, err := ec.unmarshalInputNewBugInput(ctx, v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋ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ᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "the requested element is null which the schema does not allow")
}
return graphql.Null
}
return ec._NewBugPayload(ctx, sel, v)
}
func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
res, err := ec.unmarshalInputOpenBugInput(ctx, v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋ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ᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "the requested element is null which the schema does not allow")
}
return graphql.Null
}
return ec._OpenBugPayload(ctx, sel, v)
}
func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
res, err := ec.unmarshalInputSetTitleInput(ctx, v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋ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ᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "the requested element is null which the schema does not allow")
}
return graphql.Null
}
return ec._SetTitlePayload(ctx, sel, v)
}
func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
if v == nil {
return nil, nil
}
res, err := ec.unmarshalInputChangeLabelInput(ctx, v)
return &res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
if v == nil {
return graphql.Null
}
return ec._LabelChangeResult(ctx, sel, v)
}
// endregion ***************************** type.gotpl *****************************
