BlueGit

timfa bluegit

Files

bluegit / internal / store / store.go

store.go

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