BlueGit

timfa bluegit

Files

bluegit / internal / store / repos.go

repos.go

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