aboutsummaryrefslogtreecommitdiffstats
path: root/api
diff options
context:
space:
mode:
Diffstat (limited to 'api')
-rw-r--r--api/graphql/graph/bug.generated.go416
-rw-r--r--api/graphql/graph/identity.generated.go127
-rw-r--r--api/graphql/graph/label.generated.go133
-rw-r--r--api/graphql/graph/mutations.generated.go421
-rw-r--r--api/graphql/graph/operations.generated.go586
-rw-r--r--api/graphql/graph/prelude.generated.go245
-rw-r--r--api/graphql/graph/repository.generated.go203
-rw-r--r--api/graphql/graph/root.generated.go108
-rw-r--r--api/graphql/graph/root_.generated.go58
-rw-r--r--api/graphql/graph/timeline.generated.go708
-rw-r--r--api/graphql/graph/types.generated.go132
-rw-r--r--api/graphql/models/gen_models.go68
12 files changed, 2220 insertions, 985 deletions
diff --git a/api/graphql/graph/bug.generated.go b/api/graphql/graph/bug.generated.go
index ab9c6c34..a5685942 100644
--- a/api/graphql/graph/bug.generated.go
+++ b/api/graphql/graph/bug.generated.go
@@ -694,7 +694,7 @@ func (ec *executionContext) fieldContext_Bug_actors(ctx context.Context, field g
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Bug_actors_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -759,7 +759,7 @@ func (ec *executionContext) fieldContext_Bug_participants(ctx context.Context, f
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Bug_participants_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -824,7 +824,7 @@ func (ec *executionContext) fieldContext_Bug_comments(ctx context.Context, field
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Bug_comments_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -889,7 +889,7 @@ func (ec *executionContext) fieldContext_Bug_timeline(ctx context.Context, field
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Bug_timeline_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -954,7 +954,7 @@ func (ec *executionContext) fieldContext_Bug_operations(ctx context.Context, fie
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Bug_operations_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -1805,23 +1805,22 @@ var bugImplementors = []string{"Bug", "Authored"}
func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("Bug")
case "id":
-
out.Values[i] = ec._Bug_id(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "humanId":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -1829,61 +1828,65 @@ func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj
}()
res = ec._Bug_humanId(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
- case "status":
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "status":
out.Values[i] = ec._Bug_status(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "title":
-
out.Values[i] = ec._Bug_title(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "labels":
-
out.Values[i] = ec._Bug_labels(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "author":
-
out.Values[i] = ec._Bug_author(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "createdAt":
-
out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "lastEdit":
-
out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "actors":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -1891,19 +1894,35 @@ func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj
}()
res = ec._Bug_actors(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "participants":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -1911,19 +1930,35 @@ func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj
}()
res = ec._Bug_participants(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "comments":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -1931,19 +1966,35 @@ func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj
}()
res = ec._Bug_comments(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "timeline":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -1951,19 +2002,35 @@ func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj
}()
res = ec._Bug_timeline(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "operations":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -1971,23 +2038,51 @@ func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj
}()
res = ec._Bug_operations(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -1995,48 +2090,53 @@ var bugConnectionImplementors = []string{"BugConnection"}
func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "nodes":
-
out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "pageInfo":
-
out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "totalCount":
-
out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2044,34 +2144,43 @@ var bugEdgeImplementors = []string{"BugEdge"}
func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "node":
-
out.Values[i] = ec._BugEdge_node(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2079,8 +2188,9 @@ var commentImplementors = []string{"Comment", "Authored"}
func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, commentImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
@@ -2088,7 +2198,7 @@ func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet,
case "id":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2096,19 +2206,35 @@ func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet,
}()
res = ec._Comment_id(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "author":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2116,37 +2242,61 @@ func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet,
}()
res = ec._Comment_author(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
- case "message":
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "message":
out.Values[i] = ec._Comment_message(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "files":
-
out.Values[i] = ec._Comment_files(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2154,48 +2304,53 @@ var commentConnectionImplementors = []string{"CommentConnection"}
func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, commentConnectionImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("CommentConnection")
case "edges":
-
out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "nodes":
-
out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "pageInfo":
-
out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "totalCount":
-
out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2203,34 +2358,43 @@ var commentEdgeImplementors = []string{"CommentEdge"}
func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, commentEdgeImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("CommentEdge")
case "cursor":
-
out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "node":
-
out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
diff --git a/api/graphql/graph/identity.generated.go b/api/graphql/graph/identity.generated.go
index 51aa188b..1fe6ac23 100644
--- a/api/graphql/graph/identity.generated.go
+++ b/api/graphql/graph/identity.generated.go
@@ -706,23 +706,22 @@ var identityImplementors = []string{"Identity"}
func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj models.IdentityWrapper) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, identityImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("Identity")
case "id":
-
out.Values[i] = ec._Identity_id(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "humanId":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -730,53 +729,69 @@ func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet,
}()
res = ec._Identity_humanId(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
- case "name":
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "name":
out.Values[i] = ec._Identity_name(ctx, field, obj)
-
case "email":
-
out.Values[i] = ec._Identity_email(ctx, field, obj)
-
case "login":
-
out.Values[i] = ec._Identity_login(ctx, field, obj)
-
case "displayName":
-
out.Values[i] = ec._Identity_displayName(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "avatarUrl":
-
out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
-
case "isProtected":
-
out.Values[i] = ec._Identity_isProtected(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -784,48 +799,53 @@ var identityConnectionImplementors = []string{"IdentityConnection"}
func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, identityConnectionImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "nodes":
-
out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "pageInfo":
-
out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "totalCount":
-
out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -833,34 +853,43 @@ var identityEdgeImplementors = []string{"IdentityEdge"}
func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, identityEdgeImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "node":
-
out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
diff --git a/api/graphql/graph/label.generated.go b/api/graphql/graph/label.generated.go
index 2e2dd12f..c5ebe0e0 100644
--- a/api/graphql/graph/label.generated.go
+++ b/api/graphql/graph/label.generated.go
@@ -440,8 +440,9 @@ var labelImplementors = []string{"Label"}
func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, labelImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
@@ -449,7 +450,7 @@ func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, ob
case "name":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -457,19 +458,35 @@ func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, ob
}()
res = ec._Label_name(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "color":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -477,23 +494,51 @@ func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, ob
}()
res = ec._Label_color(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -501,48 +546,53 @@ var labelConnectionImplementors = []string{"LabelConnection"}
func (ec *executionContext) _LabelConnection(ctx context.Context, sel ast.SelectionSet, obj *models.LabelConnection) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, labelConnectionImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("LabelConnection")
case "edges":
-
out.Values[i] = ec._LabelConnection_edges(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "nodes":
-
out.Values[i] = ec._LabelConnection_nodes(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "pageInfo":
-
out.Values[i] = ec._LabelConnection_pageInfo(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "totalCount":
-
out.Values[i] = ec._LabelConnection_totalCount(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -550,34 +600,43 @@ var labelEdgeImplementors = []string{"LabelEdge"}
func (ec *executionContext) _LabelEdge(ctx context.Context, sel ast.SelectionSet, obj *models.LabelEdge) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, labelEdgeImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("LabelEdge")
case "cursor":
-
out.Values[i] = ec._LabelEdge_cursor(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "node":
-
out.Values[i] = ec._LabelEdge_node(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
diff --git a/api/graphql/graph/mutations.generated.go b/api/graphql/graph/mutations.generated.go
index 11604d11..6b3755ba 100644
--- a/api/graphql/graph/mutations.generated.go
+++ b/api/graphql/graph/mutations.generated.go
@@ -8,6 +8,7 @@ import (
"fmt"
"strconv"
"sync"
+ "sync/atomic"
"github.com/99designs/gqlgen/graphql"
"github.com/MichaelMure/git-bug/api/graphql/models"
@@ -1824,42 +1825,47 @@ func (ec *executionContext) unmarshalInputAddCommentAndCloseBugInput(ctx context
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
- it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.ClientMutationID = data
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
- it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.RepoRef = data
case "prefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
- it.Prefix, err = ec.unmarshalNString2string(ctx, v)
+ data, err := ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
+ it.Prefix = data
case "message":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
- it.Message, err = ec.unmarshalNString2string(ctx, v)
+ data, err := ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
+ it.Message = data
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)
+ data, err := ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
if err != nil {
return it, err
}
+ it.Files = data
}
}
@@ -1884,42 +1890,47 @@ func (ec *executionContext) unmarshalInputAddCommentAndReopenBugInput(ctx contex
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
- it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.ClientMutationID = data
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
- it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.RepoRef = data
case "prefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
- it.Prefix, err = ec.unmarshalNString2string(ctx, v)
+ data, err := ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
+ it.Prefix = data
case "message":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
- it.Message, err = ec.unmarshalNString2string(ctx, v)
+ data, err := ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
+ it.Message = data
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)
+ data, err := ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
if err != nil {
return it, err
}
+ it.Files = data
}
}
@@ -1944,42 +1955,47 @@ func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, o
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
- it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.ClientMutationID = data
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
- it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.RepoRef = data
case "prefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
- it.Prefix, err = ec.unmarshalNString2string(ctx, v)
+ data, err := ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
+ it.Prefix = data
case "message":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
- it.Message, err = ec.unmarshalNString2string(ctx, v)
+ data, err := ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
+ it.Message = data
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)
+ data, err := ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
if err != nil {
return it, err
}
+ it.Files = data
}
}
@@ -2004,42 +2020,47 @@ func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context,
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
- it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.ClientMutationID = data
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
- it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.RepoRef = data
case "prefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
- it.Prefix, err = ec.unmarshalNString2string(ctx, v)
+ data, err := ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
+ it.Prefix = data
case "added":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("added"))
- it.Added, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
+ data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v)
if err != nil {
return it, err
}
+ it.Added = data
case "Removed":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Removed"))
- it.Removed, err = ec.unmarshalOString2ᚕstringᚄ(ctx, v)
+ data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v)
if err != nil {
return it, err
}
+ it.Removed = data
}
}
@@ -2064,26 +2085,29 @@ func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
- it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.ClientMutationID = data
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
- it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.RepoRef = data
case "prefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
- it.Prefix, err = ec.unmarshalNString2string(ctx, v)
+ data, err := ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
+ it.Prefix = data
}
}
@@ -2108,42 +2132,47 @@ func (ec *executionContext) unmarshalInputEditCommentInput(ctx context.Context,
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
- it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.ClientMutationID = data
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
- it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.RepoRef = data
case "targetPrefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("targetPrefix"))
- it.TargetPrefix, err = ec.unmarshalNString2string(ctx, v)
+ data, err := ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
+ it.TargetPrefix = data
case "message":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
- it.Message, err = ec.unmarshalNString2string(ctx, v)
+ data, err := ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
+ it.Message = data
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)
+ data, err := ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
if err != nil {
return it, err
}
+ it.Files = data
}
}
@@ -2168,42 +2197,47 @@ func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj i
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
- it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.ClientMutationID = data
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
- it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.RepoRef = data
case "title":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
- it.Title, err = ec.unmarshalNString2string(ctx, v)
+ data, err := ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
+ it.Title = data
case "message":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
- it.Message, err = ec.unmarshalNString2string(ctx, v)
+ data, err := ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
+ it.Message = data
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)
+ data, err := ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
if err != nil {
return it, err
}
+ it.Files = data
}
}
@@ -2228,26 +2262,29 @@ func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
- it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.ClientMutationID = data
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
- it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.RepoRef = data
case "prefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
- it.Prefix, err = ec.unmarshalNString2string(ctx, v)
+ data, err := ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
+ it.Prefix = data
}
}
@@ -2272,34 +2309,38 @@ func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
- it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.ClientMutationID = data
case "repoRef":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
- it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
+ data, err := ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
+ it.RepoRef = data
case "prefix":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
- it.Prefix, err = ec.unmarshalNString2string(ctx, v)
+ data, err := ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
+ it.Prefix = data
case "title":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
- it.Title, err = ec.unmarshalNString2string(ctx, v)
+ data, err := ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
+ it.Title = data
}
}
@@ -2318,45 +2359,50 @@ var addCommentAndCloseBugPayloadImplementors = []string{"AddCommentAndCloseBugPa
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
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "commentOperation":
-
out.Values[i] = ec._AddCommentAndCloseBugPayload_commentOperation(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "statusOperation":
-
out.Values[i] = ec._AddCommentAndCloseBugPayload_statusOperation(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2364,45 +2410,50 @@ var addCommentAndReopenBugPayloadImplementors = []string{"AddCommentAndReopenBug
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
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "commentOperation":
-
out.Values[i] = ec._AddCommentAndReopenBugPayload_commentOperation(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "statusOperation":
-
out.Values[i] = ec._AddCommentAndReopenBugPayload_statusOperation(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2410,38 +2461,45 @@ 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
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "operation":
-
out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2449,45 +2507,50 @@ 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
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "operation":
-
out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "results":
-
out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2495,38 +2558,45 @@ 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
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "operation":
-
out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2534,38 +2604,45 @@ 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
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "operation":
-
out.Values[i] = ec._EditCommentPayload_operation(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2573,34 +2650,43 @@ 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
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("LabelChangeResult")
case "label":
-
out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "status":
-
out.Values[i] = ec._LabelChangeResult_status(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2608,38 +2694,45 @@ 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
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "operation":
-
out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2647,38 +2740,45 @@ 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
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "operation":
-
out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2686,38 +2786,45 @@ 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
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "operation":
-
out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
diff --git a/api/graphql/graph/operations.generated.go b/api/graphql/graph/operations.generated.go
index cc3cd9b7..838f16b0 100644
--- a/api/graphql/graph/operations.generated.go
+++ b/api/graphql/graph/operations.generated.go
@@ -1880,23 +1880,22 @@ var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation
func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, addCommentOperationImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("AddCommentOperation")
case "id":
-
out.Values[i] = ec._AddCommentOperation_id(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "author":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -1904,19 +1903,35 @@ func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.Se
}()
res = ec._AddCommentOperation_author(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "date":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -1924,37 +1939,61 @@ func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.Se
}()
res = ec._AddCommentOperation_date(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
- case "message":
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "message":
out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "files":
-
out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -1962,23 +2001,22 @@ var createOperationImplementors = []string{"CreateOperation", "Operation", "Auth
func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, createOperationImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("CreateOperation")
case "id":
-
out.Values[i] = ec._CreateOperation_id(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "author":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -1986,19 +2024,35 @@ func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.Select
}()
res = ec._CreateOperation_author(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "date":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2006,44 +2060,66 @@ func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.Select
}()
res = ec._CreateOperation_date(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "title":
-
out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "message":
-
out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "files":
-
out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2051,23 +2127,22 @@ var editCommentOperationImplementors = []string{"EditCommentOperation", "Operati
func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, editCommentOperationImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("EditCommentOperation")
case "id":
-
out.Values[i] = ec._EditCommentOperation_id(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "author":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2075,19 +2150,35 @@ func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.S
}()
res = ec._EditCommentOperation_author(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "date":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2095,19 +2186,35 @@ func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.S
}()
res = ec._EditCommentOperation_date(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "target":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2115,37 +2222,61 @@ func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.S
}()
res = ec._EditCommentOperation_target(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
- case "message":
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "message":
out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "files":
-
out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2153,23 +2284,22 @@ var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operati
func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeOperationImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("LabelChangeOperation")
case "id":
-
out.Values[i] = ec._LabelChangeOperation_id(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "author":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2177,19 +2307,35 @@ func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.S
}()
res = ec._LabelChangeOperation_author(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "date":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2197,37 +2343,61 @@ func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.S
}()
res = ec._LabelChangeOperation_date(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
- case "added":
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "added":
out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "removed":
-
out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2235,48 +2405,53 @@ var operationConnectionImplementors = []string{"OperationConnection"}
func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, operationConnectionImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("OperationConnection")
case "edges":
-
out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "nodes":
-
out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "pageInfo":
-
out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "totalCount":
-
out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2284,34 +2459,43 @@ var operationEdgeImplementors = []string{"OperationEdge"}
func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, operationEdgeImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("OperationEdge")
case "cursor":
-
out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "node":
-
out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2319,23 +2503,22 @@ var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation",
func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, setStatusOperationImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("SetStatusOperation")
case "id":
-
out.Values[i] = ec._SetStatusOperation_id(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "author":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2343,19 +2526,35 @@ func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.Sel
}()
res = ec._SetStatusOperation_author(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "date":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2363,30 +2562,56 @@ func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.Sel
}()
res = ec._SetStatusOperation_date(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
- case "status":
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "status":
out.Values[i] = ec._SetStatusOperation_status(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2394,23 +2619,22 @@ var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "
func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, setTitleOperationImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("SetTitleOperation")
case "id":
-
out.Values[i] = ec._SetTitleOperation_id(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "author":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2418,19 +2642,35 @@ func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.Sele
}()
res = ec._SetTitleOperation_author(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "date":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2438,37 +2678,61 @@ func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.Sele
}()
res = ec._SetTitleOperation_date(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
- case "title":
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "title":
out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "was":
-
out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
diff --git a/api/graphql/graph/prelude.generated.go b/api/graphql/graph/prelude.generated.go
index 3767b0cd..bb1d2c76 100644
--- a/api/graphql/graph/prelude.generated.go
+++ b/api/graphql/graph/prelude.generated.go
@@ -8,6 +8,7 @@ import (
"fmt"
"strconv"
"sync"
+ "sync/atomic"
"github.com/99designs/gqlgen/graphql"
"github.com/99designs/gqlgen/graphql/introspection"
@@ -21,6 +22,30 @@ import (
// region ***************************** args.gotpl *****************************
+func (ec *executionContext) dir_defer_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["if"]; ok {
+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("if"))
+ arg0, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
+ if err != nil {
+ return nil, err
+ }
+ }
+ args["if"] = arg0
+ var arg1 *string
+ if tmp, ok := rawArgs["label"]; ok {
+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("label"))
+ arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
+ if err != nil {
+ return nil, err
+ }
+ }
+ args["label"] = arg1
+ 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{}{}
@@ -1480,7 +1505,7 @@ func (ec *executionContext) fieldContext___Type_fields(ctx context.Context, fiel
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field___Type_fields_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -1668,7 +1693,7 @@ func (ec *executionContext) fieldContext___Type_enumValues(ctx context.Context,
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field___Type_enumValues_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -1844,52 +1869,55 @@ var __DirectiveImplementors = []string{"__Directive"}
func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.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++
+ out.Invalids++
}
case "args":
-
out.Values[i] = ec.___Directive_args(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "isRepeatable":
-
out.Values[i] = ec.___Directive_isRepeatable(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -1897,42 +1925,47 @@ var __EnumValueImplementors = []string{"__EnumValue"}
func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.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++
+ out.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 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -1940,56 +1973,57 @@ var __FieldImplementors = []string{"__Field"}
func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.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++
+ out.Invalids++
}
case "type":
-
out.Values[i] = ec.___Field_type(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "isDeprecated":
-
out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.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 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -1997,42 +2031,47 @@ var __InputValueImplementors = []string{"__InputValue"}
func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.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++
+ out.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 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2040,53 +2079,54 @@ var __SchemaImplementors = []string{"__Schema"}
func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("__Schema")
case "description":
-
out.Values[i] = ec.___Schema_description(ctx, field, obj)
-
case "types":
-
out.Values[i] = ec.___Schema_types(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "queryType":
-
out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.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++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2094,63 +2134,56 @@ var __TypeImplementors = []string{"__Type"}
func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.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)
-
case "specifiedByURL":
-
out.Values[i] = ec.___Type_specifiedByURL(ctx, field, obj)
-
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
diff --git a/api/graphql/graph/repository.generated.go b/api/graphql/graph/repository.generated.go
index 48ae4d89..c72c6e45 100644
--- a/api/graphql/graph/repository.generated.go
+++ b/api/graphql/graph/repository.generated.go
@@ -304,7 +304,7 @@ func (ec *executionContext) fieldContext_Repository_allBugs(ctx context.Context,
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Repository_allBugs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -384,7 +384,7 @@ func (ec *executionContext) fieldContext_Repository_bug(ctx context.Context, fie
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Repository_bug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -449,7 +449,7 @@ func (ec *executionContext) fieldContext_Repository_allIdentities(ctx context.Co
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Repository_allIdentities_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -519,7 +519,7 @@ func (ec *executionContext) fieldContext_Repository_identity(ctx context.Context
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Repository_identity_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -643,7 +643,7 @@ func (ec *executionContext) fieldContext_Repository_validLabels(ctx context.Cont
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Repository_validLabels_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -664,8 +664,9 @@ var repositoryImplementors = []string{"Repository"}
func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, repositoryImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
@@ -673,7 +674,7 @@ func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSe
case "name":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -683,14 +684,30 @@ func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSe
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "allBugs":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -698,19 +715,35 @@ func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSe
}()
res = ec._Repository_allBugs(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "bug":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -720,14 +753,30 @@ func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSe
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "allIdentities":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -735,19 +784,35 @@ func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSe
}()
res = ec._Repository_allIdentities(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "identity":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -757,14 +822,30 @@ func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSe
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "userIdentity":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -774,14 +855,30 @@ func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSe
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "validLabels":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -789,23 +886,51 @@ func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSe
}()
res = ec._Repository_validLabels(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
diff --git a/api/graphql/graph/root.generated.go b/api/graphql/graph/root.generated.go
index ae506b73..61357c74 100644
--- a/api/graphql/graph/root.generated.go
+++ b/api/graphql/graph/root.generated.go
@@ -6,6 +6,7 @@ import (
"context"
"fmt"
"strconv"
+ "sync/atomic"
"github.com/99designs/gqlgen/graphql"
"github.com/99designs/gqlgen/graphql/introspection"
@@ -265,7 +266,7 @@ func (ec *executionContext) fieldContext_Mutation_newBug(ctx context.Context, fi
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Mutation_newBug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -328,7 +329,7 @@ func (ec *executionContext) fieldContext_Mutation_addComment(ctx context.Context
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Mutation_addComment_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -393,7 +394,7 @@ func (ec *executionContext) fieldContext_Mutation_addCommentAndClose(ctx context
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Mutation_addCommentAndClose_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -458,7 +459,7 @@ func (ec *executionContext) fieldContext_Mutation_addCommentAndReopen(ctx contex
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Mutation_addCommentAndReopen_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -521,7 +522,7 @@ func (ec *executionContext) fieldContext_Mutation_editComment(ctx context.Contex
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Mutation_editComment_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -586,7 +587,7 @@ func (ec *executionContext) fieldContext_Mutation_changeLabels(ctx context.Conte
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Mutation_changeLabels_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -649,7 +650,7 @@ func (ec *executionContext) fieldContext_Mutation_openBug(ctx context.Context, f
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Mutation_openBug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -712,7 +713,7 @@ func (ec *executionContext) fieldContext_Mutation_closeBug(ctx context.Context,
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Mutation_closeBug_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -775,7 +776,7 @@ func (ec *executionContext) fieldContext_Mutation_setTitle(ctx context.Context,
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Mutation_setTitle_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -843,7 +844,7 @@ func (ec *executionContext) fieldContext_Query_repository(ctx context.Context, f
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Query_repository_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -917,7 +918,7 @@ func (ec *executionContext) fieldContext_Query___type(ctx context.Context, field
ctx = graphql.WithFieldContext(ctx, fc)
if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
ec.Error(ctx, err)
- return
+ return fc, err
}
return fc, nil
}
@@ -998,7 +999,7 @@ func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet)
})
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
Object: field.Name,
@@ -1009,94 +1010,88 @@ func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet)
case "__typename":
out.Values[i] = graphql.MarshalString("Mutation")
case "newBug":
-
out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
return ec._Mutation_newBug(ctx, field)
})
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "addComment":
-
out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
return ec._Mutation_addComment(ctx, field)
})
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "addCommentAndClose":
-
out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
return ec._Mutation_addCommentAndClose(ctx, field)
})
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "addCommentAndReopen":
-
out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
return ec._Mutation_addCommentAndReopen(ctx, field)
})
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "editComment":
-
out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
return ec._Mutation_editComment(ctx, field)
})
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "changeLabels":
-
out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
return ec._Mutation_changeLabels(ctx, field)
})
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "openBug":
-
out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
return ec._Mutation_openBug(ctx, field)
})
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "closeBug":
-
out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
return ec._Mutation_closeBug(ctx, field)
})
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "setTitle":
-
out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
return ec._Mutation_setTitle(ctx, field)
})
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -1109,7 +1104,7 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr
})
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
Object: field.Name,
@@ -1122,7 +1117,7 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr
case "repository":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -1133,32 +1128,39 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr
}
rrm := func(ctx context.Context) graphql.Marshaler {
- return ec.OperationContext.RootResolverMiddleware(ctx, innerFunc)
+ return ec.OperationContext.RootResolverMiddleware(ctx,
+ func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
}
- out.Concurrently(i, func() graphql.Marshaler {
- return rrm(innerCtx)
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
case "__type":
-
out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
return ec._Query___type(ctx, field)
})
-
case "__schema":
-
out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
return ec._Query___schema(ctx, field)
})
-
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
diff --git a/api/graphql/graph/root_.generated.go b/api/graphql/graph/root_.generated.go
index a1434228..85e447b3 100644
--- a/api/graphql/graph/root_.generated.go
+++ b/api/graphql/graph/root_.generated.go
@@ -6,6 +6,7 @@ import (
"bytes"
"context"
"errors"
+ "sync/atomic"
"github.com/99designs/gqlgen/graphql"
"github.com/99designs/gqlgen/graphql/introspection"
@@ -381,7 +382,7 @@ func (e *executableSchema) Schema() *ast.Schema {
}
func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
- ec := executionContext{nil, e}
+ ec := executionContext{nil, e, 0, 0, nil}
_ = ec
switch typeName + "." + field {
@@ -1779,7 +1780,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
rc := graphql.GetOperationContext(ctx)
- ec := executionContext{rc, e}
+ ec := executionContext{rc, e, 0, 0, make(chan graphql.DeferredResult)}
inputUnmarshalMap := graphql.BuildUnmarshalerMap(
ec.unmarshalInputAddCommentAndCloseBugInput,
ec.unmarshalInputAddCommentAndReopenBugInput,
@@ -1796,18 +1797,33 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
switch rc.Operation.Operation {
case ast.Query:
return func(ctx context.Context) *graphql.Response {
- if !first {
- return nil
+ var response graphql.Response
+ var data graphql.Marshaler
+ if first {
+ first = false
+ ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
+ data = ec._Query(ctx, rc.Operation.SelectionSet)
+ } else {
+ if atomic.LoadInt32(&ec.pendingDeferred) > 0 {
+ result := <-ec.deferredResults
+ atomic.AddInt32(&ec.pendingDeferred, -1)
+ data = result.Result
+ response.Path = result.Path
+ response.Label = result.Label
+ response.Errors = result.Errors
+ } else {
+ return nil
+ }
}
- first = false
- ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
- data := ec._Query(ctx, rc.Operation.SelectionSet)
var buf bytes.Buffer
data.MarshalGQL(&buf)
-
- return &graphql.Response{
- Data: buf.Bytes(),
+ response.Data = buf.Bytes()
+ if atomic.LoadInt32(&ec.deferred) > 0 {
+ hasNext := atomic.LoadInt32(&ec.pendingDeferred) > 0
+ response.HasNext = &hasNext
}
+
+ return &response
}
case ast.Mutation:
return func(ctx context.Context) *graphql.Response {
@@ -1833,6 +1849,28 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
type executionContext struct {
*graphql.OperationContext
*executableSchema
+ deferred int32
+ pendingDeferred int32
+ deferredResults chan graphql.DeferredResult
+}
+
+func (ec *executionContext) processDeferredGroup(dg graphql.DeferredGroup) {
+ atomic.AddInt32(&ec.pendingDeferred, 1)
+ go func() {
+ ctx := graphql.WithFreshResponseContext(dg.Context)
+ dg.FieldSet.Dispatch(ctx)
+ ds := graphql.DeferredResult{
+ Path: dg.Path,
+ Label: dg.Label,
+ Result: dg.FieldSet,
+ Errors: graphql.GetErrors(ctx),
+ }
+ // null fields should bubble up
+ if dg.FieldSet.Invalids > 0 {
+ ds.Result = graphql.Null
+ }
+ ec.deferredResults <- ds
+ }()
}
func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
diff --git a/api/graphql/graph/timeline.generated.go b/api/graphql/graph/timeline.generated.go
index 4833e274..f0c4b06d 100644
--- a/api/graphql/graph/timeline.generated.go
+++ b/api/graphql/graph/timeline.generated.go
@@ -2013,8 +2013,9 @@ var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "Tim
func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, addCommentTimelineItemImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
@@ -2022,7 +2023,7 @@ func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast
case "id":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2030,19 +2031,35 @@ func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast
}()
res = ec._AddCommentTimelineItem_id(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "author":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2050,40 +2067,50 @@ func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast
}()
res = ec._AddCommentTimelineItem_author(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
- case "message":
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "message":
out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "messageIsEmpty":
-
out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "files":
-
out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "createdAt":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2091,19 +2118,35 @@ func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast
}()
res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "lastEdit":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2111,37 +2154,61 @@ func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast
}()
res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
- case "edited":
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "edited":
out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "history":
-
out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2149,23 +2216,22 @@ var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, commentHistoryStepImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
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)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "date":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2173,23 +2239,51 @@ func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.Sel
}()
res = ec._CommentHistoryStep_date(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2197,8 +2291,9 @@ var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineIte
func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, createTimelineItemImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
@@ -2206,7 +2301,7 @@ func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.Sel
case "id":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2214,19 +2309,35 @@ func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.Sel
}()
res = ec._CreateTimelineItem_id(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "author":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2234,40 +2345,50 @@ func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.Sel
}()
res = ec._CreateTimelineItem_author(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
- case "message":
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "message":
out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "messageIsEmpty":
-
out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "files":
-
out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "createdAt":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2275,19 +2396,35 @@ func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.Sel
}()
res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "lastEdit":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2295,37 +2432,61 @@ func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.Sel
}()
res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
- case "edited":
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "edited":
out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "history":
-
out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2333,8 +2494,9 @@ var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "T
func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeTimelineItemImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
@@ -2342,7 +2504,7 @@ func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel as
case "id":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2350,19 +2512,35 @@ func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel as
}()
res = ec._LabelChangeTimelineItem_id(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "author":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2370,19 +2548,35 @@ func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel as
}()
res = ec._LabelChangeTimelineItem_author(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "date":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2390,37 +2584,61 @@ func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel as
}()
res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
- case "added":
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "added":
out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "removed":
-
out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2428,8 +2646,9 @@ var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "Timel
func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, setStatusTimelineItemImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
@@ -2437,7 +2656,7 @@ func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.
case "id":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2445,19 +2664,35 @@ func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.
}()
res = ec._SetStatusTimelineItem_id(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "author":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2465,19 +2700,35 @@ func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.
}()
res = ec._SetStatusTimelineItem_author(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "date":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2485,30 +2736,56 @@ func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.
}()
res = ec._SetStatusTimelineItem_date(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
- case "status":
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "status":
out.Values[i] = ec._SetStatusTimelineItem_status(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2516,8 +2793,9 @@ var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "Timelin
func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, setTitleTimelineItemImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
@@ -2525,7 +2803,7 @@ func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.S
case "id":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2533,19 +2811,35 @@ func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.S
}()
res = ec._SetTitleTimelineItem_id(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "author":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2553,19 +2847,35 @@ func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.S
}()
res = ec._SetTitleTimelineItem_author(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "date":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -2573,37 +2883,61 @@ func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.S
}()
res = ec._SetTitleTimelineItem_date(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
- })
- case "title":
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "title":
out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
case "was":
-
out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&out.Invalids, 1)
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2611,48 +2945,53 @@ var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemConnectionImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "nodes":
-
out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "pageInfo":
-
out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "totalCount":
-
out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -2660,34 +2999,43 @@ var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, timelineItemEdgeImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "node":
-
out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
diff --git a/api/graphql/graph/types.generated.go b/api/graphql/graph/types.generated.go
index b75604ab..7326d929 100644
--- a/api/graphql/graph/types.generated.go
+++ b/api/graphql/graph/types.generated.go
@@ -439,8 +439,9 @@ var colorImplementors = []string{"Color"}
func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, colorImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
for i, field := range fields {
switch field.Name {
case "__typename":
@@ -448,7 +449,7 @@ func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, ob
case "R":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -456,19 +457,35 @@ func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, ob
}()
res = ec._Color_R(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "G":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -476,19 +493,35 @@ func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, ob
}()
res = ec._Color_G(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
case "B":
field := field
- innerFunc := func(ctx context.Context) (res graphql.Marshaler) {
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
@@ -496,23 +529,51 @@ func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, ob
}()
res = ec._Color_B(ctx, field, obj)
if res == graphql.Null {
- atomic.AddUint32(&invalids, 1)
+ atomic.AddUint32(&fs.Invalids, 1)
}
return res
}
- out.Concurrently(i, func() graphql.Marshaler {
- return innerFunc(ctx)
+ if field.Deferrable != nil {
+ dfs, ok := deferred[field.Deferrable.Label]
+ di := 0
+ if ok {
+ dfs.AddField(field)
+ di = len(dfs.Values) - 1
+ } else {
+ dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
+ deferred[field.Deferrable.Label] = dfs
+ }
+ dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, dfs)
+ })
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
- })
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
@@ -520,48 +581,53 @@ var pageInfoImplementors = []string{"PageInfo"}
func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, pageInfoImplementors)
+
out := graphql.NewFieldSet(fields)
- var invalids uint32
+ deferred := make(map[string]*graphql.FieldSet)
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++
+ out.Invalids++
}
case "hasPreviousPage":
-
out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "startCursor":
-
out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
case "endCursor":
-
out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
-
if out.Values[i] == graphql.Null {
- invalids++
+ out.Invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
- out.Dispatch()
- if invalids > 0 {
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
return graphql.Null
}
+
+ atomic.AddInt32(&ec.deferred, int32(len(deferred)))
+
+ for label, dfs := range deferred {
+ ec.processDeferredGroup(graphql.DeferredGroup{
+ Label: label,
+ Path: graphql.GetPath(ctx),
+ FieldSet: dfs,
+ Context: ctx,
+ })
+ }
+
return out
}
diff --git a/api/graphql/models/gen_models.go b/api/graphql/models/gen_models.go
index d75b3d27..000f4a10 100644
--- a/api/graphql/models/gen_models.go
+++ b/api/graphql/models/gen_models.go
@@ -15,20 +15,20 @@ type Authored interface {
type AddCommentAndCloseBugInput struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The name of the repository. If not set, the default repository is used.
- RepoRef *string `json:"repoRef"`
+ RepoRef *string `json:"repoRef,omitempty"`
// The bug ID's prefix.
Prefix string `json:"prefix"`
// The message to be added to the bug.
Message string `json:"message"`
// The collection of file's hash required for the first message.
- Files []repository.Hash `json:"files"`
+ Files []repository.Hash `json:"files,omitempty"`
}
type AddCommentAndCloseBugPayload struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The affected bug.
Bug BugWrapper `json:"bug"`
// The resulting AddComment operation.
@@ -39,20 +39,20 @@ type AddCommentAndCloseBugPayload struct {
type AddCommentAndReopenBugInput struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The name of the repository. If not set, the default repository is used.
- RepoRef *string `json:"repoRef"`
+ RepoRef *string `json:"repoRef,omitempty"`
// The bug ID's prefix.
Prefix string `json:"prefix"`
// The message to be added to the bug.
Message string `json:"message"`
// The collection of file's hash required for the first message.
- Files []repository.Hash `json:"files"`
+ Files []repository.Hash `json:"files,omitempty"`
}
type AddCommentAndReopenBugPayload struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The affected bug.
Bug BugWrapper `json:"bug"`
// The resulting AddComment operation.
@@ -63,20 +63,20 @@ type AddCommentAndReopenBugPayload struct {
type AddCommentInput struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The name of the repository. If not set, the default repository is used.
- RepoRef *string `json:"repoRef"`
+ RepoRef *string `json:"repoRef,omitempty"`
// The bug ID's prefix.
Prefix string `json:"prefix"`
// The message to be added to the bug.
Message string `json:"message"`
// The collection of file's hash required for the first message.
- Files []repository.Hash `json:"files"`
+ Files []repository.Hash `json:"files,omitempty"`
}
type AddCommentPayload struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The affected bug.
Bug BugWrapper `json:"bug"`
// The resulting operation.
@@ -104,20 +104,20 @@ type BugEdge struct {
type ChangeLabelInput struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The name of the repository. If not set, the default repository is used.
- RepoRef *string `json:"repoRef"`
+ RepoRef *string `json:"repoRef,omitempty"`
// The bug ID's prefix.
Prefix string `json:"prefix"`
// The list of label to add.
- Added []string `json:"added"`
+ Added []string `json:"added,omitempty"`
// The list of label to remove.
- Removed []string `json:"Removed"`
+ Removed []string `json:"Removed,omitempty"`
}
type ChangeLabelPayload struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The affected bug.
Bug BugWrapper `json:"bug"`
// The resulting operation.
@@ -128,16 +128,16 @@ type ChangeLabelPayload struct {
type CloseBugInput struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The name of the repository. If not set, the default repository is used.
- RepoRef *string `json:"repoRef"`
+ RepoRef *string `json:"repoRef,omitempty"`
// The bug ID's prefix.
Prefix string `json:"prefix"`
}
type CloseBugPayload struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The affected bug.
Bug BugWrapper `json:"bug"`
// The resulting operation.
@@ -158,20 +158,20 @@ type CommentEdge struct {
type EditCommentInput struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The name of the repository. If not set, the default repository is used.
- RepoRef *string `json:"repoRef"`
+ RepoRef *string `json:"repoRef,omitempty"`
// A prefix of the CombinedId of the comment to be changed.
TargetPrefix string `json:"targetPrefix"`
// The new message to be set.
Message string `json:"message"`
// The collection of file's hash required for the first message.
- Files []repository.Hash `json:"files"`
+ Files []repository.Hash `json:"files,omitempty"`
}
type EditCommentPayload struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The affected bug.
Bug BugWrapper `json:"bug"`
// The resulting operation.
@@ -204,20 +204,20 @@ type LabelEdge struct {
type NewBugInput struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The name of the repository. If not set, the default repository is used.
- RepoRef *string `json:"repoRef"`
+ RepoRef *string `json:"repoRef,omitempty"`
// The title of the new bug.
Title string `json:"title"`
// The first message of the new bug.
Message string `json:"message"`
// The collection of file's hash required for the first message.
- Files []repository.Hash `json:"files"`
+ Files []repository.Hash `json:"files,omitempty"`
}
type NewBugPayload struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The created bug.
Bug BugWrapper `json:"bug"`
// The resulting operation.
@@ -226,16 +226,16 @@ type NewBugPayload struct {
type OpenBugInput struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The name of the repository. If not set, the default repository is used.
- RepoRef *string `json:"repoRef"`
+ RepoRef *string `json:"repoRef,omitempty"`
// The bug ID's prefix.
Prefix string `json:"prefix"`
}
type OpenBugPayload struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The affected bug.
Bug BugWrapper `json:"bug"`
// The resulting operation.
@@ -270,9 +270,9 @@ type PageInfo struct {
type SetTitleInput struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The name of the repository. If not set, the default repository is used.
- RepoRef *string `json:"repoRef"`
+ RepoRef *string `json:"repoRef,omitempty"`
// The bug ID's prefix.
Prefix string `json:"prefix"`
// The new title.
@@ -281,7 +281,7 @@ type SetTitleInput struct {
type SetTitlePayload struct {
// A unique identifier for the client performing the mutation.
- ClientMutationID *string `json:"clientMutationId"`
+ ClientMutationID *string `json:"clientMutationId,omitempty"`
// The affected bug.
Bug BugWrapper `json:"bug"`
// The resulting operation