internal/store/repos.go
338 lines · 10830 bytes
1package store
2
3import (
4 "database/sql"
5 "encoding/json"
6 "errors"
7 "fmt"
8 "strings"
9)
10
11type Repo struct {
12 ID int64
13 OwnerKind string // user | org
14 OwnerID int64
15 OwnerName string // resolved for display and disk paths
16 Name string
17 Visibility string // public | private
18 DefaultBranch string
19 ForkOf int64 // 0 when not a fork
20 Settings RepoSettings
21}
22
23type RepoSettings struct {
24 ProtectedBranches []string `json:"protected_branches,omitempty"`
25 RequireSignedCommits bool `json:"require_signed_commits,omitempty"`
26 RequireChecks bool `json:"require_checks,omitempty"`
27 RequireApprovals int `json:"require_approvals,omitempty"`
28 RequireResolved bool `json:"require_resolved,omitempty"`
29 GitDaemon bool `json:"git_daemon,omitempty"`
30 Archived bool `json:"archived,omitempty"`
31 Website string `json:"website,omitempty"`
32}
33
34// Path returns the canonical owner/name form.
35func (r Repo) Path() string { return r.OwnerName + "/" + r.Name }
36
37func (s *Store) CreateRepo(ownerKind string, ownerID int64, name, visibility string) (int64, error) {
38 res, err := s.DB.Exec(
39 "INSERT INTO repos (owner_kind, owner_id, name, visibility) VALUES (?, ?, ?, ?)",
40 ownerKind, ownerID, name, visibility)
41 if err != nil {
42 if isUniqueErr(err) {
43 return 0, fmt.Errorf("repository %q already exists", name)
44 }
45 return 0, err
46 }
47 return res.LastInsertId()
48}
49
50// repoSelect resolves the owner name from whichever table owns the repo.
51const repoSelect = `
52 SELECT r.id, r.owner_kind, r.owner_id, COALESCE(u.username, o.name),
53 r.name, r.visibility, r.default_branch, COALESCE(r.fork_of, 0), r.settings_json
54 FROM repos r
55 LEFT JOIN users u ON r.owner_kind = 'user' AND u.id = r.owner_id
56 LEFT JOIN orgs o ON r.owner_kind = 'org' AND o.id = r.owner_id`
57
58func scanRepo(row interface{ Scan(...any) error }) (Repo, error) {
59 var r Repo
60 var settingsJSON string
61 err := row.Scan(&r.ID, &r.OwnerKind, &r.OwnerID, &r.OwnerName, &r.Name, &r.Visibility, &r.DefaultBranch, &r.ForkOf, &settingsJSON)
62 if err != nil {
63 return r, err
64 }
65 if err := json.Unmarshal([]byte(settingsJSON), &r.Settings); err != nil {
66 return r, fmt.Errorf("repo %d settings: %w", r.ID, err)
67 }
68 return r, nil
69}
70
71// RepoByPath resolves "owner/name"; the owner may be a user or an org.
72func (s *Store) RepoByPath(path string) (Repo, error) {
73 owner, name, ok := strings.Cut(strings.TrimSuffix(strings.TrimPrefix(path, "/"), ".git"), "/")
74 if !ok || owner == "" || name == "" || strings.Contains(name, "/") {
75 return Repo{}, fmt.Errorf("%w: repository path must be owner/name", ErrNotFound)
76 }
77 r, err := scanRepo(s.DB.QueryRow(
78 repoSelect+" WHERE COALESCE(u.username, o.name) = ? AND r.name = ?", owner, name))
79 if errors.Is(err, sql.ErrNoRows) {
80 return Repo{}, ErrNotFound
81 }
82 return r, err
83}
84
85// SetRepoVisibility switches a repository between public and private.
86func (s *Store) SetRepoVisibility(repoID int64, visibility string) error {
87 if visibility != "public" && visibility != "private" {
88 return fmt.Errorf("visibility must be public or private")
89 }
90 _, err := s.DB.Exec("UPDATE repos SET visibility = ? WHERE id = ?", visibility, repoID)
91 return err
92}
93
94func (s *Store) SetRepoSettings(repoID int64, settings RepoSettings) error {
95 raw, err := json.Marshal(settings)
96 if err != nil {
97 return err
98 }
99 _, err = s.DB.Exec("UPDATE repos SET settings_json = ? WHERE id = ?", string(raw), repoID)
100 return err
101}
102
103// CreateFork is CreateRepo with fork_of set in the same insert, so a fork
104// never exists for a moment as a plain repository (#108).
105func (s *Store) CreateFork(ownerKind string, ownerID int64, name, visibility string, forkOf int64) (int64, error) {
106 res, err := s.DB.Exec(
107 "INSERT INTO repos (owner_kind, owner_id, name, visibility, fork_of) VALUES (?, ?, ?, ?, ?)",
108 ownerKind, ownerID, name, visibility, forkOf)
109 if err != nil {
110 if isUniqueErr(err) {
111 return 0, fmt.Errorf("repository %q already exists", name)
112 }
113 return 0, err
114 }
115 return res.LastInsertId()
116}
117
118func (s *Store) SetForkOf(repoID, parentID int64) error {
119 _, err := s.DB.Exec("UPDATE repos SET fork_of = ? WHERE id = ?", parentID, repoID)
120 return err
121}
122
123func (s *Store) DeleteRepo(repoID int64) error {
124 res, err := s.DB.Exec("DELETE FROM repos WHERE id = ?", repoID)
125 if err != nil {
126 return err
127 }
128 if n, _ := res.RowsAffected(); n == 0 {
129 return ErrNotFound
130 }
131 return nil
132}
133
134// ListReposForUser returns repos the user owns, reaches through an org
135// (unless the org scopes members to 'none'), has an explicit grant on, or
136// reaches through a team. limit 0 means everything; after (an owner/name
137// path) starts the page strictly beyond it, matching the path-ascending
138// order.
139func (s *Store) ListReposForUser(userID int64, limit int, after string) ([]Repo, error) {
140 q := repoSelect + `
141 LEFT JOIN repo_access a ON a.repo_id = r.id AND a.subject_kind = 'user' AND a.subject_id = ?
142 LEFT JOIN org_members m ON r.owner_kind = 'org' AND m.org_id = r.owner_id AND m.user_id = ?
143 LEFT JOIN orgs og ON r.owner_kind = 'org' AND og.id = r.owner_id
144 WHERE ((r.owner_kind = 'user' AND r.owner_id = ?)
145 OR a.subject_id IS NOT NULL
146 OR (m.user_id IS NOT NULL AND (m.role = 'admin' OR og.members_role <> 'none'))
147 OR EXISTS (SELECT 1 FROM team_repos tr
148 JOIN team_members tm ON tm.team_id = tr.team_id AND tm.user_id = ?
149 WHERE tr.repo_id = r.id))`
150 args := []any{userID, userID, userID, userID}
151 if after != "" {
152 owner, name, _ := strings.Cut(after, "/")
153 q += ` AND (COALESCE(u.username, o.name) > ?
154 OR (COALESCE(u.username, o.name) = ? AND r.name > ?))`
155 args = append(args, owner, owner, name)
156 }
157 q += `
158 GROUP BY r.id
159 ORDER BY 4, r.name`
160 if limit > 0 {
161 q += " LIMIT ?"
162 args = append(args, limit)
163 }
164 rows, err := s.DB.Query(q, args...)
165 if err != nil {
166 return nil, err
167 }
168 defer rows.Close()
169 var out []Repo
170 for rows.Next() {
171 r, err := scanRepo(rows)
172 if err != nil {
173 return nil, err
174 }
175 out = append(out, r)
176 }
177 return out, rows.Err()
178}
179
180// AccessRole returns the user's effective role on the repo ("" if none):
181// the strongest of any explicit grant, the role derived from org
182// membership (org admin -> admin; plain member -> the org's members_role,
183// 'write' by default so the pre-teams model is the degenerate case), and
184// any team grants on the repo.
185func (s *Store) AccessRole(repoID, userID int64) (string, error) {
186 rank := map[string]int{"": 0, "none": 0, "read": 1, "write": 2, "admin": 3}
187 best := ""
188 better := func(role string) {
189 if rank[role] > rank[best] {
190 best = role
191 }
192 }
193
194 var explicit string
195 err := s.DB.QueryRow(
196 "SELECT role FROM repo_access WHERE repo_id = ? AND subject_kind = 'user' AND subject_id = ?",
197 repoID, userID).Scan(&explicit)
198 if err != nil && !errors.Is(err, sql.ErrNoRows) {
199 return "", err
200 }
201 better(explicit)
202
203 var orgRole, membersRole string
204 err = s.DB.QueryRow(`
205 SELECT m.role, o.members_role FROM repos r
206 JOIN org_members m ON r.owner_kind = 'org' AND m.org_id = r.owner_id AND m.user_id = ?
207 JOIN orgs o ON o.id = r.owner_id
208 WHERE r.id = ?`, userID, repoID).Scan(&orgRole, &membersRole)
209 if err != nil && !errors.Is(err, sql.ErrNoRows) {
210 return "", err
211 }
212 if orgRole == "admin" {
213 better("admin")
214 } else if orgRole == "member" {
215 better(membersRole) // write | read | none
216 }
217
218 var teamRole string
219 err = s.DB.QueryRow(`
220 SELECT tr.role FROM team_repos tr
221 JOIN team_members tm ON tm.team_id = tr.team_id AND tm.user_id = ?
222 WHERE tr.repo_id = ?
223 ORDER BY CASE tr.role WHEN 'admin' THEN 3 WHEN 'write' THEN 2 ELSE 1 END DESC
224 LIMIT 1`, userID, repoID).Scan(&teamRole)
225 if err != nil && !errors.Is(err, sql.ErrNoRows) {
226 return "", err
227 }
228 better(teamRole)
229 return best, nil
230}
231
232func (s *Store) GrantAccess(repoID, userID int64, role string) error {
233 _, err := s.DB.Exec(`
234 INSERT INTO repo_access (repo_id, subject_kind, subject_id, role) VALUES (?, 'user', ?, ?)
235 ON CONFLICT (repo_id, subject_kind, subject_id) DO UPDATE SET role = excluded.role`,
236 repoID, userID, role)
237 return err
238}
239
240func (s *Store) RevokeAccess(repoID, userID int64) error {
241 res, err := s.DB.Exec(
242 "DELETE FROM repo_access WHERE repo_id = ? AND subject_kind = 'user' AND subject_id = ?",
243 repoID, userID)
244 if err != nil {
245 return err
246 }
247 if n, _ := res.RowsAffected(); n == 0 {
248 return ErrNotFound
249 }
250 return nil
251}
252
253type AccessEntry struct {
254 Username string
255 Role string
256}
257
258func (s *Store) ListAccess(repoID int64) ([]AccessEntry, error) {
259 rows, err := s.DB.Query(`
260 SELECT u.username, a.role FROM repo_access a
261 JOIN users u ON a.subject_kind = 'user' AND u.id = a.subject_id
262 WHERE a.repo_id = ? ORDER BY u.username`, repoID)
263 if err != nil {
264 return nil, err
265 }
266 defer rows.Close()
267 var out []AccessEntry
268 for rows.Next() {
269 var e AccessEntry
270 if err := rows.Scan(&e.Username, &e.Role); err != nil {
271 return nil, err
272 }
273 out = append(out, e)
274 }
275 return out, rows.Err()
276}
277
278func (s *Store) RepoByID(id int64) (Repo, error) {
279 r, err := scanRepo(s.DB.QueryRow(repoSelect+" WHERE r.id = ?", id))
280 if errors.Is(err, sql.ErrNoRows) {
281 return Repo{}, ErrNotFound
282 }
283 return r, err
284}
285
286// ListPublicRepos returns all public repositories, for the anonymous index.
287func (s *Store) ListPublicRepos() ([]Repo, error) {
288 rows, err := s.DB.Query(repoSelect + " WHERE r.visibility = 'public' ORDER BY 4, r.name")
289 if err != nil {
290 return nil, err
291 }
292 defer rows.Close()
293 var out []Repo
294 for rows.Next() {
295 r, err := scanRepo(rows)
296 if err != nil {
297 return nil, err
298 }
299 out = append(out, r)
300 }
301 return out, rows.Err()
302}
303
304func (s *Store) UpdateDefaultBranch(repoID int64, branch string) error {
305 _, err := s.DB.Exec("UPDATE repos SET default_branch = ? WHERE id = ?", branch, repoID)
306 return err
307}
308
309// ListReposForOwner returns every repo owned by one user or org; the caller
310// filters by viewer visibility.
311func (s *Store) ListReposForOwner(ownerKind string, ownerID int64) ([]Repo, error) {
312 rows, err := s.DB.Query(repoSelect+" WHERE r.owner_kind = ? AND r.owner_id = ? ORDER BY r.name",
313 ownerKind, ownerID)
314 if err != nil {
315 return nil, err
316 }
317 defer rows.Close()
318 var out []Repo
319 for rows.Next() {
320 r, err := scanRepo(rows)
321 if err != nil {
322 return nil, err
323 }
324 out = append(out, r)
325 }
326 return out, rows.Err()
327}
328
329// TransferRepo moves a repository to a new owner. The unique index on
330// (owner_kind, owner_id, name) refuses collisions in the target namespace.
331func (s *Store) TransferRepo(repoID int64, newKind string, newOwnerID int64) error {
332 _, err := s.DB.Exec("UPDATE repos SET owner_kind = ?, owner_id = ? WHERE id = ?",
333 newKind, newOwnerID, repoID)
334 if isUniqueErr(err) {
335 return fmt.Errorf("the target owner already has a repository by that name")
336 }
337 return err
338}