1package resolvers
2
3import (
4 "context"
5
6 "github.com/MichaelMure/git-bug/bug"
7 "github.com/MichaelMure/git-bug/cache"
8 "github.com/MichaelMure/git-bug/entity"
9 "github.com/MichaelMure/git-bug/graphql/connections"
10 "github.com/MichaelMure/git-bug/graphql/graph"
11 "github.com/MichaelMure/git-bug/graphql/models"
12)
13
14var _ graph.RepositoryResolver = &repoResolver{}
15
16type repoResolver struct{}
17
18func (repoResolver) AllBugs(_ context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, queryStr *string) (*models.BugConnection, error) {
19 input := models.ConnectionInput{
20 Before: before,
21 After: after,
22 First: first,
23 Last: last,
24 }
25
26 var query *cache.Query
27 if queryStr != nil {
28 query2, err := cache.ParseQuery(*queryStr)
29 if err != nil {
30 return nil, err
31 }
32 query = query2
33 } else {
34 query = cache.NewQuery()
35 }
36
37 // Simply pass a []string with the ids to the pagination algorithm
38 source := obj.Repo.QueryBugs(query)
39
40 // The edger create a custom edge holding just the id
41 edger := func(id entity.Id, offset int) connections.Edge {
42 return connections.LazyBugEdge{
43 Id: id,
44 Cursor: connections.OffsetToCursor(offset),
45 }
46 }
47
48 // The conMaker will finally load and compile bugs from git to replace the selected edges
49 conMaker := func(lazyBugEdges []*connections.LazyBugEdge, lazyNode []entity.Id, info *models.PageInfo, totalCount int) (*models.BugConnection, error) {
50 edges := make([]*models.BugEdge, len(lazyBugEdges))
51 nodes := make([]models.BugWrapper, len(lazyBugEdges))
52
53 for i, lazyBugEdge := range lazyBugEdges {
54 excerpt, err := obj.Repo.ResolveBugExcerpt(lazyBugEdge.Id)
55 if err != nil {
56 return nil, err
57 }
58
59 b := models.NewLazyBug(obj.Repo, excerpt)
60
61 edges[i] = &models.BugEdge{
62 Cursor: lazyBugEdge.Cursor,
63 Node: b,
64 }
65 nodes[i] = b
66 }
67
68 return &models.BugConnection{
69 Edges: edges,
70 Nodes: nodes,
71 PageInfo: info,
72 TotalCount: totalCount,
73 }, nil
74 }
75
76 return connections.LazyBugCon(source, edger, conMaker, input)
77}
78
79func (repoResolver) Bug(_ context.Context, obj *models.Repository, prefix string) (models.BugWrapper, error) {
80 excerpt, err := obj.Repo.ResolveBugExcerptPrefix(prefix)
81 if err != nil {
82 return nil, err
83 }
84
85 return models.NewLazyBug(obj.Repo, excerpt), nil
86}
87
88func (repoResolver) AllIdentities(_ context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error) {
89 input := models.ConnectionInput{
90 Before: before,
91 After: after,
92 First: first,
93 Last: last,
94 }
95
96 // Simply pass a []string with the ids to the pagination algorithm
97 source := obj.Repo.AllIdentityIds()
98
99 // The edger create a custom edge holding just the id
100 edger := func(id entity.Id, offset int) connections.Edge {
101 return connections.LazyIdentityEdge{
102 Id: id,
103 Cursor: connections.OffsetToCursor(offset),
104 }
105 }
106
107 // The conMaker will finally load and compile identities from git to replace the selected edges
108 conMaker := func(lazyIdentityEdges []*connections.LazyIdentityEdge, lazyNode []entity.Id, info *models.PageInfo, totalCount int) (*models.IdentityConnection, error) {
109 edges := make([]*models.IdentityEdge, len(lazyIdentityEdges))
110 nodes := make([]models.IdentityWrapper, len(lazyIdentityEdges))
111
112 for k, lazyIdentityEdge := range lazyIdentityEdges {
113 excerpt, err := obj.Repo.ResolveIdentityExcerpt(lazyIdentityEdge.Id)
114 if err != nil {
115 return nil, err
116 }
117
118 i := models.NewLazyIdentity(obj.Repo, excerpt)
119
120 edges[k] = &models.IdentityEdge{
121 Cursor: lazyIdentityEdge.Cursor,
122 Node: i,
123 }
124 nodes[k] = i
125 }
126
127 return &models.IdentityConnection{
128 Edges: edges,
129 Nodes: nodes,
130 PageInfo: info,
131 TotalCount: totalCount,
132 }, nil
133 }
134
135 return connections.LazyIdentityCon(source, edger, conMaker, input)
136}
137
138func (repoResolver) Identity(_ context.Context, obj *models.Repository, prefix string) (models.IdentityWrapper, error) {
139 excerpt, err := obj.Repo.ResolveIdentityExcerptPrefix(prefix)
140 if err != nil {
141 return nil, err
142 }
143
144 return models.NewLazyIdentity(obj.Repo, excerpt), nil
145}
146
147func (repoResolver) UserIdentity(_ context.Context, obj *models.Repository) (models.IdentityWrapper, error) {
148 excerpt, err := obj.Repo.GetUserIdentityExcerpt()
149 if err != nil {
150 return nil, err
151 }
152
153 return models.NewLazyIdentity(obj.Repo, excerpt), nil
154}
155
156func (resolver repoResolver) ValidLabels(_ context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.LabelConnection, error) {
157 input := models.ConnectionInput{
158 Before: before,
159 After: after,
160 First: first,
161 Last: last,
162 }
163
164 edger := func(label bug.Label, offset int) connections.Edge {
165 return models.LabelEdge{
166 Node: label,
167 Cursor: connections.OffsetToCursor(offset),
168 }
169 }
170
171 conMaker := func(edges []*models.LabelEdge, nodes []bug.Label, info *models.PageInfo, totalCount int) (*models.LabelConnection, error) {
172 return &models.LabelConnection{
173 Edges: edges,
174 Nodes: nodes,
175 PageInfo: info,
176 TotalCount: totalCount,
177 }, nil
178 }
179
180 return connections.LabelCon(obj.Repo.ValidLabels(), edger, conMaker, input)
181}