BlueGit

timfa bluegit

Files

bluegit / internal / store / store.go

store.go

store.go 35.7 KiB Download Raw
1// Package store bewaart BlueGit in één SQLite-bestand op de datadisk.
2package store
3
4import (
5 "context"
6 "crypto/rand"
7 "crypto/sha256"
8 "database/sql"
9 "encoding/hex"
10 "encoding/json"
11 "errors"
12 "fmt"
13 "strings"
14 "time"
15
16 "gitlab.com/Timfa/bluegit/internal/i18n"
17 "gitlab.com/Timfa/bluegit/internal/names"
18 "gitlab.com/Timfa/bluegit/internal/secretbox"
19
20 _ "modernc.org/sqlite"
21)
22
23// Store is de metadata van deze installatie.
24type Store struct {
25 db *sql.DB
26 key []byte
27}
28
29// Open opent of maakt het databasebestand. key is 32 bytes voor geheimen.
30func Open(path string, key []byte) (*Store, error) {
31 if len(key) != 32 {
32 return nil, fmt.Errorf("geheime sleutel moet 32 bytes zijn")
33 }
34 dsn := "file:" + path + "?_pragma=busy_timeout(5000)&_pragma=foreign_keys(1)"
35 db, err := sql.Open("sqlite", dsn)
36 if err != nil {
37 return nil, err
38 }
39 db.SetMaxOpenConns(8)
40 s := &Store{db: db, key: key}
41 if _, err := db.Exec(`PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON;`); err != nil {
42 _ = db.Close()
43 return nil, err
44 }
45 if err := s.migrate(); err != nil {
46 _ = db.Close()
47 return nil, err
48 }
49 return s, nil
50}
51
52// Close sluit de database.
53func (s *Store) Close() error { return s.db.Close() }
54
55func (s *Store) migrate() error {
56 if _, err := s.db.Exec(schema); err != nil {
57 return err
58 }
59 alters := []string{
60 `ALTER TABLE users ADD COLUMN language TEXT NOT NULL DEFAULT 'en'`,
61 `ALTER TABLE groups ADD COLUMN visibility TEXT NOT NULL DEFAULT 'private'`,
62 `ALTER TABLE groups ADD COLUMN default_role TEXT NOT NULL DEFAULT 'developer'`,
63 `ALTER TABLE groups ADD COLUMN logo_mime TEXT NOT NULL DEFAULT ''`,
64 `ALTER TABLE repos ADD COLUMN logo_mime TEXT NOT NULL DEFAULT ''`,
65 `ALTER TABLE repos ADD COLUMN release_visibility TEXT NOT NULL DEFAULT 'inherit'`,
66 `ALTER TABLE repos ADD COLUMN pushed_at TEXT NOT NULL DEFAULT ''`,
67 `ALTER TABLE secrets ADD COLUMN expand INTEGER NOT NULL DEFAULT 0`,
68 `ALTER TABLE repos ADD COLUMN fork_of INTEGER NOT NULL DEFAULT 0`,
69 `ALTER TABLE repos ADD COLUMN stale_manual_days INTEGER NOT NULL DEFAULT -1`,
70 `ALTER TABLE merge_requests ADD COLUMN source_repo_id INTEGER NOT NULL DEFAULT 0`,
71 `ALTER TABLE merge_requests ADD COLUMN source_repo_branch TEXT NOT NULL DEFAULT ''`,
72 `ALTER TABLE webhooks ADD COLUMN method TEXT NOT NULL DEFAULT 'POST'`,
73 `ALTER TABLE notes ADD COLUMN file_path TEXT NOT NULL DEFAULT ''`,
74 `ALTER TABLE notes ADD COLUMN line_start INTEGER NOT NULL DEFAULT 0`,
75 `ALTER TABLE notes ADD COLUMN line_end INTEGER NOT NULL DEFAULT 0`,
76 `ALTER TABLE notes ADD COLUMN suggestion TEXT NOT NULL DEFAULT ''`,
77 `ALTER TABLE notes ADD COLUMN base_text TEXT NOT NULL DEFAULT ''`,
78 `ALTER TABLE pipelines ADD COLUMN source TEXT NOT NULL DEFAULT 'push'`,
79 `ALTER TABLE pipelines ADD COLUMN actor TEXT NOT NULL DEFAULT ''`,
80 `ALTER TABLE pipelines ADD COLUMN commit_title TEXT NOT NULL DEFAULT ''`,
81 `ALTER TABLE pipelines ADD COLUMN started_at TEXT`,
82 `ALTER TABLE jobs ADD COLUMN before_script TEXT NOT NULL DEFAULT ''`,
83 `ALTER TABLE jobs ADD COLUMN after_script TEXT NOT NULL DEFAULT ''`,
84 `ALTER TABLE jobs ADD COLUMN when_mode TEXT NOT NULL DEFAULT 'on_success'`,
85 `ALTER TABLE jobs ADD COLUMN timeout_seconds INTEGER NOT NULL DEFAULT 0`,
86 `ALTER TABLE jobs ADD COLUMN failure_reason TEXT NOT NULL DEFAULT ''`,
87 // Oude geannuleerde jobs: alleen een onderbreekbare job met de melding
88 // in het log is echt door een nieuwere pipeline gestopt. Vóór deze
89 // versie schreef de runner die melding ook bij handmatig annuleren.
90 `UPDATE jobs SET failure_reason = CASE WHEN interruptible = 1 AND log LIKE '%canceled because a newer pipeline started for the same ref%' THEN 'canceled_by_newer_pipeline' ELSE 'canceled_by_user' END WHERE status = 'canceled' AND failure_reason = ''`,
91 `ALTER TABLE jobs ADD COLUMN tags_json TEXT NOT NULL DEFAULT '[]'`,
92 `ALTER TABLE jobs ADD COLUMN cache_paths TEXT NOT NULL DEFAULT '[]'`,
93 `ALTER TABLE jobs ADD COLUMN cache_key TEXT NOT NULL DEFAULT ''`,
94 `ALTER TABLE jobs ADD COLUMN resource_group TEXT NOT NULL DEFAULT ''`,
95 `ALTER TABLE jobs ADD COLUMN optional_json TEXT NOT NULL DEFAULT '[]'`,
96 `ALTER TABLE jobs ADD COLUMN retry_max INTEGER NOT NULL DEFAULT 0`,
97 `ALTER TABLE jobs ADD COLUMN retry_when TEXT NOT NULL DEFAULT '[]'`,
98 `ALTER TABLE jobs ADD COLUMN attempt INTEGER NOT NULL DEFAULT 0`,
99 `ALTER TABLE jobs ADD COLUMN services_json TEXT NOT NULL DEFAULT '[]'`,
100 `ALTER TABLE jobs ADD COLUMN environment_name TEXT NOT NULL DEFAULT ''`,
101 `ALTER TABLE jobs ADD COLUMN environment_url TEXT NOT NULL DEFAULT ''`,
102 `ALTER TABLE jobs ADD COLUMN interruptible INTEGER NOT NULL DEFAULT 0`,
103 `ALTER TABLE jobs ADD COLUMN do_not_interrupt INTEGER NOT NULL DEFAULT 0`,
104 `ALTER TABLE pipelines ADD COLUMN mr_id INTEGER NOT NULL DEFAULT 0`,
105 `ALTER TABLE groups ADD COLUMN owner_id INTEGER NOT NULL DEFAULT 0`,
106 `ALTER TABLE merge_requests ADD COLUMN draft INTEGER NOT NULL DEFAULT 0`,
107 `ALTER TABLE merge_requests ADD COLUMN labels TEXT NOT NULL DEFAULT ''`,
108 `ALTER TABLE merge_requests ADD COLUMN remove_source_branch INTEGER NOT NULL DEFAULT 1`,
109 `ALTER TABLE merge_requests ADD COLUMN squash INTEGER NOT NULL DEFAULT 0`,
110 `ALTER TABLE merge_requests ADD COLUMN squash_message TEXT NOT NULL DEFAULT ''`,
111 `ALTER TABLE notes ADD COLUMN parent_id INTEGER NOT NULL DEFAULT 0`,
112 `ALTER TABLE secrets ADD COLUMN invisible INTEGER NOT NULL DEFAULT 0`,
113 `ALTER TABLE webhooks ADD COLUMN fields_json TEXT NOT NULL DEFAULT ''`,
114 `ALTER TABLE access_tokens ADD COLUMN scopes TEXT NOT NULL DEFAULT 'api'`,
115 `ALTER TABLE pipelines ADD COLUMN target_sha TEXT NOT NULL DEFAULT ''`,
116 `ALTER TABLE users ADD COLUMN display_name TEXT NOT NULL DEFAULT ''`,
117 `ALTER TABLE users ADD COLUMN bio TEXT NOT NULL DEFAULT ''`,
118 `ALTER TABLE users ADD COLUMN runner_pref TEXT NOT NULL DEFAULT 'builtin_first'`,
119 `ALTER TABLE groups ADD COLUMN builtin_first INTEGER NOT NULL DEFAULT 0`,
120 `ALTER TABLE runners ADD COLUMN paused INTEGER NOT NULL DEFAULT 0`,
121 `ALTER TABLE runners ADD COLUMN draining INTEGER NOT NULL DEFAULT 0`,
122 `ALTER TABLE repos ADD COLUMN ci_paused INTEGER NOT NULL DEFAULT 0`,
123 `ALTER TABLE users ADD COLUMN avatar_source TEXT NOT NULL DEFAULT ''`,
124 `ALTER TABLE users ADD COLUMN avatar_mime TEXT NOT NULL DEFAULT ''`,
125 }
126 for _, q := range alters {
127 if _, err := s.db.Exec(q); err != nil && !strings.Contains(strings.ToLower(err.Error()), "duplicate column") {
128 return err
129 }
130 }
131 if _, err := s.db.Exec(`UPDATE groups SET owner_id = created_by WHERE owner_id = 0 AND created_by != 0`); err != nil {
132 return err
133 }
134 return nil
135}
136
137const schema = `
138CREATE TABLE IF NOT EXISTS instance_settings (
139 key TEXT PRIMARY KEY,
140 value TEXT NOT NULL
141);
142CREATE TABLE IF NOT EXISTS runners (
143 id INTEGER PRIMARY KEY,
144 owner_kind TEXT NOT NULL,
145 owner_id INTEGER NOT NULL,
146 name TEXT NOT NULL,
147 token_hash TEXT NOT NULL UNIQUE,
148 created_by INTEGER NOT NULL DEFAULT 0,
149 created_at TEXT NOT NULL,
150 last_seen TEXT NOT NULL DEFAULT '',
151 version TEXT NOT NULL DEFAULT '',
152 revoked INTEGER NOT NULL DEFAULT 0
153);
154CREATE TABLE IF NOT EXISTS runner_reg_tokens (
155 id INTEGER PRIMARY KEY,
156 owner_kind TEXT NOT NULL,
157 owner_id INTEGER NOT NULL,
158 token_hash TEXT NOT NULL UNIQUE,
159 created_by INTEGER NOT NULL,
160 expires_at TEXT NOT NULL,
161 used INTEGER NOT NULL DEFAULT 0
162);
163CREATE TABLE IF NOT EXISTS group_runner_optin (
164 group_id INTEGER NOT NULL,
165 user_id INTEGER NOT NULL,
166 PRIMARY KEY (group_id, user_id)
167);
168CREATE TABLE IF NOT EXISTS job_runs (
169 job_id INTEGER PRIMARY KEY,
170 runner_id INTEGER NOT NULL DEFAULT 0,
171 runner_name TEXT NOT NULL DEFAULT '',
172 offer_tier INTEGER NOT NULL DEFAULT 0,
173 offer_at TEXT NOT NULL DEFAULT ''
174);
175CREATE TABLE IF NOT EXISTS users (
176 id INTEGER PRIMARY KEY,
177 auth_id INTEGER NOT NULL UNIQUE,
178 username TEXT NOT NULL UNIQUE,
179 avatar_url TEXT NOT NULL DEFAULT '',
180 auth_admin INTEGER NOT NULL DEFAULT 0,
181 instance_admin INTEGER NOT NULL DEFAULT 0,
182 language TEXT NOT NULL DEFAULT 'en',
183 display_name TEXT NOT NULL DEFAULT '',
184 bio TEXT NOT NULL DEFAULT '',
185 created_at TEXT NOT NULL,
186 updated_at TEXT NOT NULL
187);
188CREATE TABLE IF NOT EXISTS sessions (
189 id TEXT PRIMARY KEY,
190 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
191 access_token TEXT NOT NULL,
192 expires_at TEXT NOT NULL,
193 csrf TEXT NOT NULL,
194 created_at TEXT NOT NULL
195);
196CREATE TABLE IF NOT EXISTS access_tokens (
197 id INTEGER PRIMARY KEY,
198 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
199 name TEXT NOT NULL,
200 token_hash TEXT NOT NULL UNIQUE,
201 prefix TEXT NOT NULL,
202 created_at TEXT NOT NULL,
203 last_used_at TEXT,
204 expires_at TEXT
205);
206CREATE TABLE IF NOT EXISTS ssh_keys (
207 id INTEGER PRIMARY KEY,
208 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
209 name TEXT NOT NULL,
210 public_key TEXT NOT NULL,
211 fingerprint TEXT NOT NULL UNIQUE,
212 created_at TEXT NOT NULL
213);
214CREATE TABLE IF NOT EXISTS groups (
215 id INTEGER PRIMARY KEY,
216 name TEXT NOT NULL,
217 path TEXT NOT NULL UNIQUE,
218 description TEXT NOT NULL DEFAULT '',
219 visibility TEXT NOT NULL DEFAULT 'private',
220 default_role TEXT NOT NULL DEFAULT 'developer',
221 logo_mime TEXT NOT NULL DEFAULT '',
222 created_by INTEGER NOT NULL,
223 created_at TEXT NOT NULL
224);
225CREATE TABLE IF NOT EXISTS group_members (
226 group_id INTEGER NOT NULL REFERENCES groups(id) ON DELETE CASCADE,
227 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
228 role TEXT NOT NULL,
229 PRIMARY KEY (group_id, user_id)
230);
231CREATE TABLE IF NOT EXISTS repos (
232 id INTEGER PRIMARY KEY,
233 owner_kind TEXT NOT NULL,
234 owner_id INTEGER NOT NULL,
235 name TEXT NOT NULL,
236 description TEXT NOT NULL DEFAULT '',
237 default_branch TEXT NOT NULL,
238 visibility TEXT NOT NULL DEFAULT 'private',
239 logo_mime TEXT NOT NULL DEFAULT '',
240 created_at TEXT NOT NULL,
241 UNIQUE(owner_kind, owner_id, name)
242);
243CREATE TABLE IF NOT EXISTS repo_members (
244 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
245 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
246 role TEXT NOT NULL,
247 PRIMARY KEY (repo_id, user_id)
248);
249CREATE TABLE IF NOT EXISTS pending_members (
250 id INTEGER PRIMARY KEY,
251 scope_kind TEXT NOT NULL,
252 scope_id INTEGER NOT NULL,
253 username TEXT NOT NULL,
254 role TEXT NOT NULL,
255 UNIQUE(scope_kind, scope_id, username)
256);
257CREATE TABLE IF NOT EXISTS protected_branches (
258 id INTEGER PRIMARY KEY,
259 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
260 pattern TEXT NOT NULL,
261 UNIQUE(repo_id, pattern)
262);
263CREATE TABLE IF NOT EXISTS protected_tags (
264 id INTEGER PRIMARY KEY,
265 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
266 pattern TEXT NOT NULL,
267 UNIQUE(repo_id, pattern)
268);
269CREATE TABLE IF NOT EXISTS secrets (
270 id INTEGER PRIMARY KEY,
271 scope_kind TEXT NOT NULL,
272 scope_id INTEGER NOT NULL,
273 name TEXT NOT NULL,
274 ciphertext BLOB NOT NULL,
275 nonce BLOB NOT NULL,
276 protected INTEGER NOT NULL DEFAULT 0,
277 invisible INTEGER NOT NULL DEFAULT 0,
278 created_at TEXT NOT NULL,
279 UNIQUE(scope_kind, scope_id, name)
280);
281CREATE TABLE IF NOT EXISTS webhooks (
282 id INTEGER PRIMARY KEY,
283 scope_kind TEXT NOT NULL,
284 scope_id INTEGER NOT NULL,
285 name TEXT NOT NULL,
286 preset TEXT NOT NULL,
287 url_template TEXT NOT NULL,
288 headers_json TEXT NOT NULL,
289 body_template TEXT NOT NULL,
290 events_json TEXT NOT NULL,
291 branch_filter TEXT NOT NULL DEFAULT '',
292 active INTEGER NOT NULL DEFAULT 1,
293 method TEXT NOT NULL DEFAULT 'POST',
294 fields_json TEXT NOT NULL DEFAULT '',
295 created_at TEXT NOT NULL
296);
297CREATE TABLE IF NOT EXISTS webhook_deliveries (
298 id INTEGER PRIMARY KEY,
299 webhook_id INTEGER NOT NULL REFERENCES webhooks(id) ON DELETE CASCADE,
300 event_type TEXT NOT NULL,
301 status_code INTEGER NOT NULL DEFAULT 0,
302 error TEXT NOT NULL DEFAULT '',
303 created_at TEXT NOT NULL
304);
305CREATE TABLE IF NOT EXISTS merge_requests (
306 id INTEGER PRIMARY KEY,
307 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
308 number INTEGER NOT NULL,
309 title TEXT NOT NULL,
310 description TEXT NOT NULL DEFAULT '',
311 source_branch TEXT NOT NULL,
312 target_branch TEXT NOT NULL,
313 author_id INTEGER NOT NULL,
314 status TEXT NOT NULL,
315 created_at TEXT NOT NULL,
316 updated_at TEXT NOT NULL,
317 draft INTEGER NOT NULL DEFAULT 0,
318 labels TEXT NOT NULL DEFAULT '',
319 remove_source_branch INTEGER NOT NULL DEFAULT 1,
320 squash INTEGER NOT NULL DEFAULT 0,
321 squash_message TEXT NOT NULL DEFAULT '',
322 UNIQUE(repo_id, number)
323);
324CREATE TABLE IF NOT EXISTS pipelines (
325 id INTEGER PRIMARY KEY,
326 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
327 commit_sha TEXT NOT NULL,
328 ref TEXT NOT NULL,
329 status TEXT NOT NULL,
330 created_at TEXT NOT NULL,
331 finished_at TEXT,
332 source TEXT NOT NULL DEFAULT 'push',
333 actor TEXT NOT NULL DEFAULT '',
334 commit_title TEXT NOT NULL DEFAULT '',
335 started_at TEXT
336);
337CREATE TABLE IF NOT EXISTS jobs (
338 id INTEGER PRIMARY KEY,
339 pipeline_id INTEGER NOT NULL REFERENCES pipelines(id) ON DELETE CASCADE,
340 repo_id INTEGER NOT NULL,
341 name TEXT NOT NULL,
342 stage TEXT NOT NULL,
343 position INTEGER NOT NULL,
344 status TEXT NOT NULL,
345 image TEXT NOT NULL,
346 script TEXT NOT NULL,
347 needs_json TEXT NOT NULL,
348 needs_set INTEGER NOT NULL,
349 variables_json TEXT NOT NULL,
350 artifact_paths TEXT NOT NULL,
351 artifact_expire_seconds INTEGER NOT NULL DEFAULT 0,
352 allow_failure INTEGER NOT NULL DEFAULT 0,
353 log TEXT NOT NULL DEFAULT '',
354 started_at TEXT,
355 finished_at TEXT,
356 before_script TEXT NOT NULL DEFAULT '',
357 after_script TEXT NOT NULL DEFAULT '',
358 when_mode TEXT NOT NULL DEFAULT 'on_success',
359 timeout_seconds INTEGER NOT NULL DEFAULT 0,
360 failure_reason TEXT NOT NULL DEFAULT '',
361 tags_json TEXT NOT NULL DEFAULT '[]',
362 cache_paths TEXT NOT NULL DEFAULT '[]',
363 cache_key TEXT NOT NULL DEFAULT '',
364 resource_group TEXT NOT NULL DEFAULT '',
365 optional_json TEXT NOT NULL DEFAULT '[]',
366 retry_max INTEGER NOT NULL DEFAULT 0,
367 retry_when TEXT NOT NULL DEFAULT '[]',
368 attempt INTEGER NOT NULL DEFAULT 0,
369 services_json TEXT NOT NULL DEFAULT '[]',
370 environment_name TEXT NOT NULL DEFAULT '',
371 environment_url TEXT NOT NULL DEFAULT '',
372 interruptible INTEGER NOT NULL DEFAULT 0,
373 do_not_interrupt INTEGER NOT NULL DEFAULT 0,
374 UNIQUE(pipeline_id, name)
375);
376CREATE TABLE IF NOT EXISTS artifacts (
377 id INTEGER PRIMARY KEY,
378 job_id INTEGER NOT NULL REFERENCES jobs(id) ON DELETE CASCADE,
379 path TEXT NOT NULL,
380 storage_path TEXT NOT NULL,
381 size INTEGER NOT NULL,
382 expires_at TEXT
383);
384CREATE TABLE IF NOT EXISTS job_tokens (
385 job_id INTEGER PRIMARY KEY REFERENCES jobs(id) ON DELETE CASCADE,
386 token_hash TEXT NOT NULL UNIQUE,
387 created_at TEXT NOT NULL
388);
389CREATE TABLE IF NOT EXISTS releases (
390 id INTEGER PRIMARY KEY,
391 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
392 tag TEXT NOT NULL,
393 commit_sha TEXT NOT NULL,
394 name TEXT NOT NULL,
395 body TEXT NOT NULL DEFAULT '',
396 author_id INTEGER,
397 job_id INTEGER,
398 created_at TEXT NOT NULL,
399 UNIQUE(repo_id, tag)
400);
401CREATE TABLE IF NOT EXISTS release_assets (
402 id INTEGER PRIMARY KEY,
403 release_id INTEGER NOT NULL REFERENCES releases(id) ON DELETE CASCADE,
404 name TEXT NOT NULL,
405 storage_path TEXT NOT NULL,
406 size INTEGER NOT NULL,
407 UNIQUE(release_id, name)
408);
409CREATE TABLE IF NOT EXISTS contributions (
410 id INTEGER PRIMARY KEY,
411 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
412 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
413 kind TEXT NOT NULL,
414 ref TEXT NOT NULL,
415 occurred_at TEXT NOT NULL,
416 UNIQUE(repo_id, kind, ref)
417);
418CREATE INDEX IF NOT EXISTS contributions_repo_time ON contributions(repo_id, occurred_at);
419CREATE INDEX IF NOT EXISTS contributions_user_time ON contributions(user_id, occurred_at);
420CREATE TABLE IF NOT EXISTS contribution_sync (
421 repo_id INTEGER PRIMARY KEY REFERENCES repos(id) ON DELETE CASCADE,
422 synced_at TEXT NOT NULL
423);
424CREATE TABLE IF NOT EXISTS stars (
425 user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
426 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
427 created_at TEXT NOT NULL,
428 PRIMARY KEY (user_id, repo_id)
429);
430CREATE TABLE IF NOT EXISTS notes (
431 id INTEGER PRIMARY KEY,
432 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
433 mr_id INTEGER NOT NULL REFERENCES merge_requests(id) ON DELETE CASCADE,
434 author_id INTEGER NOT NULL REFERENCES users(id),
435 body TEXT NOT NULL,
436 created_at TEXT NOT NULL,
437 file_path TEXT NOT NULL DEFAULT '',
438 line_start INTEGER NOT NULL DEFAULT 0,
439 line_end INTEGER NOT NULL DEFAULT 0,
440 suggestion TEXT NOT NULL DEFAULT '',
441 base_text TEXT NOT NULL DEFAULT '',
442 parent_id INTEGER NOT NULL DEFAULT 0
443);
444CREATE TABLE IF NOT EXISTS mr_events (
445 id INTEGER PRIMARY KEY,
446 repo_id INTEGER NOT NULL,
447 mr_id INTEGER NOT NULL REFERENCES merge_requests(id) ON DELETE CASCADE,
448 actor_id INTEGER NOT NULL DEFAULT 0,
449 kind TEXT NOT NULL,
450 body TEXT NOT NULL DEFAULT '',
451 created_at TEXT NOT NULL
452);
453CREATE INDEX IF NOT EXISTS mr_events_mr ON mr_events(mr_id, id);
454CREATE TABLE IF NOT EXISTS commit_pushers (
455 repo_id INTEGER NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
456 sha TEXT NOT NULL,
457 user_id INTEGER NOT NULL REFERENCES users(id),
458 author_name TEXT NOT NULL,
459 author_email TEXT NOT NULL,
460 created_at TEXT NOT NULL,
461 PRIMARY KEY (repo_id, sha)
462);
463CREATE TABLE IF NOT EXISTS approval_rules (
464 scope_kind TEXT NOT NULL,
465 scope_id INTEGER NOT NULL,
466 configured INTEGER NOT NULL DEFAULT 0,
467 maintainer_required INTEGER NOT NULL DEFAULT 0,
468 required_count INTEGER NOT NULL DEFAULT 1,
469 developers_approve INTEGER NOT NULL DEFAULT 0,
470 PRIMARY KEY (scope_kind, scope_id)
471);
472CREATE TABLE IF NOT EXISTS reviews (
473 id INTEGER PRIMARY KEY,
474 repo_id INTEGER NOT NULL,
475 mr_id INTEGER NOT NULL REFERENCES merge_requests(id) ON DELETE CASCADE,
476 user_id INTEGER NOT NULL,
477 status TEXT NOT NULL,
478 updated_at TEXT NOT NULL,
479 UNIQUE(mr_id, user_id)
480);
481CREATE TABLE IF NOT EXISTS labels (
482 id INTEGER PRIMARY KEY,
483 repo_id INTEGER NOT NULL,
484 name TEXT NOT NULL,
485 color TEXT NOT NULL,
486 UNIQUE(repo_id, name)
487);
488CREATE TABLE IF NOT EXISTS milestones (
489 id INTEGER PRIMARY KEY,
490 repo_id INTEGER NOT NULL,
491 title TEXT NOT NULL,
492 due_on TEXT NOT NULL DEFAULT '',
493 state TEXT NOT NULL DEFAULT 'open',
494 UNIQUE(repo_id, title)
495);
496CREATE TABLE IF NOT EXISTS issues (
497 id INTEGER PRIMARY KEY,
498 repo_id INTEGER NOT NULL,
499 number INTEGER NOT NULL,
500 title TEXT NOT NULL,
501 description TEXT NOT NULL DEFAULT '',
502 author_id INTEGER NOT NULL,
503 status TEXT NOT NULL DEFAULT 'open',
504 confidential INTEGER NOT NULL DEFAULT 0,
505 milestone_id INTEGER NOT NULL DEFAULT 0,
506 due_on TEXT NOT NULL DEFAULT '',
507 created_at TEXT NOT NULL,
508 updated_at TEXT NOT NULL,
509 closed_at TEXT NOT NULL DEFAULT '',
510 UNIQUE(repo_id, number)
511);
512CREATE TABLE IF NOT EXISTS issue_labels (
513 issue_id INTEGER NOT NULL,
514 label_id INTEGER NOT NULL,
515 PRIMARY KEY(issue_id, label_id)
516);
517CREATE TABLE IF NOT EXISTS issue_assignees (
518 issue_id INTEGER NOT NULL,
519 user_id INTEGER NOT NULL,
520 PRIMARY KEY(issue_id, user_id)
521);
522CREATE TABLE IF NOT EXISTS issue_notes (
523 id INTEGER PRIMARY KEY,
524 repo_id INTEGER NOT NULL,
525 issue_id INTEGER NOT NULL,
526 author_id INTEGER NOT NULL,
527 body TEXT NOT NULL,
528 created_at TEXT NOT NULL
529);
530CREATE TABLE IF NOT EXISTS issue_links (
531 repo_id INTEGER NOT NULL,
532 a INTEGER NOT NULL,
533 b INTEGER NOT NULL,
534 PRIMARY KEY (a, b)
535);
536CREATE INDEX IF NOT EXISTS issues_repo ON issues(repo_id, number);
537`
538
539func now() string { return time.Now().UTC().Format(time.RFC3339) }
540
541func parseTime(s string) time.Time {
542 t, err := time.Parse(time.RFC3339, s)
543 if err != nil {
544 return time.Time{}
545 }
546 return t
547}
548
549// User is een ingelogd account van de auth-server.
550type User struct {
551 ID int64
552 AuthID int64
553 Username string
554 AvatarURL string
555 AvatarSource string // "", "remote", "entra" of "upload"
556 AvatarMIME string
557 AuthAdmin bool
558 InstanceAdmin bool
559 Language string
560 DisplayName string
561 Bio string
562 CreatedAt time.Time
563}
564
565// UpsertUser maakt of ververst een account. De eerste gebruiker wordt
566// installatiebeheerder. Wachtende lidmaatschappen op deze naam worden gekoppeld.
567func (s *Store) UpsertUser(ctx context.Context, authID int64, username, avatar string, authAdmin bool) (User, error) {
568 username = strings.ToLower(strings.TrimSpace(username))
569 if err := names.ValidUsername(username); err != nil {
570 return User{}, err
571 }
572 tx, err := s.db.BeginTx(ctx, nil)
573 if err != nil {
574 return User{}, err
575 }
576 defer func() { _ = tx.Rollback() }()
577
578 var count int
579 if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM users`).Scan(&count); err != nil {
580 return User{}, err
581 }
582 ts := now()
583 var existingID int64
584 err = tx.QueryRowContext(ctx, `SELECT id FROM users WHERE auth_id = ?`, authID).Scan(&existingID)
585 if errors.Is(err, sql.ErrNoRows) {
586 var nameTaken int
587 if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM users WHERE username = ?`, username).Scan(&nameTaken); err != nil {
588 return User{}, err
589 }
590 if nameTaken > 0 {
591 return User{}, i18n.E("err.userTaken", username)
592 }
593 admin := 0
594 if count == 0 {
595 admin = 1
596 }
597 src := ""
598 if avatar != "" {
599 src = "remote"
600 }
601 res, err := tx.ExecContext(ctx, `INSERT INTO users (auth_id, username, avatar_url, avatar_source, auth_admin, instance_admin, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
602 authID, username, avatar, src, boolInt(authAdmin), admin, ts, ts)
603 if err != nil {
604 return User{}, err
605 }
606 existingID, _ = res.LastInsertId()
607 } else if err != nil {
608 return User{}, err
609 } else {
610 var current, source string
611 if err := tx.QueryRowContext(ctx, `SELECT username, avatar_source FROM users WHERE id = ?`, existingID).Scan(&current, &source); err != nil {
612 return User{}, err
613 }
614 newName := current
615 if current != username {
616 var taken int
617 if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM users WHERE username = ? AND id <> ?`, username, existingID).Scan(&taken); err != nil {
618 return User{}, err
619 }
620 var groupTaken int
621 if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM groups WHERE path = ?`, username).Scan(&groupTaken); err != nil {
622 return User{}, err
623 }
624 if taken == 0 && groupTaken == 0 {
625 newName = username
626 }
627 }
628 // Een handmatig geüploade avatar nooit overschrijven. Een lege
629 // avatar-URL (Entra zonder foto) wist een bestaande ook niet.
630 if source == "upload" || avatar == "" {
631 if _, err := tx.ExecContext(ctx, `UPDATE users SET username = ?, auth_admin = ?, updated_at = ? WHERE id = ?`,
632 newName, boolInt(authAdmin), ts, existingID); err != nil {
633 return User{}, err
634 }
635 } else {
636 if _, err := tx.ExecContext(ctx, `UPDATE users SET username = ?, avatar_url = ?, avatar_source = ?, auth_admin = ?, updated_at = ? WHERE id = ?`,
637 newName, avatar, "remote", boolInt(authAdmin), ts, existingID); err != nil {
638 return User{}, err
639 }
640 }
641 }
642 if err := claimPending(ctx, tx, existingID, username); err != nil {
643 return User{}, err
644 }
645 if err := tx.Commit(); err != nil {
646 return User{}, err
647 }
648 return s.UserByID(ctx, existingID)
649}
650
651func claimPending(ctx context.Context, tx *sql.Tx, userID int64, username string) error {
652 rows, err := tx.QueryContext(ctx, `SELECT id, scope_kind, scope_id, role FROM pending_members WHERE username = ?`, username)
653 if err != nil {
654 return err
655 }
656 defer rows.Close()
657 type pend struct {
658 id, scopeID int64
659 kind, role string
660 }
661 var all []pend
662 for rows.Next() {
663 var p pend
664 if err := rows.Scan(&p.id, &p.kind, &p.scopeID, &p.role); err != nil {
665 return err
666 }
667 all = append(all, p)
668 }
669 if err := rows.Err(); err != nil {
670 return err
671 }
672 for _, p := range all {
673 switch p.kind {
674 case "group":
675 if _, err := tx.ExecContext(ctx, `INSERT OR IGNORE INTO group_members (group_id, user_id, role) VALUES (?, ?, ?)`, p.scopeID, userID, p.role); err != nil {
676 return err
677 }
678 case "repo":
679 if _, err := tx.ExecContext(ctx, `INSERT OR IGNORE INTO repo_members (repo_id, user_id, role) VALUES (?, ?, ?)`, p.scopeID, userID, p.role); err != nil {
680 return err
681 }
682 }
683 if _, err := tx.ExecContext(ctx, `DELETE FROM pending_members WHERE id = ?`, p.id); err != nil {
684 return err
685 }
686 }
687 return nil
688}
689
690// UserByID leest één account.
691func (s *Store) UserByID(ctx context.Context, id int64) (User, error) {
692 row := s.db.QueryRowContext(ctx, `SELECT `+userCols+` FROM users WHERE id = ?`, id)
693 return scanUser(row)
694}
695
696// UserByUsername leest op naam.
697func (s *Store) UserByUsername(ctx context.Context, username string) (User, error) {
698 row := s.db.QueryRowContext(ctx, `SELECT `+userCols+` FROM users WHERE username = ?`, strings.ToLower(username))
699 return scanUser(row)
700}
701
702const userCols = `id, auth_id, username, avatar_url, avatar_source, avatar_mime, auth_admin, instance_admin, language, display_name, bio, created_at`
703
704// SetUserAvatar zet de avatar-URL en de bron. source "upload" is handmatig
705// en wordt bij een latere login niet overschreven.
706func (s *Store) SetUserAvatar(ctx context.Context, userID int64, url, source, mime string) error {
707 _, err := s.db.ExecContext(ctx, `UPDATE users SET avatar_url = ?, avatar_source = ?, avatar_mime = ?, updated_at = ? WHERE id = ?`, url, source, mime, now(), userID)
708 return err
709}
710
711// SetProfile bewaart de weergavenaam en de bio. Lege tekst wist het veld.
712func (s *Store) SetProfile(ctx context.Context, userID int64, name, bio string) error {
713 _, err := s.db.ExecContext(ctx, `UPDATE users SET display_name = ?, bio = ?, updated_at = ? WHERE id = ?`, name, bio, now(), userID)
714 return err
715}
716
717func scanUser(row interface{ Scan(...any) error }) (User, error) {
718 var u User
719 var admin, inst int
720 var created string
721 if err := row.Scan(&u.ID, &u.AuthID, &u.Username, &u.AvatarURL, &u.AvatarSource, &u.AvatarMIME, &admin, &inst, &u.Language, &u.DisplayName, &u.Bio, &created); err != nil {
722 if errors.Is(err, sql.ErrNoRows) {
723 return User{}, errNotFound
724 }
725 return User{}, err
726 }
727 u.AuthAdmin = admin == 1
728 u.InstanceAdmin = inst == 1
729 if u.Language == "" {
730 u.Language = "en"
731 }
732 u.CreatedAt = parseTime(created)
733 return u, nil
734}
735
736// Session is een browsersessie.
737type Session struct {
738 ID string
739 UserID int64
740 AccessToken string
741 ExpiresAt time.Time
742 CSRF string
743 User User
744}
745
746// CreateSession bewaart het bearer-token van de auth-server.
747func (s *Store) CreateSession(ctx context.Context, userID int64, accessToken string, expiresAt time.Time) (Session, error) {
748 id, err := randomID()
749 if err != nil {
750 return Session{}, err
751 }
752 csrf, err := randomID()
753 if err != nil {
754 return Session{}, err
755 }
756 _, err = s.db.ExecContext(ctx, `INSERT INTO sessions (id, user_id, access_token, expires_at, csrf, created_at) VALUES (?, ?, ?, ?, ?, ?)`,
757 id, userID, accessToken, expiresAt.UTC().Format(time.RFC3339), csrf, now())
758 if err != nil {
759 return Session{}, err
760 }
761 return s.Session(ctx, id)
762}
763
764// Session leest een sessie met de gebruiker.
765func (s *Store) Session(ctx context.Context, id string) (Session, error) {
766 var sess Session
767 var exp string
768 err := s.db.QueryRowContext(ctx, `SELECT id, user_id, access_token, expires_at, csrf FROM sessions WHERE id = ?`, id).
769 Scan(&sess.ID, &sess.UserID, &sess.AccessToken, &exp, &sess.CSRF)
770 if errors.Is(err, sql.ErrNoRows) {
771 return Session{}, errNotFound
772 }
773 if err != nil {
774 return Session{}, err
775 }
776 sess.ExpiresAt = parseTime(exp)
777 u, err := s.UserByID(ctx, sess.UserID)
778 if err != nil {
779 return Session{}, err
780 }
781 sess.User = u
782 return sess, nil
783}
784
785// UpdateSessionExpiry schuift de lokale kopie van de auth-sessie op.
786func (s *Store) UpdateSessionExpiry(ctx context.Context, id string, expiresAt time.Time) error {
787 _, err := s.db.ExecContext(ctx, `UPDATE sessions SET expires_at = ? WHERE id = ?`, expiresAt.UTC().Format(time.RFC3339), id)
788 return err
789}
790
791// DeleteSession verwijdert de lokale sessie.
792func (s *Store) DeleteSession(ctx context.Context, id string) error {
793 _, err := s.db.ExecContext(ctx, `DELETE FROM sessions WHERE id = ?`, id)
794 return err
795}
796
797// TokenInfo is een persoonlijk toegangstoken zonder het geheim.
798type TokenInfo struct {
799 ID int64
800 Name string
801 Prefix string
802 Scopes string
803 CreatedAt time.Time
804 LastUsedAt time.Time
805 ExpiresAt time.Time
806}
807
808// TokenAuth is een geldig token plus de eigenaar.
809type TokenAuth struct {
810 Token TokenInfo
811 User User
812}
813
814// TokenRequest beschrijft een nieuw token. Lege scopes worden api.
815type TokenRequest struct {
816 Name string
817 Scopes string
818 ExpiresAt time.Time
819}
820
821// CreateToken maakt een bg_-token met scope api. De tekst wordt één keer teruggegeven.
822func (s *Store) CreateToken(ctx context.Context, userID int64, name string) (string, error) {
823 plain, _, err := s.IssueToken(ctx, userID, TokenRequest{Name: name, Scopes: "api"})
824 return plain, err
825}
826
827// IssueToken maakt een token met scopes en een optionele vervaldatum.
828func (s *Store) IssueToken(ctx context.Context, userID int64, req TokenRequest) (string, TokenInfo, error) {
829 name := strings.TrimSpace(req.Name)
830 if name == "" || len(name) > 80 {
831 return "", TokenInfo{}, i18n.E("err.tokenNeedsName")
832 }
833 scopes := strings.TrimSpace(req.Scopes)
834 if scopes == "" {
835 scopes = "api"
836 }
837 if !req.ExpiresAt.IsZero() && !req.ExpiresAt.After(time.Now()) {
838 return "", TokenInfo{}, i18n.E("err.tokenExpired")
839 }
840 plain, err := newToken("bg_")
841 if err != nil {
842 return "", TokenInfo{}, err
843 }
844 var exp any
845 if !req.ExpiresAt.IsZero() {
846 exp = req.ExpiresAt.UTC().Format(time.RFC3339)
847 }
848 res, err := s.db.ExecContext(ctx, `INSERT INTO access_tokens (user_id, name, token_hash, prefix, scopes, created_at, expires_at) VALUES (?, ?, ?, ?, ?, ?, ?)`,
849 userID, name, hashToken(plain), plain[:10], scopes, now(), exp)
850 if err != nil {
851 return "", TokenInfo{}, err
852 }
853 id, _ := res.LastInsertId()
854 info := TokenInfo{ID: id, Name: name, Prefix: plain[:10], Scopes: scopes, CreatedAt: time.Now().UTC(), ExpiresAt: req.ExpiresAt}
855 return plain, info, nil
856}
857
858// ListTokens toont de tokens van een gebruiker.
859func (s *Store) ListTokens(ctx context.Context, userID int64) ([]TokenInfo, error) {
860 rows, err := s.db.QueryContext(ctx, `SELECT id, name, prefix, COALESCE(scopes, 'api'), created_at, COALESCE(last_used_at, ''), COALESCE(expires_at, '') FROM access_tokens WHERE user_id = ? ORDER BY id DESC`, userID)
861 if err != nil {
862 return nil, err
863 }
864 defer rows.Close()
865 var out []TokenInfo
866 for rows.Next() {
867 var t TokenInfo
868 var created, used, expires string
869 if err := rows.Scan(&t.ID, &t.Name, &t.Prefix, &t.Scopes, &created, &used, &expires); err != nil {
870 return nil, err
871 }
872 t.CreatedAt = parseTime(created)
873 t.LastUsedAt = parseTime(used)
874 t.ExpiresAt = parseTime(expires)
875 out = append(out, t)
876 }
877 return out, rows.Err()
878}
879
880// DeleteToken verwijdert een token van deze gebruiker.
881func (s *Store) DeleteToken(ctx context.Context, userID, id int64) error {
882 res, err := s.db.ExecContext(ctx, `DELETE FROM access_tokens WHERE id = ? AND user_id = ?`, id, userID)
883 if err != nil {
884 return err
885 }
886 n, _ := res.RowsAffected()
887 if n == 0 {
888 return errNotFound
889 }
890 return nil
891}
892
893// UserByToken zoekt de eigenaar van een persoonlijk token.
894func (s *Store) UserByToken(ctx context.Context, token string) (User, error) {
895 auth, err := s.AuthenticateToken(ctx, token)
896 if err != nil {
897 return User{}, err
898 }
899 return auth.User, nil
900}
901
902// AuthenticateToken controleert het geheim, de vervaldatum en geeft de scopes terug.
903func (s *Store) AuthenticateToken(ctx context.Context, token string) (TokenAuth, error) {
904 if !strings.HasPrefix(token, "bg_") {
905 return TokenAuth{}, errNotFound
906 }
907 var info TokenInfo
908 var userID int64
909 var created, expires, scopes string
910 err := s.db.QueryRowContext(ctx, `SELECT id, user_id, name, prefix, COALESCE(scopes, 'api'), created_at, COALESCE(expires_at, '') FROM access_tokens WHERE token_hash = ?`, hashToken(token)).
911 Scan(&info.ID, &userID, &info.Name, &info.Prefix, &scopes, &created, &expires)
912 if errors.Is(err, sql.ErrNoRows) {
913 return TokenAuth{}, errNotFound
914 }
915 if err != nil {
916 return TokenAuth{}, err
917 }
918 info.Scopes = scopes
919 info.CreatedAt = parseTime(created)
920 info.ExpiresAt = parseTime(expires)
921 if !info.ExpiresAt.IsZero() && !info.ExpiresAt.After(time.Now()) {
922 return TokenAuth{}, i18n.E("err.tokenExpired")
923 }
924 _, _ = s.db.ExecContext(ctx, `UPDATE access_tokens SET last_used_at = ? WHERE id = ?`, now(), info.ID)
925 user, err := s.UserByID(ctx, userID)
926 if err != nil {
927 return TokenAuth{}, err
928 }
929 return TokenAuth{Token: info, User: user}, nil
930}
931
932// SSHKey is een publieke sleutel voor git-over-SSH.
933type SSHKey struct {
934 ID int64
935 UserID int64
936 Name string
937 PublicKey string
938 Fingerprint string
939 CreatedAt time.Time
940}
941
942// AddSSHKey bewaart één OpenSSH-regel.
943func (s *Store) AddSSHKey(ctx context.Context, userID int64, name, line, fingerprint string) error {
944 name = strings.TrimSpace(name)
945 if name == "" {
946 name = "sleutel"
947 }
948 _, err := s.db.ExecContext(ctx, `INSERT INTO ssh_keys (user_id, name, public_key, fingerprint, created_at) VALUES (?, ?, ?, ?, ?)`,
949 userID, name, strings.TrimSpace(line), fingerprint, now())
950 if err != nil && strings.Contains(err.Error(), "UNIQUE") {
951 return i18n.E("err.sshDup")
952 }
953 return err
954}
955
956// ListSSHKeys toont de sleutels van een gebruiker.
957func (s *Store) ListSSHKeys(ctx context.Context, userID int64) ([]SSHKey, error) {
958 rows, err := s.db.QueryContext(ctx, `SELECT id, user_id, name, public_key, fingerprint, created_at FROM ssh_keys WHERE user_id = ? ORDER BY id`, userID)
959 if err != nil {
960 return nil, err
961 }
962 defer rows.Close()
963 return scanKeys(rows)
964}
965
966// SSHKeyByFingerprint zoekt een sleutel voor de SSH-server.
967func (s *Store) SSHKeyByFingerprint(ctx context.Context, fingerprint string) (SSHKey, error) {
968 row := s.db.QueryRowContext(ctx, `SELECT id, user_id, name, public_key, fingerprint, created_at FROM ssh_keys WHERE fingerprint = ?`, fingerprint)
969 var k SSHKey
970 var created string
971 if err := row.Scan(&k.ID, &k.UserID, &k.Name, &k.PublicKey, &k.Fingerprint, &created); err != nil {
972 if errors.Is(err, sql.ErrNoRows) {
973 return SSHKey{}, errNotFound
974 }
975 return SSHKey{}, err
976 }
977 k.CreatedAt = parseTime(created)
978 return k, nil
979}
980
981// DeleteSSHKey verwijdert een sleutel van deze gebruiker.
982func (s *Store) DeleteSSHKey(ctx context.Context, userID, id int64) error {
983 res, err := s.db.ExecContext(ctx, `DELETE FROM ssh_keys WHERE id = ? AND user_id = ?`, id, userID)
984 if err != nil {
985 return err
986 }
987 n, _ := res.RowsAffected()
988 if n == 0 {
989 return errNotFound
990 }
991 return nil
992}
993
994func scanKeys(rows *sql.Rows) ([]SSHKey, error) {
995 var out []SSHKey
996 for rows.Next() {
997 var k SSHKey
998 var created string
999 if err := rows.Scan(&k.ID, &k.UserID, &k.Name, &k.PublicKey, &k.Fingerprint, &created); err != nil {
1000 return nil, err
1001 }
1002 k.CreatedAt = parseTime(created)
1003 out = append(out, k)
1004 }
1005 return out, rows.Err()
1006}
1007
1008func randomID() (string, error) {
1009 b := make([]byte, 32)
1010 if _, err := rand.Read(b); err != nil {
1011 return "", err
1012 }
1013 return hex.EncodeToString(b), nil
1014}
1015
1016func newToken(prefix string) (string, error) {
1017 b := make([]byte, 32)
1018 if _, err := rand.Read(b); err != nil {
1019 return "", err
1020 }
1021 return prefix + hex.EncodeToString(b), nil
1022}
1023
1024func hashToken(token string) string {
1025 sum := sha256.Sum256([]byte(token))
1026 return hex.EncodeToString(sum[:])
1027}
1028
1029func boolInt(b bool) int {
1030 if b {
1031 return 1
1032 }
1033 return 0
1034}
1035
1036var errNotFound = fmt.Errorf("niet gevonden")
1037
1038// Missing meldt dat de gevraagde rij er niet is.
1039func Missing(err error) bool { return errors.Is(err, errNotFound) }
1040
1041// NotFound is de fout voor een ontbrekende rij.
1042func NotFound() error { return errNotFound }
1043
1044// ErrNotFound is het resultaat als een rij ontbreekt.
1045func ErrNotFound() error { return errNotFound }
1046
1047// IsNotFound meldt of err een ontbrekende rij is.
1048func IsNotFound(err error) bool { return errors.Is(err, errNotFound) }
1049
1050func mustJSON(v any) string {
1051 b, _ := json.Marshal(v)
1052 if b == nil {
1053 return "null"
1054 }
1055 return string(b)
1056}
1057
1058// EncryptSecret versleutelt een geheim met de installatiesleutel.
1059func (s *Store) encrypt(plain string) (nonce, ct []byte, err error) {
1060 return secretbox.Encrypt(s.key, plain)
1061}
1062
1063func (s *Store) decrypt(nonce, ct []byte) (string, error) {
1064 return secretbox.Decrypt(s.key, nonce, ct)
1065}
1066
1067// Snapshot schrijft een consistente kopie van de database naar dst
1068// (VACUUM INTO). dst mag nog niet bestaan. Gebruikt door de backup server.
1069func (s *Store) Snapshot(ctx context.Context, dst string) error {
1070 _, err := s.db.ExecContext(ctx, `VACUUM INTO ?`, dst)
1071 return err
1072}