Detailed changes
@@ -26,17 +26,17 @@ type NameEdgeMaker func(value NodeType, offset int) Edge
// NameConMaker define a function that create a ConnectionType
type NameConMaker func(
- edges []EdgeType,
+ edges []*EdgeType,
nodes []NodeType,
- info models.PageInfo,
+ info *models.PageInfo,
totalCount int) (*ConnectionType, error)
// NameCon will paginate a source according to the input of a relay connection
func NameCon(source []NodeType, edgeMaker NameEdgeMaker, conMaker NameConMaker, input models.ConnectionInput) (*ConnectionType, error) {
var nodes []NodeType
- var edges []EdgeType
+ var edges []*EdgeType
var cursors []string
- var pageInfo models.PageInfo
+ var pageInfo = &models.PageInfo{}
var totalCount = len(source)
emptyCon, _ := conMaker(edges, nodes, pageInfo, 0)
@@ -66,18 +66,20 @@ func NameCon(source []NodeType, edgeMaker NameEdgeMaker, conMaker NameConMaker,
break
}
- edges = append(edges, edge.(EdgeType))
+ e := edge.(EdgeType)
+ edges = append(edges, &e)
cursors = append(cursors, edge.GetCursor())
nodes = append(nodes, value)
}
} else {
- edges = make([]EdgeType, len(source))
+ edges = make([]*EdgeType, len(source))
cursors = make([]string, len(source))
nodes = source
for i, value := range source {
edge := edgeMaker(value, i+offset)
- edges[i] = edge.(EdgeType)
+ e := edge.(EdgeType)
+ edges[i] = &e
cursors[i] = edge.GetCursor()
}
}
@@ -17,17 +17,17 @@ type CommentEdgeMaker func(value bug.Comment, offset int) Edge
// CommentConMaker define a function that create a models.CommentConnection
type CommentConMaker func(
- edges []models.CommentEdge,
+ edges []*models.CommentEdge,
nodes []bug.Comment,
- info models.PageInfo,
+ info *models.PageInfo,
totalCount int) (*models.CommentConnection, error)
// CommentCon will paginate a source according to the input of a relay connection
func CommentCon(source []bug.Comment, edgeMaker CommentEdgeMaker, conMaker CommentConMaker, input models.ConnectionInput) (*models.CommentConnection, error) {
var nodes []bug.Comment
- var edges []models.CommentEdge
+ var edges []*models.CommentEdge
var cursors []string
- var pageInfo models.PageInfo
+ var pageInfo = &models.PageInfo{}
var totalCount = len(source)
emptyCon, _ := conMaker(edges, nodes, pageInfo, 0)
@@ -57,18 +57,20 @@ func CommentCon(source []bug.Comment, edgeMaker CommentEdgeMaker, conMaker Comme
break
}
- edges = append(edges, edge.(models.CommentEdge))
+ e := edge.(models.CommentEdge)
+ edges = append(edges, &e)
cursors = append(cursors, edge.GetCursor())
nodes = append(nodes, value)
}
} else {
- edges = make([]models.CommentEdge, len(source))
+ edges = make([]*models.CommentEdge, len(source))
cursors = make([]string, len(source))
nodes = source
for i, value := range source {
edge := edgeMaker(value, i+offset)
- edges[i] = edge.(models.CommentEdge)
+ e := edge.(models.CommentEdge)
+ edges[i] = &e
cursors[i] = edge.GetCursor()
}
}
@@ -17,17 +17,17 @@ type IdentityEdgeMaker func(value identity.Interface, offset int) Edge
// IdentityConMaker define a function that create a models.IdentityConnection
type IdentityConMaker func(
- edges []models.IdentityEdge,
+ edges []*models.IdentityEdge,
nodes []identity.Interface,
- info models.PageInfo,
+ info *models.PageInfo,
totalCount int) (*models.IdentityConnection, error)
// IdentityCon will paginate a source according to the input of a relay connection
func IdentityCon(source []identity.Interface, edgeMaker IdentityEdgeMaker, conMaker IdentityConMaker, input models.ConnectionInput) (*models.IdentityConnection, error) {
var nodes []identity.Interface
- var edges []models.IdentityEdge
+ var edges []*models.IdentityEdge
var cursors []string
- var pageInfo models.PageInfo
+ var pageInfo = &models.PageInfo{}
var totalCount = len(source)
emptyCon, _ := conMaker(edges, nodes, pageInfo, 0)
@@ -57,18 +57,20 @@ func IdentityCon(source []identity.Interface, edgeMaker IdentityEdgeMaker, conMa
break
}
- edges = append(edges, edge.(models.IdentityEdge))
+ e := edge.(models.IdentityEdge)
+ edges = append(edges, &e)
cursors = append(cursors, edge.GetCursor())
nodes = append(nodes, value)
}
} else {
- edges = make([]models.IdentityEdge, len(source))
+ edges = make([]*models.IdentityEdge, len(source))
cursors = make([]string, len(source))
nodes = source
for i, value := range source {
edge := edgeMaker(value, i+offset)
- edges[i] = edge.(models.IdentityEdge)
+ e := edge.(models.IdentityEdge)
+ edges[i] = &e
cursors[i] = edge.GetCursor()
}
}
@@ -16,17 +16,17 @@ type LazyBugEdgeMaker func(value string, offset int) Edge
// LazyBugConMaker define a function that create a models.BugConnection
type LazyBugConMaker func(
- edges []LazyBugEdge,
+ edges []*LazyBugEdge,
nodes []string,
- info models.PageInfo,
+ info *models.PageInfo,
totalCount int) (*models.BugConnection, error)
// LazyBugCon will paginate a source according to the input of a relay connection
func LazyBugCon(source []string, edgeMaker LazyBugEdgeMaker, conMaker LazyBugConMaker, input models.ConnectionInput) (*models.BugConnection, error) {
var nodes []string
- var edges []LazyBugEdge
+ var edges []*LazyBugEdge
var cursors []string
- var pageInfo models.PageInfo
+ var pageInfo = &models.PageInfo{}
var totalCount = len(source)
emptyCon, _ := conMaker(edges, nodes, pageInfo, 0)
@@ -56,18 +56,20 @@ func LazyBugCon(source []string, edgeMaker LazyBugEdgeMaker, conMaker LazyBugCon
break
}
- edges = append(edges, edge.(LazyBugEdge))
+ e := edge.(LazyBugEdge)
+ edges = append(edges, &e)
cursors = append(cursors, edge.GetCursor())
nodes = append(nodes, value)
}
} else {
- edges = make([]LazyBugEdge, len(source))
+ edges = make([]*LazyBugEdge, len(source))
cursors = make([]string, len(source))
nodes = source
for i, value := range source {
edge := edgeMaker(value, i+offset)
- edges[i] = edge.(LazyBugEdge)
+ e := edge.(LazyBugEdge)
+ edges[i] = &e
cursors[i] = edge.GetCursor()
}
}
@@ -16,17 +16,17 @@ type LazyIdentityEdgeMaker func(value string, offset int) Edge
// LazyIdentityConMaker define a function that create a models.IdentityConnection
type LazyIdentityConMaker func(
- edges []LazyIdentityEdge,
+ edges []*LazyIdentityEdge,
nodes []string,
- info models.PageInfo,
+ info *models.PageInfo,
totalCount int) (*models.IdentityConnection, error)
// LazyIdentityCon will paginate a source according to the input of a relay connection
func LazyIdentityCon(source []string, edgeMaker LazyIdentityEdgeMaker, conMaker LazyIdentityConMaker, input models.ConnectionInput) (*models.IdentityConnection, error) {
var nodes []string
- var edges []LazyIdentityEdge
+ var edges []*LazyIdentityEdge
var cursors []string
- var pageInfo models.PageInfo
+ var pageInfo = &models.PageInfo{}
var totalCount = len(source)
emptyCon, _ := conMaker(edges, nodes, pageInfo, 0)
@@ -56,18 +56,20 @@ func LazyIdentityCon(source []string, edgeMaker LazyIdentityEdgeMaker, conMaker
break
}
- edges = append(edges, edge.(LazyIdentityEdge))
+ e := edge.(LazyIdentityEdge)
+ edges = append(edges, &e)
cursors = append(cursors, edge.GetCursor())
nodes = append(nodes, value)
}
} else {
- edges = make([]LazyIdentityEdge, len(source))
+ edges = make([]*LazyIdentityEdge, len(source))
cursors = make([]string, len(source))
nodes = source
for i, value := range source {
edge := edgeMaker(value, i+offset)
- edges[i] = edge.(LazyIdentityEdge)
+ e := edge.(LazyIdentityEdge)
+ edges[i] = &e
cursors[i] = edge.GetCursor()
}
}
@@ -17,17 +17,17 @@ type OperationEdgeMaker func(value bug.Operation, offset int) Edge
// OperationConMaker define a function that create a models.OperationConnection
type OperationConMaker func(
- edges []models.OperationEdge,
+ edges []*models.OperationEdge,
nodes []bug.Operation,
- info models.PageInfo,
+ info *models.PageInfo,
totalCount int) (*models.OperationConnection, error)
// OperationCon will paginate a source according to the input of a relay connection
func OperationCon(source []bug.Operation, edgeMaker OperationEdgeMaker, conMaker OperationConMaker, input models.ConnectionInput) (*models.OperationConnection, error) {
var nodes []bug.Operation
- var edges []models.OperationEdge
+ var edges []*models.OperationEdge
var cursors []string
- var pageInfo models.PageInfo
+ var pageInfo = &models.PageInfo{}
var totalCount = len(source)
emptyCon, _ := conMaker(edges, nodes, pageInfo, 0)
@@ -57,18 +57,20 @@ func OperationCon(source []bug.Operation, edgeMaker OperationEdgeMaker, conMaker
break
}
- edges = append(edges, edge.(models.OperationEdge))
+ e := edge.(models.OperationEdge)
+ edges = append(edges, &e)
cursors = append(cursors, edge.GetCursor())
nodes = append(nodes, value)
}
} else {
- edges = make([]models.OperationEdge, len(source))
+ edges = make([]*models.OperationEdge, len(source))
cursors = make([]string, len(source))
nodes = source
for i, value := range source {
edge := edgeMaker(value, i+offset)
- edges[i] = edge.(models.OperationEdge)
+ e := edge.(models.OperationEdge)
+ edges[i] = &e
cursors[i] = edge.GetCursor()
}
}
@@ -17,17 +17,17 @@ type TimelineItemEdgeMaker func(value bug.TimelineItem, offset int) Edge
// TimelineItemConMaker define a function that create a models.TimelineItemConnection
type TimelineItemConMaker func(
- edges []models.TimelineItemEdge,
+ edges []*models.TimelineItemEdge,
nodes []bug.TimelineItem,
- info models.PageInfo,
+ info *models.PageInfo,
totalCount int) (*models.TimelineItemConnection, error)
// TimelineItemCon will paginate a source according to the input of a relay connection
func TimelineItemCon(source []bug.TimelineItem, edgeMaker TimelineItemEdgeMaker, conMaker TimelineItemConMaker, input models.ConnectionInput) (*models.TimelineItemConnection, error) {
var nodes []bug.TimelineItem
- var edges []models.TimelineItemEdge
+ var edges []*models.TimelineItemEdge
var cursors []string
- var pageInfo models.PageInfo
+ var pageInfo = &models.PageInfo{}
var totalCount = len(source)
emptyCon, _ := conMaker(edges, nodes, pageInfo, 0)
@@ -57,18 +57,20 @@ func TimelineItemCon(source []bug.TimelineItem, edgeMaker TimelineItemEdgeMaker,
break
}
- edges = append(edges, edge.(models.TimelineItemEdge))
+ e := edge.(models.TimelineItemEdge)
+ edges = append(edges, &e)
cursors = append(cursors, edge.GetCursor())
nodes = append(nodes, value)
}
} else {
- edges = make([]models.TimelineItemEdge, len(source))
+ edges = make([]*models.TimelineItemEdge, len(source))
cursors = make([]string, len(source))
nodes = source
for i, value := range source {
edge := edgeMaker(value, i+offset)
- edges[i] = edge.(models.TimelineItemEdge)
+ e := edge.(models.TimelineItemEdge)
+ edges[i] = &e
cursors[i] = edge.GetCursor()
}
}
@@ -9,6 +9,7 @@ import (
"fmt"
"strconv"
"sync"
+ "sync/atomic"
"time"
"github.com/99designs/gqlgen/graphql"
@@ -385,105 +386,105 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
_ = ec
switch typeName + "." + field {
- case "AddCommentOperation.Author":
+ case "AddCommentOperation.author":
if e.complexity.AddCommentOperation.Author == nil {
break
}
return e.complexity.AddCommentOperation.Author(childComplexity), true
- case "AddCommentOperation.Date":
+ case "AddCommentOperation.date":
if e.complexity.AddCommentOperation.Date == nil {
break
}
return e.complexity.AddCommentOperation.Date(childComplexity), true
- case "AddCommentOperation.Files":
+ case "AddCommentOperation.files":
if e.complexity.AddCommentOperation.Files == nil {
break
}
return e.complexity.AddCommentOperation.Files(childComplexity), true
- case "AddCommentOperation.Hash":
+ case "AddCommentOperation.hash":
if e.complexity.AddCommentOperation.Hash == nil {
break
}
return e.complexity.AddCommentOperation.Hash(childComplexity), true
- case "AddCommentOperation.Message":
+ case "AddCommentOperation.message":
if e.complexity.AddCommentOperation.Message == nil {
break
}
return e.complexity.AddCommentOperation.Message(childComplexity), true
- case "AddCommentTimelineItem.Author":
+ case "AddCommentTimelineItem.author":
if e.complexity.AddCommentTimelineItem.Author == nil {
break
}
return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
- case "AddCommentTimelineItem.CreatedAt":
+ case "AddCommentTimelineItem.createdAt":
if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
break
}
return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
- case "AddCommentTimelineItem.Edited":
+ case "AddCommentTimelineItem.edited":
if e.complexity.AddCommentTimelineItem.Edited == nil {
break
}
return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
- case "AddCommentTimelineItem.Files":
+ case "AddCommentTimelineItem.files":
if e.complexity.AddCommentTimelineItem.Files == nil {
break
}
return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
- case "AddCommentTimelineItem.Hash":
+ case "AddCommentTimelineItem.hash":
if e.complexity.AddCommentTimelineItem.Hash == nil {
break
}
return e.complexity.AddCommentTimelineItem.Hash(childComplexity), true
- case "AddCommentTimelineItem.History":
+ case "AddCommentTimelineItem.history":
if e.complexity.AddCommentTimelineItem.History == nil {
break
}
return e.complexity.AddCommentTimelineItem.History(childComplexity), true
- case "AddCommentTimelineItem.LastEdit":
+ case "AddCommentTimelineItem.lastEdit":
if e.complexity.AddCommentTimelineItem.LastEdit == nil {
break
}
return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
- case "AddCommentTimelineItem.Message":
+ case "AddCommentTimelineItem.message":
if e.complexity.AddCommentTimelineItem.Message == nil {
break
}
return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
- case "AddCommentTimelineItem.MessageIsEmpty":
+ case "AddCommentTimelineItem.messageIsEmpty":
if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
break
}
return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
- case "Bug.Actors":
+ case "Bug.actors":
if e.complexity.Bug.Actors == nil {
break
}
@@ -495,14 +496,14 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
- case "Bug.Author":
+ case "Bug.author":
if e.complexity.Bug.Author == nil {
break
}
return e.complexity.Bug.Author(childComplexity), true
- case "Bug.Comments":
+ case "Bug.comments":
if e.complexity.Bug.Comments == nil {
break
}
@@ -514,42 +515,42 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
- case "Bug.CreatedAt":
+ case "Bug.createdAt":
if e.complexity.Bug.CreatedAt == nil {
break
}
return e.complexity.Bug.CreatedAt(childComplexity), true
- case "Bug.HumanId":
+ case "Bug.humanId":
if e.complexity.Bug.HumanId == nil {
break
}
return e.complexity.Bug.HumanId(childComplexity), true
- case "Bug.Id":
+ case "Bug.id":
if e.complexity.Bug.Id == nil {
break
}
return e.complexity.Bug.Id(childComplexity), true
- case "Bug.Labels":
+ case "Bug.labels":
if e.complexity.Bug.Labels == nil {
break
}
return e.complexity.Bug.Labels(childComplexity), true
- case "Bug.LastEdit":
+ case "Bug.lastEdit":
if e.complexity.Bug.LastEdit == nil {
break
}
return e.complexity.Bug.LastEdit(childComplexity), true
- case "Bug.Operations":
+ case "Bug.operations":
if e.complexity.Bug.Operations == nil {
break
}
@@ -561,7 +562,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
- case "Bug.Participants":
+ case "Bug.participants":
if e.complexity.Bug.Participants == nil {
break
}
@@ -573,14 +574,14 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
- case "Bug.Status":
+ case "Bug.status":
if e.complexity.Bug.Status == nil {
break
}
return e.complexity.Bug.Status(childComplexity), true
- case "Bug.Timeline":
+ case "Bug.timeline":
if e.complexity.Bug.Timeline == nil {
break
}
@@ -592,448 +593,448 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
- case "Bug.Title":
+ case "Bug.title":
if e.complexity.Bug.Title == nil {
break
}
return e.complexity.Bug.Title(childComplexity), true
- case "BugConnection.Edges":
+ case "BugConnection.edges":
if e.complexity.BugConnection.Edges == nil {
break
}
return e.complexity.BugConnection.Edges(childComplexity), true
- case "BugConnection.Nodes":
+ case "BugConnection.nodes":
if e.complexity.BugConnection.Nodes == nil {
break
}
return e.complexity.BugConnection.Nodes(childComplexity), true
- case "BugConnection.PageInfo":
+ case "BugConnection.pageInfo":
if e.complexity.BugConnection.PageInfo == nil {
break
}
return e.complexity.BugConnection.PageInfo(childComplexity), true
- case "BugConnection.TotalCount":
+ case "BugConnection.totalCount":
if e.complexity.BugConnection.TotalCount == nil {
break
}
return e.complexity.BugConnection.TotalCount(childComplexity), true
- case "BugEdge.Cursor":
+ case "BugEdge.cursor":
if e.complexity.BugEdge.Cursor == nil {
break
}
return e.complexity.BugEdge.Cursor(childComplexity), true
- case "BugEdge.Node":
+ case "BugEdge.node":
if e.complexity.BugEdge.Node == nil {
break
}
return e.complexity.BugEdge.Node(childComplexity), true
- case "Comment.Author":
+ case "Comment.author":
if e.complexity.Comment.Author == nil {
break
}
return e.complexity.Comment.Author(childComplexity), true
- case "Comment.Files":
+ case "Comment.files":
if e.complexity.Comment.Files == nil {
break
}
return e.complexity.Comment.Files(childComplexity), true
- case "Comment.Message":
+ case "Comment.message":
if e.complexity.Comment.Message == nil {
break
}
return e.complexity.Comment.Message(childComplexity), true
- case "CommentConnection.Edges":
+ case "CommentConnection.edges":
if e.complexity.CommentConnection.Edges == nil {
break
}
return e.complexity.CommentConnection.Edges(childComplexity), true
- case "CommentConnection.Nodes":
+ case "CommentConnection.nodes":
if e.complexity.CommentConnection.Nodes == nil {
break
}
return e.complexity.CommentConnection.Nodes(childComplexity), true
- case "CommentConnection.PageInfo":
+ case "CommentConnection.pageInfo":
if e.complexity.CommentConnection.PageInfo == nil {
break
}
return e.complexity.CommentConnection.PageInfo(childComplexity), true
- case "CommentConnection.TotalCount":
+ case "CommentConnection.totalCount":
if e.complexity.CommentConnection.TotalCount == nil {
break
}
return e.complexity.CommentConnection.TotalCount(childComplexity), true
- case "CommentEdge.Cursor":
+ case "CommentEdge.cursor":
if e.complexity.CommentEdge.Cursor == nil {
break
}
return e.complexity.CommentEdge.Cursor(childComplexity), true
- case "CommentEdge.Node":
+ case "CommentEdge.node":
if e.complexity.CommentEdge.Node == nil {
break
}
return e.complexity.CommentEdge.Node(childComplexity), true
- case "CommentHistoryStep.Date":
+ case "CommentHistoryStep.date":
if e.complexity.CommentHistoryStep.Date == nil {
break
}
return e.complexity.CommentHistoryStep.Date(childComplexity), true
- case "CommentHistoryStep.Message":
+ case "CommentHistoryStep.message":
if e.complexity.CommentHistoryStep.Message == nil {
break
}
return e.complexity.CommentHistoryStep.Message(childComplexity), true
- case "CreateOperation.Author":
+ case "CreateOperation.author":
if e.complexity.CreateOperation.Author == nil {
break
}
return e.complexity.CreateOperation.Author(childComplexity), true
- case "CreateOperation.Date":
+ case "CreateOperation.date":
if e.complexity.CreateOperation.Date == nil {
break
}
return e.complexity.CreateOperation.Date(childComplexity), true
- case "CreateOperation.Files":
+ case "CreateOperation.files":
if e.complexity.CreateOperation.Files == nil {
break
}
return e.complexity.CreateOperation.Files(childComplexity), true
- case "CreateOperation.Hash":
+ case "CreateOperation.hash":
if e.complexity.CreateOperation.Hash == nil {
break
}
return e.complexity.CreateOperation.Hash(childComplexity), true
- case "CreateOperation.Message":
+ case "CreateOperation.message":
if e.complexity.CreateOperation.Message == nil {
break
}
return e.complexity.CreateOperation.Message(childComplexity), true
- case "CreateOperation.Title":
+ case "CreateOperation.title":
if e.complexity.CreateOperation.Title == nil {
break
}
return e.complexity.CreateOperation.Title(childComplexity), true
- case "CreateTimelineItem.Author":
+ case "CreateTimelineItem.author":
if e.complexity.CreateTimelineItem.Author == nil {
break
}
return e.complexity.CreateTimelineItem.Author(childComplexity), true
- case "CreateTimelineItem.CreatedAt":
+ case "CreateTimelineItem.createdAt":
if e.complexity.CreateTimelineItem.CreatedAt == nil {
break
}
return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
- case "CreateTimelineItem.Edited":
+ case "CreateTimelineItem.edited":
if e.complexity.CreateTimelineItem.Edited == nil {
break
}
return e.complexity.CreateTimelineItem.Edited(childComplexity), true
- case "CreateTimelineItem.Files":
+ case "CreateTimelineItem.files":
if e.complexity.CreateTimelineItem.Files == nil {
break
}
return e.complexity.CreateTimelineItem.Files(childComplexity), true
- case "CreateTimelineItem.Hash":
+ case "CreateTimelineItem.hash":
if e.complexity.CreateTimelineItem.Hash == nil {
break
}
return e.complexity.CreateTimelineItem.Hash(childComplexity), true
- case "CreateTimelineItem.History":
+ case "CreateTimelineItem.history":
if e.complexity.CreateTimelineItem.History == nil {
break
}
return e.complexity.CreateTimelineItem.History(childComplexity), true
- case "CreateTimelineItem.LastEdit":
+ case "CreateTimelineItem.lastEdit":
if e.complexity.CreateTimelineItem.LastEdit == nil {
break
}
return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
- case "CreateTimelineItem.Message":
+ case "CreateTimelineItem.message":
if e.complexity.CreateTimelineItem.Message == nil {
break
}
return e.complexity.CreateTimelineItem.Message(childComplexity), true
- case "CreateTimelineItem.MessageIsEmpty":
+ case "CreateTimelineItem.messageIsEmpty":
if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
break
}
return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
- case "EditCommentOperation.Author":
+ case "EditCommentOperation.author":
if e.complexity.EditCommentOperation.Author == nil {
break
}
return e.complexity.EditCommentOperation.Author(childComplexity), true
- case "EditCommentOperation.Date":
+ case "EditCommentOperation.date":
if e.complexity.EditCommentOperation.Date == nil {
break
}
return e.complexity.EditCommentOperation.Date(childComplexity), true
- case "EditCommentOperation.Files":
+ case "EditCommentOperation.files":
if e.complexity.EditCommentOperation.Files == nil {
break
}
return e.complexity.EditCommentOperation.Files(childComplexity), true
- case "EditCommentOperation.Hash":
+ case "EditCommentOperation.hash":
if e.complexity.EditCommentOperation.Hash == nil {
break
}
return e.complexity.EditCommentOperation.Hash(childComplexity), true
- case "EditCommentOperation.Message":
+ case "EditCommentOperation.message":
if e.complexity.EditCommentOperation.Message == nil {
break
}
return e.complexity.EditCommentOperation.Message(childComplexity), true
- case "EditCommentOperation.Target":
+ case "EditCommentOperation.target":
if e.complexity.EditCommentOperation.Target == nil {
break
}
return e.complexity.EditCommentOperation.Target(childComplexity), true
- case "Identity.AvatarURL":
+ case "Identity.avatarUrl":
if e.complexity.Identity.AvatarURL == nil {
break
}
return e.complexity.Identity.AvatarURL(childComplexity), true
- case "Identity.DisplayName":
+ case "Identity.displayName":
if e.complexity.Identity.DisplayName == nil {
break
}
return e.complexity.Identity.DisplayName(childComplexity), true
- case "Identity.Email":
+ case "Identity.email":
if e.complexity.Identity.Email == nil {
break
}
return e.complexity.Identity.Email(childComplexity), true
- case "Identity.HumanID":
+ case "Identity.humanId":
if e.complexity.Identity.HumanID == nil {
break
}
return e.complexity.Identity.HumanID(childComplexity), true
- case "Identity.ID":
+ case "Identity.id":
if e.complexity.Identity.ID == nil {
break
}
return e.complexity.Identity.ID(childComplexity), true
- case "Identity.IsProtected":
+ case "Identity.isProtected":
if e.complexity.Identity.IsProtected == nil {
break
}
return e.complexity.Identity.IsProtected(childComplexity), true
- case "Identity.Login":
+ case "Identity.login":
if e.complexity.Identity.Login == nil {
break
}
return e.complexity.Identity.Login(childComplexity), true
- case "Identity.Name":
+ case "Identity.name":
if e.complexity.Identity.Name == nil {
break
}
return e.complexity.Identity.Name(childComplexity), true
- case "IdentityConnection.Edges":
+ case "IdentityConnection.edges":
if e.complexity.IdentityConnection.Edges == nil {
break
}
return e.complexity.IdentityConnection.Edges(childComplexity), true
- case "IdentityConnection.Nodes":
+ case "IdentityConnection.nodes":
if e.complexity.IdentityConnection.Nodes == nil {
break
}
return e.complexity.IdentityConnection.Nodes(childComplexity), true
- case "IdentityConnection.PageInfo":
+ case "IdentityConnection.pageInfo":
if e.complexity.IdentityConnection.PageInfo == nil {
break
}
return e.complexity.IdentityConnection.PageInfo(childComplexity), true
- case "IdentityConnection.TotalCount":
+ case "IdentityConnection.totalCount":
if e.complexity.IdentityConnection.TotalCount == nil {
break
}
return e.complexity.IdentityConnection.TotalCount(childComplexity), true
- case "IdentityEdge.Cursor":
+ case "IdentityEdge.cursor":
if e.complexity.IdentityEdge.Cursor == nil {
break
}
return e.complexity.IdentityEdge.Cursor(childComplexity), true
- case "IdentityEdge.Node":
+ case "IdentityEdge.node":
if e.complexity.IdentityEdge.Node == nil {
break
}
return e.complexity.IdentityEdge.Node(childComplexity), true
- case "LabelChangeOperation.Added":
+ case "LabelChangeOperation.added":
if e.complexity.LabelChangeOperation.Added == nil {
break
}
return e.complexity.LabelChangeOperation.Added(childComplexity), true
- case "LabelChangeOperation.Author":
+ case "LabelChangeOperation.author":
if e.complexity.LabelChangeOperation.Author == nil {
break
}
return e.complexity.LabelChangeOperation.Author(childComplexity), true
- case "LabelChangeOperation.Date":
+ case "LabelChangeOperation.date":
if e.complexity.LabelChangeOperation.Date == nil {
break
}
return e.complexity.LabelChangeOperation.Date(childComplexity), true
- case "LabelChangeOperation.Hash":
+ case "LabelChangeOperation.hash":
if e.complexity.LabelChangeOperation.Hash == nil {
break
}
return e.complexity.LabelChangeOperation.Hash(childComplexity), true
- case "LabelChangeOperation.Removed":
+ case "LabelChangeOperation.removed":
if e.complexity.LabelChangeOperation.Removed == nil {
break
}
return e.complexity.LabelChangeOperation.Removed(childComplexity), true
- case "LabelChangeTimelineItem.Added":
+ case "LabelChangeTimelineItem.added":
if e.complexity.LabelChangeTimelineItem.Added == nil {
break
}
return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
- case "LabelChangeTimelineItem.Author":
+ case "LabelChangeTimelineItem.author":
if e.complexity.LabelChangeTimelineItem.Author == nil {
break
}
return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
- case "LabelChangeTimelineItem.Date":
+ case "LabelChangeTimelineItem.date":
if e.complexity.LabelChangeTimelineItem.Date == nil {
break
}
return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
- case "LabelChangeTimelineItem.Hash":
+ case "LabelChangeTimelineItem.hash":
if e.complexity.LabelChangeTimelineItem.Hash == nil {
break
}
return e.complexity.LabelChangeTimelineItem.Hash(childComplexity), true
- case "LabelChangeTimelineItem.Removed":
+ case "LabelChangeTimelineItem.removed":
if e.complexity.LabelChangeTimelineItem.Removed == nil {
break
}
return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
- case "Mutation.AddComment":
+ case "Mutation.addComment":
if e.complexity.Mutation.AddComment == nil {
break
}
@@ -1045,7 +1046,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Mutation.AddComment(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["message"].(string), args["files"].([]git.Hash)), true
- case "Mutation.ChangeLabels":
+ case "Mutation.changeLabels":
if e.complexity.Mutation.ChangeLabels == nil {
break
}
@@ -1057,7 +1058,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Mutation.ChangeLabels(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["added"].([]string), args["removed"].([]string)), true
- case "Mutation.Close":
+ case "Mutation.close":
if e.complexity.Mutation.Close == nil {
break
}
@@ -1069,7 +1070,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Mutation.Close(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
- case "Mutation.Commit":
+ case "Mutation.commit":
if e.complexity.Mutation.Commit == nil {
break
}
@@ -1081,7 +1082,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Mutation.Commit(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
- case "Mutation.NewBug":
+ case "Mutation.newBug":
if e.complexity.Mutation.NewBug == nil {
break
}
@@ -1093,7 +1094,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Mutation.NewBug(childComplexity, args["repoRef"].(*string), args["title"].(string), args["message"].(string), args["files"].([]git.Hash)), true
- case "Mutation.Open":
+ case "Mutation.open":
if e.complexity.Mutation.Open == nil {
break
}
@@ -1105,7 +1106,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Mutation.Open(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
- case "Mutation.SetTitle":
+ case "Mutation.setTitle":
if e.complexity.Mutation.SetTitle == nil {
break
}
@@ -1117,84 +1118,84 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Mutation.SetTitle(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["title"].(string)), true
- case "OperationConnection.Edges":
+ case "OperationConnection.edges":
if e.complexity.OperationConnection.Edges == nil {
break
}
return e.complexity.OperationConnection.Edges(childComplexity), true
- case "OperationConnection.Nodes":
+ case "OperationConnection.nodes":
if e.complexity.OperationConnection.Nodes == nil {
break
}
return e.complexity.OperationConnection.Nodes(childComplexity), true
- case "OperationConnection.PageInfo":
+ case "OperationConnection.pageInfo":
if e.complexity.OperationConnection.PageInfo == nil {
break
}
return e.complexity.OperationConnection.PageInfo(childComplexity), true
- case "OperationConnection.TotalCount":
+ case "OperationConnection.totalCount":
if e.complexity.OperationConnection.TotalCount == nil {
break
}
return e.complexity.OperationConnection.TotalCount(childComplexity), true
- case "OperationEdge.Cursor":
+ case "OperationEdge.cursor":
if e.complexity.OperationEdge.Cursor == nil {
break
}
return e.complexity.OperationEdge.Cursor(childComplexity), true
- case "OperationEdge.Node":
+ case "OperationEdge.node":
if e.complexity.OperationEdge.Node == nil {
break
}
return e.complexity.OperationEdge.Node(childComplexity), true
- case "PageInfo.EndCursor":
+ case "PageInfo.endCursor":
if e.complexity.PageInfo.EndCursor == nil {
break
}
return e.complexity.PageInfo.EndCursor(childComplexity), true
- case "PageInfo.HasNextPage":
+ case "PageInfo.hasNextPage":
if e.complexity.PageInfo.HasNextPage == nil {
break
}
return e.complexity.PageInfo.HasNextPage(childComplexity), true
- case "PageInfo.HasPreviousPage":
+ case "PageInfo.hasPreviousPage":
if e.complexity.PageInfo.HasPreviousPage == nil {
break
}
return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
- case "PageInfo.StartCursor":
+ case "PageInfo.startCursor":
if e.complexity.PageInfo.StartCursor == nil {
break
}
return e.complexity.PageInfo.StartCursor(childComplexity), true
- case "Query.DefaultRepository":
+ case "Query.defaultRepository":
if e.complexity.Query.DefaultRepository == nil {
break
}
return e.complexity.Query.DefaultRepository(childComplexity), true
- case "Query.Repository":
+ case "Query.repository":
if e.complexity.Query.Repository == nil {
break
}
@@ -1206,7 +1207,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Query.Repository(childComplexity, args["id"].(string)), true
- case "Repository.AllBugs":
+ case "Repository.allBugs":
if e.complexity.Repository.AllBugs == nil {
break
}
@@ -1218,7 +1219,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
- case "Repository.AllIdentities":
+ case "Repository.allIdentities":
if e.complexity.Repository.AllIdentities == nil {
break
}
@@ -1230,7 +1231,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
- case "Repository.Bug":
+ case "Repository.bug":
if e.complexity.Repository.Bug == nil {
break
}
@@ -1242,7 +1243,7 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
- case "Repository.Identity":
+ case "Repository.identity":
if e.complexity.Repository.Identity == nil {
break
}
@@ -1254,182 +1255,182 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
- case "Repository.UserIdentity":
+ case "Repository.userIdentity":
if e.complexity.Repository.UserIdentity == nil {
break
}
return e.complexity.Repository.UserIdentity(childComplexity), true
- case "Repository.ValidLabels":
+ case "Repository.validLabels":
if e.complexity.Repository.ValidLabels == nil {
break
}
return e.complexity.Repository.ValidLabels(childComplexity), true
- case "SetStatusOperation.Author":
+ case "SetStatusOperation.author":
if e.complexity.SetStatusOperation.Author == nil {
break
}
return e.complexity.SetStatusOperation.Author(childComplexity), true
- case "SetStatusOperation.Date":
+ case "SetStatusOperation.date":
if e.complexity.SetStatusOperation.Date == nil {
break
}
return e.complexity.SetStatusOperation.Date(childComplexity), true
- case "SetStatusOperation.Hash":
+ case "SetStatusOperation.hash":
if e.complexity.SetStatusOperation.Hash == nil {
break
}
return e.complexity.SetStatusOperation.Hash(childComplexity), true
- case "SetStatusOperation.Status":
+ case "SetStatusOperation.status":
if e.complexity.SetStatusOperation.Status == nil {
break
}
return e.complexity.SetStatusOperation.Status(childComplexity), true
- case "SetStatusTimelineItem.Author":
+ case "SetStatusTimelineItem.author":
if e.complexity.SetStatusTimelineItem.Author == nil {
break
}
return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
- case "SetStatusTimelineItem.Date":
+ case "SetStatusTimelineItem.date":
if e.complexity.SetStatusTimelineItem.Date == nil {
break
}
return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
- case "SetStatusTimelineItem.Hash":
+ case "SetStatusTimelineItem.hash":
if e.complexity.SetStatusTimelineItem.Hash == nil {
break
}
return e.complexity.SetStatusTimelineItem.Hash(childComplexity), true
- case "SetStatusTimelineItem.Status":
+ case "SetStatusTimelineItem.status":
if e.complexity.SetStatusTimelineItem.Status == nil {
break
}
return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
- case "SetTitleOperation.Author":
+ case "SetTitleOperation.author":
if e.complexity.SetTitleOperation.Author == nil {
break
}
return e.complexity.SetTitleOperation.Author(childComplexity), true
- case "SetTitleOperation.Date":
+ case "SetTitleOperation.date":
if e.complexity.SetTitleOperation.Date == nil {
break
}
return e.complexity.SetTitleOperation.Date(childComplexity), true
- case "SetTitleOperation.Hash":
+ case "SetTitleOperation.hash":
if e.complexity.SetTitleOperation.Hash == nil {
break
}
return e.complexity.SetTitleOperation.Hash(childComplexity), true
- case "SetTitleOperation.Title":
+ case "SetTitleOperation.title":
if e.complexity.SetTitleOperation.Title == nil {
break
}
return e.complexity.SetTitleOperation.Title(childComplexity), true
- case "SetTitleOperation.Was":
+ case "SetTitleOperation.was":
if e.complexity.SetTitleOperation.Was == nil {
break
}
return e.complexity.SetTitleOperation.Was(childComplexity), true
- case "SetTitleTimelineItem.Author":
+ case "SetTitleTimelineItem.author":
if e.complexity.SetTitleTimelineItem.Author == nil {
break
}
return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
- case "SetTitleTimelineItem.Date":
+ case "SetTitleTimelineItem.date":
if e.complexity.SetTitleTimelineItem.Date == nil {
break
}
return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
- case "SetTitleTimelineItem.Hash":
+ case "SetTitleTimelineItem.hash":
if e.complexity.SetTitleTimelineItem.Hash == nil {
break
}
return e.complexity.SetTitleTimelineItem.Hash(childComplexity), true
- case "SetTitleTimelineItem.Title":
+ case "SetTitleTimelineItem.title":
if e.complexity.SetTitleTimelineItem.Title == nil {
break
}
return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
- case "SetTitleTimelineItem.Was":
+ case "SetTitleTimelineItem.was":
if e.complexity.SetTitleTimelineItem.Was == nil {
break
}
return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
- case "TimelineItemConnection.Edges":
+ case "TimelineItemConnection.edges":
if e.complexity.TimelineItemConnection.Edges == nil {
break
}
return e.complexity.TimelineItemConnection.Edges(childComplexity), true
- case "TimelineItemConnection.Nodes":
+ case "TimelineItemConnection.nodes":
if e.complexity.TimelineItemConnection.Nodes == nil {
break
}
return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
- case "TimelineItemConnection.PageInfo":
+ case "TimelineItemConnection.pageInfo":
if e.complexity.TimelineItemConnection.PageInfo == nil {
break
}
return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
- case "TimelineItemConnection.TotalCount":
+ case "TimelineItemConnection.totalCount":
if e.complexity.TimelineItemConnection.TotalCount == nil {
break
}
return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
- case "TimelineItemEdge.Cursor":
+ case "TimelineItemEdge.cursor":
if e.complexity.TimelineItemEdge.Cursor == nil {
break
}
return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
- case "TimelineItemEdge.Node":
+ case "TimelineItemEdge.node":
if e.complexity.TimelineItemEdge.Node == nil {
break
}
@@ -19,10 +19,10 @@ type Authored interface {
// The connection type for Bug.
type BugConnection struct {
// A list of edges.
- Edges []BugEdge `json:"edges"`
- Nodes []bug.Snapshot `json:"nodes"`
+ Edges []*BugEdge `json:"edges"`
+ Nodes []*bug.Snapshot `json:"nodes"`
// Information to aid in pagination.
- PageInfo PageInfo `json:"pageInfo"`
+ PageInfo *PageInfo `json:"pageInfo"`
// Identifies the total count of items in the connection.
TotalCount int `json:"totalCount"`
}
@@ -32,25 +32,25 @@ type BugEdge struct {
// A cursor for use in pagination.
Cursor string `json:"cursor"`
// The item at the end of the edge.
- Node bug.Snapshot `json:"node"`
+ Node *bug.Snapshot `json:"node"`
}
type CommentConnection struct {
- Edges []CommentEdge `json:"edges"`
- Nodes []bug.Comment `json:"nodes"`
- PageInfo PageInfo `json:"pageInfo"`
- TotalCount int `json:"totalCount"`
+ Edges []*CommentEdge `json:"edges"`
+ Nodes []*bug.Comment `json:"nodes"`
+ PageInfo *PageInfo `json:"pageInfo"`
+ TotalCount int `json:"totalCount"`
}
type CommentEdge struct {
- Cursor string `json:"cursor"`
- Node bug.Comment `json:"node"`
+ Cursor string `json:"cursor"`
+ Node *bug.Comment `json:"node"`
}
type IdentityConnection struct {
- Edges []IdentityEdge `json:"edges"`
+ Edges []*IdentityEdge `json:"edges"`
Nodes []identity.Interface `json:"nodes"`
- PageInfo PageInfo `json:"pageInfo"`
+ PageInfo *PageInfo `json:"pageInfo"`
TotalCount int `json:"totalCount"`
}
@@ -61,10 +61,10 @@ type IdentityEdge struct {
// The connection type for an Operation
type OperationConnection struct {
- Edges []OperationEdge `json:"edges"`
- Nodes []bug.Operation `json:"nodes"`
- PageInfo PageInfo `json:"pageInfo"`
- TotalCount int `json:"totalCount"`
+ Edges []*OperationEdge `json:"edges"`
+ Nodes []bug.Operation `json:"nodes"`
+ PageInfo *PageInfo `json:"pageInfo"`
+ TotalCount int `json:"totalCount"`
}
// Represent an Operation
@@ -87,10 +87,10 @@ type PageInfo struct {
// The connection type for TimelineItem
type TimelineItemConnection struct {
- Edges []TimelineItemEdge `json:"edges"`
- Nodes []bug.TimelineItem `json:"nodes"`
- PageInfo PageInfo `json:"pageInfo"`
- TotalCount int `json:"totalCount"`
+ Edges []*TimelineItemEdge `json:"edges"`
+ Nodes []bug.TimelineItem `json:"nodes"`
+ PageInfo *PageInfo `json:"pageInfo"`
+ TotalCount int `json:"totalCount"`
}
// Represent a TimelineItem
@@ -29,15 +29,19 @@ func (bugResolver) Comments(ctx context.Context, obj *bug.Snapshot, after *strin
edger := func(comment bug.Comment, offset int) connections.Edge {
return models.CommentEdge{
- Node: comment,
+ Node: &comment,
Cursor: connections.OffsetToCursor(offset),
}
}
- conMaker := func(edges []models.CommentEdge, nodes []bug.Comment, info models.PageInfo, totalCount int) (*models.CommentConnection, error) {
+ conMaker := func(edges []*models.CommentEdge, nodes []bug.Comment, info *models.PageInfo, totalCount int) (*models.CommentConnection, error) {
+ var commentNodes []*bug.Comment
+ for _, c := range nodes {
+ commentNodes = append(commentNodes, &c)
+ }
return &models.CommentConnection{
Edges: edges,
- Nodes: nodes,
+ Nodes: commentNodes,
PageInfo: info,
TotalCount: totalCount,
}, nil
@@ -61,7 +65,7 @@ func (bugResolver) Operations(ctx context.Context, obj *bug.Snapshot, after *str
}
}
- conMaker := func(edges []models.OperationEdge, nodes []bug.Operation, info models.PageInfo, totalCount int) (*models.OperationConnection, error) {
+ conMaker := func(edges []*models.OperationEdge, nodes []bug.Operation, info *models.PageInfo, totalCount int) (*models.OperationConnection, error) {
return &models.OperationConnection{
Edges: edges,
Nodes: nodes,
@@ -88,7 +92,7 @@ func (bugResolver) Timeline(ctx context.Context, obj *bug.Snapshot, after *strin
}
}
- conMaker := func(edges []models.TimelineItemEdge, nodes []bug.TimelineItem, info models.PageInfo, totalCount int) (*models.TimelineItemConnection, error) {
+ conMaker := func(edges []*models.TimelineItemEdge, nodes []bug.TimelineItem, info *models.PageInfo, totalCount int) (*models.TimelineItemConnection, error) {
return &models.TimelineItemConnection{
Edges: edges,
Nodes: nodes,
@@ -120,7 +124,7 @@ func (bugResolver) Actors(ctx context.Context, obj *bug.Snapshot, after *string,
}
}
- conMaker := func(edges []models.IdentityEdge, nodes []identity.Interface, info models.PageInfo, totalCount int) (*models.IdentityConnection, error) {
+ conMaker := func(edges []*models.IdentityEdge, nodes []identity.Interface, info *models.PageInfo, totalCount int) (*models.IdentityConnection, error) {
return &models.IdentityConnection{
Edges: edges,
Nodes: nodes,
@@ -147,7 +151,7 @@ func (bugResolver) Participants(ctx context.Context, obj *bug.Snapshot, after *s
}
}
- conMaker := func(edges []models.IdentityEdge, nodes []identity.Interface, info models.PageInfo, totalCount int) (*models.IdentityConnection, error) {
+ conMaker := func(edges []*models.IdentityEdge, nodes []identity.Interface, info *models.PageInfo, totalCount int) (*models.IdentityConnection, error) {
return &models.IdentityConnection{
Edges: edges,
Nodes: nodes,
@@ -46,9 +46,9 @@ func (repoResolver) AllBugs(ctx context.Context, obj *models.Repository, after *
}
// The conMaker will finally load and compile bugs from git to replace the selected edges
- conMaker := func(lazyBugEdges []connections.LazyBugEdge, lazyNode []string, info models.PageInfo, totalCount int) (*models.BugConnection, error) {
- edges := make([]models.BugEdge, len(lazyBugEdges))
- nodes := make([]bug.Snapshot, len(lazyBugEdges))
+ conMaker := func(lazyBugEdges []*connections.LazyBugEdge, lazyNode []string, info *models.PageInfo, totalCount int) (*models.BugConnection, error) {
+ edges := make([]*models.BugEdge, len(lazyBugEdges))
+ nodes := make([]*bug.Snapshot, len(lazyBugEdges))
for i, lazyBugEdge := range lazyBugEdges {
b, err := obj.Repo.ResolveBug(lazyBugEdge.Id)
@@ -59,11 +59,11 @@ func (repoResolver) AllBugs(ctx context.Context, obj *models.Repository, after *
snap := b.Snapshot()
- edges[i] = models.BugEdge{
+ edges[i] = &models.BugEdge{
Cursor: lazyBugEdge.Cursor,
- Node: *snap,
+ Node: snap,
}
- nodes[i] = *snap
+ nodes[i] = snap
}
return &models.BugConnection{
@@ -107,8 +107,8 @@ func (repoResolver) AllIdentities(ctx context.Context, obj *models.Repository, a
}
// The conMaker will finally load and compile identities from git to replace the selected edges
- conMaker := func(lazyIdentityEdges []connections.LazyIdentityEdge, lazyNode []string, info models.PageInfo, totalCount int) (*models.IdentityConnection, error) {
- edges := make([]models.IdentityEdge, len(lazyIdentityEdges))
+ conMaker := func(lazyIdentityEdges []*connections.LazyIdentityEdge, lazyNode []string, info *models.PageInfo, totalCount int) (*models.IdentityConnection, error) {
+ edges := make([]*models.IdentityEdge, len(lazyIdentityEdges))
nodes := make([]identity.Interface, len(lazyIdentityEdges))
for k, lazyIdentityEdge := range lazyIdentityEdges {
@@ -120,9 +120,9 @@ func (repoResolver) AllIdentities(ctx context.Context, obj *models.Repository, a
ii := identity.Interface(i.Identity)
- edges[k] = models.IdentityEdge{
+ edges[k] = &models.IdentityEdge{
Cursor: lazyIdentityEdge.Cursor,
- Node: ii,
+ Node: i.Identity,
}
nodes[k] = ii
}