BlueGit

timfa bluegit

Files

bluegit / internal / store / repos.go

repos.go

feat: projectpagina met overzicht en bestanden
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 4 weeks ago
Failed ea0d24ce History
repos.go 18.6 KiB Download Raw
1package store
2
3import (
4 "context"
5 "database/sql"
6 "errors"
7 "fmt"
8 "strings"
9 "time"
10
11 "gitlab.com/Timfa/bluegit/internal/access"
12 "gitlab.com/Timfa/bluegit/internal/names"
13)
14
15// Group is een verzameling repositories en leden.
16type Group struct {
17 ID int64
18 Name string
19 Path string
20 Description string
21 CreatedBy int64
22 CreatedAt time.Time
23}
24
25// Repo is een git-repository van een gebruiker of een groep.
26type Repo struct {
27 ID int64
28 OwnerKind string
29 OwnerID int64
30 OwnerPath string
31 Name string
32 Description string
33 DefaultBranch string
34 Visibility string
35 CreatedAt time.Time
36}
37
38// FullPath is owner/naam.
39func (r Repo) FullPath() string { return r.OwnerPath + "/" + r.Name }
40
41// CreateGroup maakt een groep. De maker wordt beheerder.
42func (s *Store) CreateGroup(ctx context.Context, creator int64, name, path, description string) (Group, error) {
43 name = strings.TrimSpace(name)
44 path = strings.ToLower(strings.TrimSpace(path))
45 if name == "" {
46 return Group{}, fmt.Errorf("de groep heeft een naam nodig")
47 }
48 if err := names.ValidGroupPath(path); err != nil {
49 return Group{}, err
50 }
51 if err := s.ensurePathFree(ctx, path); err != nil {
52 return Group{}, err
53 }
54 res, err := s.db.ExecContext(ctx, `INSERT INTO groups (name, path, description, created_by, created_at) VALUES (?, ?, ?, ?, ?)`,
55 name, path, strings.TrimSpace(description), creator, now())
56 if err != nil {
57 return Group{}, err
58 }
59 id, _ := res.LastInsertId()
60 if _, err := s.db.ExecContext(ctx, `INSERT INTO group_members (group_id, user_id, role) VALUES (?, ?, ?)`, id, creator, string(access.RoleMaintainer)); err != nil {
61 return Group{}, err
62 }
63 return s.GroupByID(ctx, id)
64}
65
66func (s *Store) ensurePathFree(ctx context.Context, path string) error {
67 var n int
68 if err := s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM users WHERE username = ?`, path).Scan(&n); err != nil {
69 return err
70 }
71 if n > 0 {
72 return fmt.Errorf("pad %s is al een gebruiker", path)
73 }
74 if err := s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM groups WHERE path = ?`, path).Scan(&n); err != nil {
75 return err
76 }
77 if n > 0 {
78 return fmt.Errorf("pad %s is al een groep", path)
79 }
80 return nil
81}
82
83// GroupByPath leest een groep.
84func (s *Store) GroupByPath(ctx context.Context, path string) (Group, error) {
85 row := s.db.QueryRowContext(ctx, `SELECT id, name, path, description, created_by, created_at FROM groups WHERE path = ?`, path)
86 return scanGroup(row)
87}
88
89// GroupByID leest een groep.
90func (s *Store) GroupByID(ctx context.Context, id int64) (Group, error) {
91 row := s.db.QueryRowContext(ctx, `SELECT id, name, path, description, created_by, created_at FROM groups WHERE id = ?`, id)
92 return scanGroup(row)
93}
94
95func scanGroup(row *sql.Row) (Group, error) {
96 var g Group
97 var created string
98 if err := row.Scan(&g.ID, &g.Name, &g.Path, &g.Description, &g.CreatedBy, &created); err != nil {
99 if errors.Is(err, sql.ErrNoRows) {
100 return Group{}, errNotFound
101 }
102 return Group{}, err
103 }
104 g.CreatedAt = parseTime(created)
105 return g, nil
106}
107
108// GroupRole is de rol van een gebruiker in een groep.
109// Installatiebeheer geeft geen lidmaatschap.
110func (s *Store) GroupRole(ctx context.Context, groupID, userID int64) (access.Role, error) {
111 if userID == 0 {
112 return access.RoleNone, nil
113 }
114 var role string
115 err := s.db.QueryRowContext(ctx, `SELECT role FROM group_members WHERE group_id = ? AND user_id = ?`, groupID, userID).Scan(&role)
116 if errors.Is(err, sql.ErrNoRows) {
117 return access.RoleNone, nil
118 }
119 if err != nil {
120 return access.RoleNone, err
121 }
122 return access.Role(role), nil
123}
124
125// ListGroups geeft de groepen waarvan deze gebruiker lid is.
126func (s *Store) ListGroups(ctx context.Context, userID int64) ([]Group, error) {
127 q := `SELECT id, name, path, description, created_by, created_at FROM groups WHERE id IN (SELECT group_id FROM group_members WHERE user_id = ?) ORDER BY path`
128 args := []any{userID}
129 rows, err := s.db.QueryContext(ctx, q, args...)
130 if err != nil {
131 return nil, err
132 }
133 defer rows.Close()
134 var out []Group
135 for rows.Next() {
136 var g Group
137 var created string
138 if err := rows.Scan(&g.ID, &g.Name, &g.Path, &g.Description, &g.CreatedBy, &created); err != nil {
139 return nil, err
140 }
141 g.CreatedAt = parseTime(created)
142 out = append(out, g)
143 }
144 return out, rows.Err()
145}
146
147// CreateRepo maakt de metadata. De schijfmap maakt de aanroeper.
148func (s *Store) CreateRepo(ctx context.Context, ownerKind string, ownerID int64, name, description, defaultBranch, visibility string) (Repo, error) {
149 if ownerKind != "user" && ownerKind != "group" {
150 return Repo{}, fmt.Errorf("eigenaar moet user of group zijn")
151 }
152 if err := names.ValidRepoName(name); err != nil {
153 return Repo{}, err
154 }
155 if visibility != "public" && visibility != "private" {
156 return Repo{}, fmt.Errorf("zichtbaarheid moet public of private zijn")
157 }
158 if defaultBranch == "" {
159 defaultBranch = "master"
160 }
161 if ownerKind == "user" {
162 u, err := s.UserByID(ctx, ownerID)
163 if err != nil {
164 return Repo{}, err
165 }
166 var n int
167 if err := s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM groups WHERE path = ?`, u.Username).Scan(&n); err != nil {
168 return Repo{}, err
169 }
170 if n > 0 {
171 return Repo{}, fmt.Errorf("er bestaat al een groep %s; persoonlijke repositories zijn dan niet bereikbaar", u.Username)
172 }
173 }
174 res, err := s.db.ExecContext(ctx, `INSERT INTO repos (owner_kind, owner_id, name, description, default_branch, visibility, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)`,
175 ownerKind, ownerID, name, strings.TrimSpace(description), defaultBranch, visibility, now())
176 if err != nil {
177 if strings.Contains(err.Error(), "UNIQUE") {
178 return Repo{}, fmt.Errorf("er is al een repository %s", name)
179 }
180 return Repo{}, err
181 }
182 id, _ := res.LastInsertId()
183 if err := s.AddProtected(ctx, id, defaultBranch); err != nil {
184 return Repo{}, err
185 }
186 return s.RepoByID(ctx, id)
187}
188
189// RepoByID leest een repository.
190func (s *Store) RepoByID(ctx context.Context, id int64) (Repo, error) {
191 row := s.db.QueryRowContext(ctx, repoSelect+` WHERE r.id = ?`, id)
192 return scanRepo(row)
193}
194
195// RepoByPath leest owner/naam.
196func (s *Store) RepoByPath(ctx context.Context, owner, name string) (Repo, error) {
197 row := s.db.QueryRowContext(ctx, repoSelect+`
198 WHERE r.name = ? AND (
199 (r.owner_kind = 'user' AND r.owner_id = (SELECT id FROM users WHERE username = ?))
200 OR (r.owner_kind = 'group' AND r.owner_id = (SELECT id FROM groups WHERE path = ?))
201 )`, name, owner, owner)
202 return scanRepo(row)
203}
204
205const repoSelect = `
206SELECT r.id, r.owner_kind, r.owner_id,
207 CASE r.owner_kind WHEN 'user' THEN (SELECT username FROM users WHERE id = r.owner_id) ELSE (SELECT path FROM groups WHERE id = r.owner_id) END,
208 r.name, r.description, r.default_branch, r.visibility, r.created_at
209FROM repos r`
210
211func scanRepo(row *sql.Row) (Repo, error) {
212 var r Repo
213 var created string
214 var owner sql.NullString
215 if err := row.Scan(&r.ID, &r.OwnerKind, &r.OwnerID, &owner, &r.Name, &r.Description, &r.DefaultBranch, &r.Visibility, &created); err != nil {
216 if errors.Is(err, sql.ErrNoRows) {
217 return Repo{}, errNotFound
218 }
219 return Repo{}, err
220 }
221 r.OwnerPath = owner.String
222 r.CreatedAt = parseTime(created)
223 return r, nil
224}
225
226// UpdateRepo wijzigt beschrijving en zichtbaarheid.
227func (s *Store) UpdateRepo(ctx context.Context, id int64, description, visibility string) error {
228 if visibility != "public" && visibility != "private" {
229 return fmt.Errorf("zichtbaarheid moet public of private zijn")
230 }
231 _, err := s.db.ExecContext(ctx, `UPDATE repos SET description = ?, visibility = ? WHERE id = ?`, strings.TrimSpace(description), visibility, id)
232 return err
233}
234
235// DeleteRepo verwijdert de metadata. Bestanden verwijdert de aanroeper.
236func (s *Store) DeleteRepo(ctx context.Context, id int64) error {
237 _, err := s.db.ExecContext(ctx, `DELETE FROM repos WHERE id = ?`, id)
238 return err
239}
240
241// ListRepoIDs geeft repositories die deze gebruiker mag zien:
242// openbare repositories, eigen repositories, repositories van een groep
243// waarvan hij lid is, en repositories met een rechtstreeks lidmaatschap.
244// Installatiebeheer voegt daar niets aan toe.
245func (s *Store) ListRepoIDs(ctx context.Context, userID int64) ([]int64, error) {
246 q := `SELECT id FROM repos WHERE visibility = 'public'`
247 args := []any{}
248 if userID != 0 {
249 q = `SELECT DISTINCT id FROM repos WHERE visibility = 'public'
250 OR (owner_kind = 'user' AND owner_id = ?)
251 OR (owner_kind = 'group' AND owner_id IN (SELECT group_id FROM group_members WHERE user_id = ?))
252 OR id IN (SELECT repo_id FROM repo_members WHERE user_id = ?)`
253 args = []any{userID, userID, userID}
254 }
255 q += ` ORDER BY id DESC`
256 rows, err := s.db.QueryContext(ctx, q, args...)
257 if err != nil {
258 return nil, err
259 }
260 defer rows.Close()
261 var ids []int64
262 for rows.Next() {
263 var id int64
264 if err := rows.Scan(&id); err != nil {
265 return nil, err
266 }
267 ids = append(ids, id)
268 }
269 return ids, rows.Err()
270}
271
272// ReposByGroup geeft de repositories van een groep.
273func (s *Store) ReposByGroup(ctx context.Context, groupID int64) ([]Repo, error) {
274 rows, err := s.db.QueryContext(ctx, repoSelect+` WHERE r.owner_kind = 'group' AND r.owner_id = ? ORDER BY r.name`, groupID)
275 if err != nil {
276 return nil, err
277 }
278 defer rows.Close()
279 return scanRepos(rows)
280}
281
282// ReposByIDs laadt een lijst.
283func (s *Store) ReposByIDs(ctx context.Context, ids []int64) ([]Repo, error) {
284 var out []Repo
285 for _, id := range ids {
286 r, err := s.RepoByID(ctx, id)
287 if err != nil {
288 return nil, err
289 }
290 out = append(out, r)
291 }
292 return out, nil
293}
294
295func scanRepos(rows *sql.Rows) ([]Repo, error) {
296 var out []Repo
297 for rows.Next() {
298 var r Repo
299 var created string
300 var owner sql.NullString
301 if err := rows.Scan(&r.ID, &r.OwnerKind, &r.OwnerID, &owner, &r.Name, &r.Description, &r.DefaultBranch, &r.Visibility, &created); err != nil {
302 return nil, err
303 }
304 r.OwnerPath = owner.String
305 r.CreatedAt = parseTime(created)
306 out = append(out, r)
307 }
308 return out, rows.Err()
309}
310
311// AllRepos is voor het verversen van hooks bij het starten.
312func (s *Store) AllRepos(ctx context.Context) ([]Repo, error) {
313 rows, err := s.db.QueryContext(ctx, repoSelect+` ORDER BY r.id`)
314 if err != nil {
315 return nil, err
316 }
317 defer rows.Close()
318 return scanRepos(rows)
319}
320
321// EffectiveRole past de rolregels toe op een repository.
322func (s *Store) EffectiveRole(ctx context.Context, userID, repoID int64) (access.Role, error) {
323 if userID == 0 {
324 return access.RoleNone, nil
325 }
326 if _, err := s.UserByID(ctx, userID); err != nil {
327 return access.RoleNone, err
328 }
329 repo, err := s.RepoByID(ctx, repoID)
330 if err != nil {
331 return access.RoleNone, err
332 }
333 in := access.Input{}
334 if repo.OwnerKind == "user" && repo.OwnerID == userID {
335 in.UserOwner = true
336 }
337 if repo.OwnerKind == "group" {
338 var role string
339 err := s.db.QueryRowContext(ctx, `SELECT role FROM group_members WHERE group_id = ? AND user_id = ?`, repo.OwnerID, userID).Scan(&role)
340 if err != nil && !errors.Is(err, sql.ErrNoRows) {
341 return access.RoleNone, err
342 }
343 if err == nil {
344 in.GroupRole = access.Role(role)
345 }
346 }
347 var role string
348 err = s.db.QueryRowContext(ctx, `SELECT role FROM repo_members WHERE repo_id = ? AND user_id = ?`, repoID, userID).Scan(&role)
349 if err != nil && !errors.Is(err, sql.ErrNoRows) {
350 return access.RoleNone, err
351 }
352 if err == nil {
353 in.RepoRole = access.Role(role)
354 }
355 return access.Resolve(in), nil
356}
357
358// Member is een lid of een uitnodiging op gebruikersnaam.
359type Member struct {
360 UserID int64
361 Username string
362 Role access.Role
363 Pending bool
364}
365
366// SetMember zet een lidmaatschap. Een onbekende naam blijft wachten tot de eerste login.
367func (s *Store) SetMember(ctx context.Context, scopeKind string, scopeID int64, username string, role access.Role) error {
368 if scopeKind != "repo" && scopeKind != "group" {
369 return fmt.Errorf("scope moet repo of group zijn")
370 }
371 if _, err := access.ParseRole(string(role)); err != nil {
372 return err
373 }
374 username = strings.ToLower(strings.TrimSpace(username))
375 if err := names.ValidUsername(username); err != nil {
376 return err
377 }
378 u, err := s.UserByUsername(ctx, username)
379 if IsNotFound(err) {
380 _, err = s.db.ExecContext(ctx, `INSERT INTO pending_members (scope_kind, scope_id, username, role) VALUES (?, ?, ?, ?)
381 ON CONFLICT(scope_kind, scope_id, username) DO UPDATE SET role = excluded.role`, scopeKind, scopeID, username, string(role))
382 return err
383 }
384 if err != nil {
385 return err
386 }
387 table, col := "repo_members", "repo_id"
388 if scopeKind == "group" {
389 table, col = "group_members", "group_id"
390 }
391 _, err = s.db.ExecContext(ctx, `INSERT INTO `+table+` (`+col+`, user_id, role) VALUES (?, ?, ?)
392 ON CONFLICT(`+col+`, user_id) DO UPDATE SET role = excluded.role`, scopeID, u.ID, string(role))
393 return err
394}
395
396// RemoveMember haalt een lid of een uitnodiging weg.
397func (s *Store) RemoveMember(ctx context.Context, scopeKind string, scopeID int64, username string) error {
398 username = strings.ToLower(strings.TrimSpace(username))
399 _, err := s.db.ExecContext(ctx, `DELETE FROM pending_members WHERE scope_kind = ? AND scope_id = ? AND username = ?`, scopeKind, scopeID, username)
400 if err != nil {
401 return err
402 }
403 u, err := s.UserByUsername(ctx, username)
404 if IsNotFound(err) {
405 return nil
406 }
407 if err != nil {
408 return err
409 }
410 if scopeKind == "group" {
411 _, err = s.db.ExecContext(ctx, `DELETE FROM group_members WHERE group_id = ? AND user_id = ?`, scopeID, u.ID)
412 return err
413 }
414 _, err = s.db.ExecContext(ctx, `DELETE FROM repo_members WHERE repo_id = ? AND user_id = ?`, scopeID, u.ID)
415 return err
416}
417
418// ListMembers geeft leden van een repository of groep, plus open uitnodigingen.
419func (s *Store) ListMembers(ctx context.Context, scopeKind string, scopeID int64) ([]Member, error) {
420 var q string
421 if scopeKind == "group" {
422 q = `SELECT u.id, u.username, m.role FROM group_members m JOIN users u ON u.id = m.user_id WHERE m.group_id = ? ORDER BY u.username`
423 } else {
424 q = `SELECT u.id, u.username, m.role FROM repo_members m JOIN users u ON u.id = m.user_id WHERE m.repo_id = ? ORDER BY u.username`
425 }
426 rows, err := s.db.QueryContext(ctx, q, scopeID)
427 if err != nil {
428 return nil, err
429 }
430 defer rows.Close()
431 var out []Member
432 for rows.Next() {
433 var m Member
434 var role string
435 if err := rows.Scan(&m.UserID, &m.Username, &role); err != nil {
436 return nil, err
437 }
438 m.Role = access.Role(role)
439 out = append(out, m)
440 }
441 if err := rows.Err(); err != nil {
442 return nil, err
443 }
444 prows, err := s.db.QueryContext(ctx, `SELECT username, role FROM pending_members WHERE scope_kind = ? AND scope_id = ? ORDER BY username`, scopeKind, scopeID)
445 if err != nil {
446 return nil, err
447 }
448 defer prows.Close()
449 for prows.Next() {
450 var m Member
451 var role string
452 if err := prows.Scan(&m.Username, &role); err != nil {
453 return nil, err
454 }
455 m.Role = access.Role(role)
456 m.Pending = true
457 out = append(out, m)
458 }
459 return out, prows.Err()
460}
461
462// ProtectedPatterns geeft de beschermde branchpatronen.
463func (s *Store) ProtectedPatterns(ctx context.Context, repoID int64) ([]string, error) {
464 rows, err := s.db.QueryContext(ctx, `SELECT pattern FROM protected_branches WHERE repo_id = ? ORDER BY pattern`, repoID)
465 if err != nil {
466 return nil, err
467 }
468 defer rows.Close()
469 var out []string
470 for rows.Next() {
471 var p string
472 if err := rows.Scan(&p); err != nil {
473 return nil, err
474 }
475 out = append(out, p)
476 }
477 return out, rows.Err()
478}
479
480// AddProtected voegt een patroon toe.
481func (s *Store) AddProtected(ctx context.Context, repoID int64, pattern string) error {
482 pattern = strings.TrimSpace(pattern)
483 if pattern == "" || strings.Contains(pattern, " ") || strings.Contains(pattern, "..") {
484 return fmt.Errorf("patroon %q is niet bruikbaar", pattern)
485 }
486 _, err := s.db.ExecContext(ctx, `INSERT INTO protected_branches (repo_id, pattern) VALUES (?, ?)`, repoID, pattern)
487 if err != nil && strings.Contains(err.Error(), "UNIQUE") {
488 return nil
489 }
490 return err
491}
492
493// RemoveProtected haalt een patroon weg.
494func (s *Store) RemoveProtected(ctx context.Context, repoID int64, pattern string) error {
495 _, err := s.db.ExecContext(ctx, `DELETE FROM protected_branches WHERE repo_id = ? AND pattern = ?`, repoID, pattern)
496 return err
497}
498
499// SecretMeta is een geheim zonder de waarde.
500type SecretMeta struct {
501 Name string
502 Protected bool
503 CreatedAt time.Time
504}
505
506// PutSecret bewaart een versleutelde waarde. De naam is een omgevingsvariabele.
507func (s *Store) PutSecret(ctx context.Context, scopeKind string, scopeID int64, name, value string, protected bool) error {
508 if scopeKind != "repo" && scopeKind != "group" {
509 return fmt.Errorf("scope moet repo of group zijn")
510 }
511 if err := access.ValidSecretName(name); err != nil {
512 return err
513 }
514 if strings.TrimSpace(value) == "" {
515 return fmt.Errorf("de waarde is leeg")
516 }
517 nonce, ct, err := s.encrypt(value)
518 if err != nil {
519 return err
520 }
521 _, err = s.db.ExecContext(ctx, `INSERT INTO secrets (scope_kind, scope_id, name, ciphertext, nonce, protected, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)
522 ON CONFLICT(scope_kind, scope_id, name) DO UPDATE SET ciphertext = excluded.ciphertext, nonce = excluded.nonce, protected = excluded.protected`,
523 scopeKind, scopeID, name, ct, nonce, boolInt(protected), now())
524 return err
525}
526
527// DeleteSecret verwijdert een geheim.
528func (s *Store) DeleteSecret(ctx context.Context, scopeKind string, scopeID int64, name string) error {
529 _, err := s.db.ExecContext(ctx, `DELETE FROM secrets WHERE scope_kind = ? AND scope_id = ? AND name = ?`, scopeKind, scopeID, name)
530 return err
531}
532
533// ListSecrets geeft namen, niet de waarden.
534func (s *Store) ListSecrets(ctx context.Context, scopeKind string, scopeID int64) ([]SecretMeta, error) {
535 rows, err := s.db.QueryContext(ctx, `SELECT name, protected, created_at FROM secrets WHERE scope_kind = ? AND scope_id = ? ORDER BY name`, scopeKind, scopeID)
536 if err != nil {
537 return nil, err
538 }
539 defer rows.Close()
540 var out []SecretMeta
541 for rows.Next() {
542 var m SecretMeta
543 var p int
544 var created string
545 if err := rows.Scan(&m.Name, &p, &created); err != nil {
546 return nil, err
547 }
548 m.Protected = p == 1
549 m.CreatedAt = parseTime(created)
550 out = append(out, m)
551 }
552 return out, rows.Err()
553}
554
555// SecretValues ontcijfert geheimen voor een job of webhook.
556// refProtected bepaalt of beschermde geheimen meegaan.
557func (s *Store) SecretValues(ctx context.Context, scopeKind string, scopeID int64, refProtected bool) (map[string]string, error) {
558 rows, err := s.db.QueryContext(ctx, `SELECT name, ciphertext, nonce, protected FROM secrets WHERE scope_kind = ? AND scope_id = ?`, scopeKind, scopeID)
559 if err != nil {
560 return nil, err
561 }
562 defer rows.Close()
563 out := map[string]string{}
564 for rows.Next() {
565 var name string
566 var ct, nonce []byte
567 var p int
568 if err := rows.Scan(&name, &ct, &nonce, &p); err != nil {
569 return nil, err
570 }
571 if !access.InjectSecret(p == 1, refProtected) {
572 continue
573 }
574 val, err := s.decrypt(nonce, ct)
575 if err != nil {
576 return nil, err
577 }
578 out[name] = val
579 }
580 return out, rows.Err()
581}