feat(store): schema v2 with moderation, pending requests and bounce state

- Add member id, disabled flag and bounce counter
- Add per-list post and join policies
- Add held message queue
- Add expiring, rate-limited pending subscribe and unsubscribe tokens
- Add persistent HMAC secret
- Migrate databases created by milestone 1
This commit is contained in:
tgiachi 2026-11-09 15:03:08 +01:00
commit 9eb4d14a70
2 changed files with 554 additions and 73 deletions

185
internal/store/m2_test.go Normal file
View file

@ -0,0 +1,185 @@
package store
import (
"database/sql"
"errors"
"path/filepath"
"testing"
"time"
)
func TestListPolicies(t *testing.T) {
s := newTestStore(t)
l, _ := s.CreateList("dev", "example.org", "Dev")
if l.PostPolicy != "members" || l.JoinPolicy != "open" {
t.Fatalf("defaults: %+v", l)
}
if err := s.SetPolicies(l.ID, "moderated", "closed"); err != nil {
t.Fatal(err)
}
got, _ := s.GetList(l.ID)
if got.PostPolicy != "moderated" || got.JoinPolicy != "closed" {
t.Fatalf("policies: %+v", got)
}
if err := s.SetPolicies(l.ID, "bogus", "open"); err == nil {
t.Fatal("invalid policy must be rejected")
}
if err := s.SetPolicies(999, "members", "open"); !errors.Is(err, ErrNotFound) {
t.Fatalf("want ErrNotFound, got %v", err)
}
}
func TestHeldQueue(t *testing.T) {
s := newTestStore(t)
l, _ := s.CreateList("dev", "example.org", "Dev")
id, err := s.HoldMessage(l.ID, "bob@x.com", []byte("Subject: hi\r\n\r\nx"))
if err != nil {
t.Fatal(err)
}
hs, err := s.ListHeld(l.ID)
if err != nil || len(hs) != 1 || hs[0].ID != id || hs[0].Sender != "bob@x.com" {
t.Fatalf("held: %+v %v", hs, err)
}
h, err := s.GetHeld(id)
if err != nil || string(h.Data) != "Subject: hi\r\n\r\nx" || h.ListID != l.ID {
t.Fatalf("get: %+v %v", h, err)
}
if err := s.DeleteHeld(id); err != nil {
t.Fatal(err)
}
if _, err := s.GetHeld(id); !errors.Is(err, ErrNotFound) {
t.Fatal("held message should be gone")
}
if err := s.DeleteHeld(id); !errors.Is(err, ErrNotFound) {
t.Fatalf("want ErrNotFound, got %v", err)
}
}
func TestPendingTokens(t *testing.T) {
s := newTestStore(t)
now := time.Unix(1_000_000, 0)
s.Now = func() time.Time { return now }
l, _ := s.CreateList("dev", "example.org", "Dev")
tok, created, err := s.CreatePending(l.ID, "A@x.com", "join")
if err != nil || !created || tok == "" {
t.Fatalf("create: %q %v %v", tok, created, err)
}
// Rate limit: same request within an hour is not recreated.
now = now.Add(30 * time.Minute)
if _, created, _ := s.CreatePending(l.ID, "a@x.com", "join"); created {
t.Fatal("must be rate limited")
}
// A different action is independent.
if _, created, _ := s.CreatePending(l.ID, "a@x.com", "leave"); !created {
t.Fatal("leave is a separate request")
}
p, err := s.ConfirmPending(tok)
if err != nil || p.Address != "a@x.com" || p.Action != "join" || p.ListID != l.ID {
t.Fatalf("confirm: %+v %v", p, err)
}
if _, err := s.ConfirmPending(tok); !errors.Is(err, ErrNotFound) {
t.Fatal("token is single use")
}
if _, err := s.ConfirmPending("nope"); !errors.Is(err, ErrNotFound) {
t.Fatal("unknown token")
}
// Expiry.
tok2, _, _ := s.CreatePending(l.ID, "b@x.com", "join")
now = now.Add(73 * time.Hour)
if _, err := s.ConfirmPending(tok2); !errors.Is(err, ErrNotFound) {
t.Fatal("token must expire after 72h")
}
}
func TestSecretIsStable(t *testing.T) {
s := newTestStore(t)
a, err := s.Secret()
if err != nil || len(a) < 32 {
t.Fatalf("secret: %x %v", a, err)
}
b, _ := s.Secret()
if string(a) != string(b) {
t.Fatal("secret must not change")
}
}
func TestBounceDisablesAfterThreshold(t *testing.T) {
s := newTestStore(t)
l, _ := s.CreateList("dev", "example.org", "Dev")
s.AddMember(l.ID, "a@x.com", "A")
ms, _ := s.Members(l.ID)
id := ms[0].ID
for i := 1; i <= 2; i++ {
disabled, err := s.RecordHardBounce(id, 3)
if err != nil || disabled {
t.Fatalf("bounce %d: %v %v", i, disabled, err)
}
}
disabled, _ := s.RecordHardBounce(id, 3)
if !disabled {
t.Fatal("third hard bounce must disable")
}
ms, _ = s.Members(l.ID)
if !ms[0].Disabled || ms[0].BounceCount != 3 {
t.Fatalf("member: %+v", ms[0])
}
if act, _ := s.ActiveMembers(l.ID); len(act) != 0 {
t.Fatalf("active: %+v", act)
}
// Re-adding resets the state.
s.AddMember(l.ID, "a@x.com", "A")
act, _ := s.ActiveMembers(l.ID)
if len(act) != 1 || act[0].BounceCount != 0 || act[0].ID != id {
t.Fatalf("after re-add: %+v", act)
}
m, err := s.MemberByID(id)
if err != nil || m.Address != "a@x.com" || m.ListID != l.ID {
t.Fatalf("by id: %+v %v", m, err)
}
if _, err := s.MemberByID(999); !errors.Is(err, ErrNotFound) {
t.Fatal("unknown id")
}
if _, err := s.RecordHardBounce(999, 3); !errors.Is(err, ErrNotFound) {
t.Fatal("unknown id")
}
}
func TestMigrateFromM1(t *testing.T) {
path := filepath.Join(t.TempDir(), "old.db")
db, err := sql.Open("sqlite", path)
if err != nil {
t.Fatal(err)
}
_, err = db.Exec(`
CREATE TABLE lists (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, domain TEXT NOT NULL, title TEXT NOT NULL DEFAULT '', UNIQUE(name, domain));
CREATE TABLE members (list_id INTEGER NOT NULL REFERENCES lists(id) ON DELETE CASCADE, address TEXT NOT NULL, display_name TEXT NOT NULL DEFAULT '', PRIMARY KEY(list_id, address));
INSERT INTO lists(name, domain, title) VALUES('dev','example.org','Dev');
INSERT INTO members(list_id, address, display_name) VALUES(1,'a@x.com','A'),(1,'b@x.com','B');`)
if err != nil {
t.Fatal(err)
}
db.Close()
s, err := Open(path)
if err != nil {
t.Fatalf("migrate: %v", err)
}
defer s.Close()
l, err := s.FindList("dev@example.org")
if err != nil || l.PostPolicy != "members" || l.JoinPolicy != "open" {
t.Fatalf("list: %+v %v", l, err)
}
ms, _ := s.Members(l.ID)
if len(ms) != 2 || ms[0].ID == 0 || ms[0].Address != "a@x.com" {
t.Fatalf("members: %+v", ms)
}
s.Close()
// Opening again is a no-op.
s2, err := Open(path)
if err != nil {
t.Fatal(err)
}
s2.Close()
}

View file

@ -1,27 +1,52 @@
// Package store persists lists and members in SQLite.
// Package store persists lists, members and moderation state in SQLite.
package store
import (
"crypto/rand"
"database/sql"
"encoding/hex"
"errors"
"fmt"
"strings"
"time"
_ "modernc.org/sqlite"
)
// ErrNotFound is returned when a list or member does not exist.
var ErrNotFound = errors.New("not found")
var (
// ErrNotFound is returned when a record does not exist.
ErrNotFound = errors.New("not found")
// ErrExists is returned when creating something that already exists.
ErrExists = errors.New("already exists")
)
// ErrExists is returned when creating something that already exists.
var ErrExists = errors.New("already exists")
// Policy values.
const (
PostMembers = "members" // only members may post, others are rejected
PostModerated = "moderated" // every post waits for approval
JoinOpen = "open" // anyone can subscribe (with confirmation)
JoinClosed = "closed" // only the admin adds members
)
// Pending actions.
const (
ActionJoin = "join"
ActionLeave = "leave"
)
const (
pendingTTL = 72 * time.Hour
pendingRateLimit = time.Hour
)
// List is a mailing list.
type List struct {
ID int64
Name string // local part, lowercase
Domain string // lowercase
Title string
ID int64
Name string // local part, lowercase
Domain string // lowercase
Title string
PostPolicy string
JoinPolicy string
}
// Address returns the list posting address.
@ -29,26 +54,74 @@ func (l List) Address() string { return l.Name + "@" + l.Domain }
// Member is a list subscriber.
type Member struct {
ID int64
ListID int64
Address string // lowercase
DisplayName string
Disabled bool // too many hard bounces: no more delivery
BounceCount int
}
// Held is a message waiting for moderation.
type Held struct {
ID int64
ListID int64
Sender string
Data []byte
CreatedAt time.Time
}
// Pending is an unconfirmed subscribe or unsubscribe request.
type Pending struct {
Token string
ListID int64
Address string
Action string
}
// Store wraps the SQLite database.
type Store struct{ db *sql.DB }
type Store struct {
db *sql.DB
// Now returns the current time; tests replace it.
Now func() time.Time
}
const schema = `
CREATE TABLE IF NOT EXISTS lists (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
domain TEXT NOT NULL,
title TEXT NOT NULL DEFAULT '',
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
domain TEXT NOT NULL,
title TEXT NOT NULL DEFAULT '',
post_policy TEXT NOT NULL DEFAULT 'members',
join_policy TEXT NOT NULL DEFAULT 'open',
UNIQUE(name, domain)
);
CREATE TABLE IF NOT EXISTS members (
id INTEGER PRIMARY KEY AUTOINCREMENT,
list_id INTEGER NOT NULL REFERENCES lists(id) ON DELETE CASCADE,
address TEXT NOT NULL,
display_name TEXT NOT NULL DEFAULT '',
PRIMARY KEY(list_id, address)
disabled INTEGER NOT NULL DEFAULT 0,
bounce_count INTEGER NOT NULL DEFAULT 0,
UNIQUE(list_id, address)
);
CREATE TABLE IF NOT EXISTS held (
id INTEGER PRIMARY KEY AUTOINCREMENT,
list_id INTEGER NOT NULL REFERENCES lists(id) ON DELETE CASCADE,
sender TEXT NOT NULL,
data BLOB NOT NULL,
created_at INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS pending (
token TEXT PRIMARY KEY,
list_id INTEGER NOT NULL REFERENCES lists(id) ON DELETE CASCADE,
address TEXT NOT NULL,
action TEXT NOT NULL,
created_at INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS settings (
key TEXT PRIMARY KEY,
value TEXT NOT NULL
);`
// Open opens (and migrates) the database at path. Use ":memory:" for tests.
@ -63,106 +136,60 @@ func Open(path string) (*Store, error) {
db.Close()
return nil, err
}
if _, err := db.Exec(schema); err != nil {
if err := migrate(db); err != nil {
db.Close()
return nil, fmt.Errorf("migrate: %w", err)
}
return &Store{db: db}, nil
return &Store{db: db, Now: time.Now}, nil
}
func hasColumn(db *sql.DB, table, column string) (bool, error) {
var n int
err := db.QueryRow(`SELECT COUNT(*) FROM pragma_table_info(?) WHERE name=?`, table, column).Scan(&n)
return n > 0, err
}
// migrate upgrades a database created by milestone 1, then ensures the schema.
func migrate(db *sql.DB) error {
if ok, err := hasColumn(db, "members", "list_id"); err != nil {
return err
} else if ok {
if hasID, err := hasColumn(db, "members", "id"); err != nil {
return err
} else if !hasID {
if _, err := db.Exec(`ALTER TABLE members RENAME TO members_v1`); err != nil {
return err
}
if _, err := db.Exec(schema); err != nil {
return err
}
if _, err := db.Exec(`INSERT INTO members(list_id, address, display_name)
SELECT list_id, address, display_name FROM members_v1 ORDER BY list_id, address;
DROP TABLE members_v1;`); err != nil {
return err
}
}
}
if ok, err := hasColumn(db, "lists", "name"); err != nil {
return err
} else if ok {
if has, _ := hasColumn(db, "lists", "post_policy"); !has {
if _, err := db.Exec(`ALTER TABLE lists ADD COLUMN post_policy TEXT NOT NULL DEFAULT 'members';
ALTER TABLE lists ADD COLUMN join_policy TEXT NOT NULL DEFAULT 'open';`); err != nil {
return err
}
}
}
_, err := db.Exec(schema)
return err
}
// Close closes the database.
func (s *Store) Close() error { return s.db.Close() }
// CreateList adds a new list.
func (s *Store) CreateList(name, domain, title string) (List, error) {
l := List{Name: strings.ToLower(name), Domain: strings.ToLower(domain), Title: title}
res, err := s.db.Exec(`INSERT INTO lists(name, domain, title) VALUES(?,?,?)`, l.Name, l.Domain, l.Title)
if err != nil {
if strings.Contains(err.Error(), "UNIQUE") {
return List{}, ErrExists
}
return List{}, err
}
l.ID, _ = res.LastInsertId()
return l, nil
}
func norm(addr string) string { return strings.ToLower(strings.TrimSpace(addr)) }
// FindList resolves a posting address like "dev@example.org".
func (s *Store) FindList(addr string) (List, error) {
name, domain, ok := strings.Cut(strings.ToLower(strings.TrimSpace(addr)), "@")
if !ok {
return List{}, ErrNotFound
}
var l List
err := s.db.QueryRow(`SELECT id, name, domain, title FROM lists WHERE name=? AND domain=?`, name, domain).
Scan(&l.ID, &l.Name, &l.Domain, &l.Title)
if errors.Is(err, sql.ErrNoRows) {
return List{}, ErrNotFound
}
return l, err
}
// AddMember subscribes an address to a list (idempotent).
func (s *Store) AddMember(listID int64, addr, displayName string) error {
_, err := s.db.Exec(`INSERT OR REPLACE INTO members(list_id, address, display_name) VALUES(?,?,?)`,
listID, strings.ToLower(strings.TrimSpace(addr)), displayName)
return err
}
// IsMember reports whether addr is subscribed to the list.
func (s *Store) IsMember(listID int64, addr string) (bool, error) {
var n int
err := s.db.QueryRow(`SELECT COUNT(*) FROM members WHERE list_id=? AND address=?`,
listID, strings.ToLower(strings.TrimSpace(addr))).Scan(&n)
return n > 0, err
}
// Members returns all subscribers of a list.
func (s *Store) Members(listID int64) ([]Member, error) {
rows, err := s.db.Query(`SELECT address, display_name FROM members WHERE list_id=? ORDER BY address`, listID)
if err != nil {
return nil, err
}
defer rows.Close()
var out []Member
for rows.Next() {
var m Member
if err := rows.Scan(&m.Address, &m.DisplayName); err != nil {
return nil, err
}
out = append(out, m)
}
return out, rows.Err()
}
// ListLists returns every list ordered by address.
func (s *Store) ListLists() ([]List, error) {
rows, err := s.db.Query(`SELECT id, name, domain, title FROM lists ORDER BY domain, name`)
if err != nil {
return nil, err
}
defer rows.Close()
var out []List
for rows.Next() {
var l List
if err := rows.Scan(&l.ID, &l.Name, &l.Domain, &l.Title); err != nil {
return nil, err
}
out = append(out, l)
}
return out, rows.Err()
}
// GetList returns a list by id.
func (s *Store) GetList(id int64) (List, error) {
var l List
err := s.db.QueryRow(`SELECT id, name, domain, title FROM lists WHERE id=?`, id).
Scan(&l.ID, &l.Name, &l.Domain, &l.Title)
if errors.Is(err, sql.ErrNoRows) {
return List{}, ErrNotFound
}
return l, err
}
func isUnique(err error) bool { return err != nil && strings.Contains(err.Error(), "UNIQUE") }
func affected(res sql.Result, err error) error {
if err != nil {
@ -174,18 +201,287 @@ func affected(res sql.Result, err error) error {
return nil
}
// Lists.
const listCols = `id, name, domain, title, post_policy, join_policy`
func scanList(row interface{ Scan(...any) error }) (List, error) {
var l List
err := row.Scan(&l.ID, &l.Name, &l.Domain, &l.Title, &l.PostPolicy, &l.JoinPolicy)
if errors.Is(err, sql.ErrNoRows) {
return List{}, ErrNotFound
}
return l, err
}
// CreateList adds a new list with default policies.
func (s *Store) CreateList(name, domain, title string) (List, error) {
res, err := s.db.Exec(`INSERT INTO lists(name, domain, title) VALUES(?,?,?)`,
strings.ToLower(name), strings.ToLower(domain), title)
if isUnique(err) {
return List{}, ErrExists
}
if err != nil {
return List{}, err
}
id, _ := res.LastInsertId()
return s.GetList(id)
}
// FindList resolves a posting address like "dev@example.org".
func (s *Store) FindList(addr string) (List, error) {
name, domain, ok := strings.Cut(norm(addr), "@")
if !ok {
return List{}, ErrNotFound
}
return scanList(s.db.QueryRow(`SELECT `+listCols+` FROM lists WHERE name=? AND domain=?`, name, domain))
}
// GetList returns a list by id.
func (s *Store) GetList(id int64) (List, error) {
return scanList(s.db.QueryRow(`SELECT `+listCols+` FROM lists WHERE id=?`, id))
}
// ListLists returns every list ordered by address.
func (s *Store) ListLists() ([]List, error) {
rows, err := s.db.Query(`SELECT ` + listCols + ` FROM lists ORDER BY domain, name`)
if err != nil {
return nil, err
}
defer rows.Close()
var out []List
for rows.Next() {
l, err := scanList(rows)
if err != nil {
return nil, err
}
out = append(out, l)
}
return out, rows.Err()
}
// UpdateList changes the title of a list.
func (s *Store) UpdateList(id int64, title string) error {
return affected(s.db.Exec(`UPDATE lists SET title=? WHERE id=?`, title, id))
}
// DeleteList removes a list and its members.
// SetPolicies changes the post and join policies of a list.
func (s *Store) SetPolicies(id int64, post, join string) error {
if post != PostMembers && post != PostModerated {
return fmt.Errorf("invalid post policy %q", post)
}
if join != JoinOpen && join != JoinClosed {
return fmt.Errorf("invalid join policy %q", join)
}
return affected(s.db.Exec(`UPDATE lists SET post_policy=?, join_policy=? WHERE id=?`, post, join, id))
}
// DeleteList removes a list with its members, held messages and pending requests.
func (s *Store) DeleteList(id int64) error {
return affected(s.db.Exec(`DELETE FROM lists WHERE id=?`, id))
}
// Members.
const memberCols = `id, list_id, address, display_name, disabled, bounce_count`
func scanMember(row interface{ Scan(...any) error }) (Member, error) {
var m Member
var dis int
err := row.Scan(&m.ID, &m.ListID, &m.Address, &m.DisplayName, &dis, &m.BounceCount)
if errors.Is(err, sql.ErrNoRows) {
return Member{}, ErrNotFound
}
m.Disabled = dis != 0
return m, err
}
// AddMember subscribes an address to a list. Re-adding keeps the member id and
// clears the bounce state.
func (s *Store) AddMember(listID int64, addr, displayName string) error {
_, err := s.db.Exec(`INSERT INTO members(list_id, address, display_name) VALUES(?,?,?)
ON CONFLICT(list_id, address) DO UPDATE SET display_name=excluded.display_name, disabled=0, bounce_count=0`,
listID, norm(addr), displayName)
return err
}
// IsMember reports whether addr is subscribed to the list.
func (s *Store) IsMember(listID int64, addr string) (bool, error) {
var n int
err := s.db.QueryRow(`SELECT COUNT(*) FROM members WHERE list_id=? AND address=?`, listID, norm(addr)).Scan(&n)
return n > 0, err
}
func (s *Store) queryMembers(where string, args ...any) ([]Member, error) {
rows, err := s.db.Query(`SELECT `+memberCols+` FROM members WHERE `+where+` ORDER BY address`, args...)
if err != nil {
return nil, err
}
defer rows.Close()
var out []Member
for rows.Next() {
m, err := scanMember(rows)
if err != nil {
return nil, err
}
out = append(out, m)
}
return out, rows.Err()
}
// Members returns all subscribers of a list, including disabled ones.
func (s *Store) Members(listID int64) ([]Member, error) {
return s.queryMembers(`list_id=?`, listID)
}
// ActiveMembers returns the subscribers that should receive mail.
func (s *Store) ActiveMembers(listID int64) ([]Member, error) {
return s.queryMembers(`list_id=? AND disabled=0`, listID)
}
// MemberByID returns a member by its id.
func (s *Store) MemberByID(id int64) (Member, error) {
return scanMember(s.db.QueryRow(`SELECT `+memberCols+` FROM members WHERE id=?`, id))
}
// RemoveMember unsubscribes an address from a list.
func (s *Store) RemoveMember(listID int64, addr string) error {
return affected(s.db.Exec(`DELETE FROM members WHERE list_id=? AND address=?`,
listID, strings.ToLower(strings.TrimSpace(addr))))
return affected(s.db.Exec(`DELETE FROM members WHERE list_id=? AND address=?`, listID, norm(addr)))
}
// RecordHardBounce counts a hard bounce and disables the member once the count
// reaches threshold. It reports whether the member is now disabled.
func (s *Store) RecordHardBounce(memberID int64, threshold int) (bool, error) {
if err := affected(s.db.Exec(`UPDATE members SET bounce_count=bounce_count+1 WHERE id=?`, memberID)); err != nil {
return false, err
}
if _, err := s.db.Exec(`UPDATE members SET disabled=1 WHERE id=? AND bounce_count>=?`, memberID, threshold); err != nil {
return false, err
}
m, err := s.MemberByID(memberID)
return m.Disabled, err
}
// Held messages.
// HoldMessage queues a message for moderation and returns its id.
func (s *Store) HoldMessage(listID int64, sender string, data []byte) (int64, error) {
res, err := s.db.Exec(`INSERT INTO held(list_id, sender, data, created_at) VALUES(?,?,?,?)`,
listID, norm(sender), data, s.Now().Unix())
if err != nil {
return 0, err
}
return res.LastInsertId()
}
func scanHeld(row interface{ Scan(...any) error }) (Held, error) {
var h Held
var ts int64
err := row.Scan(&h.ID, &h.ListID, &h.Sender, &h.Data, &ts)
if errors.Is(err, sql.ErrNoRows) {
return Held{}, ErrNotFound
}
h.CreatedAt = time.Unix(ts, 0)
return h, err
}
// ListHeld returns the held messages of a list, oldest first.
func (s *Store) ListHeld(listID int64) ([]Held, error) {
rows, err := s.db.Query(`SELECT id, list_id, sender, data, created_at FROM held WHERE list_id=? ORDER BY id`, listID)
if err != nil {
return nil, err
}
defer rows.Close()
var out []Held
for rows.Next() {
h, err := scanHeld(rows)
if err != nil {
return nil, err
}
out = append(out, h)
}
return out, rows.Err()
}
// GetHeld returns a held message by id.
func (s *Store) GetHeld(id int64) (Held, error) {
return scanHeld(s.db.QueryRow(`SELECT id, list_id, sender, data, created_at FROM held WHERE id=?`, id))
}
// DeleteHeld discards a held message.
func (s *Store) DeleteHeld(id int64) error {
return affected(s.db.Exec(`DELETE FROM held WHERE id=?`, id))
}
// Pending confirmations.
func randomHex(n int) (string, error) {
b := make([]byte, n)
if _, err := rand.Read(b); err != nil {
return "", err
}
return hex.EncodeToString(b), nil
}
// CreatePending records a subscribe or unsubscribe request and returns its
// token. created is false when an identical request was made in the last hour:
// this limits how often a third party can trigger confirmation mail.
func (s *Store) CreatePending(listID int64, addr, action string) (token string, created bool, err error) {
addr = norm(addr)
now := s.Now()
var n int
err = s.db.QueryRow(`SELECT COUNT(*) FROM pending WHERE list_id=? AND address=? AND action=? AND created_at>?`,
listID, addr, action, now.Add(-pendingRateLimit).Unix()).Scan(&n)
if err != nil || n > 0 {
return "", false, err
}
token, err = randomHex(16)
if err != nil {
return "", false, err
}
_, err = s.db.Exec(`INSERT INTO pending(token, list_id, address, action, created_at) VALUES(?,?,?,?,?)`,
token, listID, addr, action, now.Unix())
if err != nil {
return "", false, err
}
return token, true, nil
}
// ConfirmPending consumes a token. Unknown, used and expired tokens give ErrNotFound.
func (s *Store) ConfirmPending(token string) (Pending, error) {
var p Pending
var ts int64
err := s.db.QueryRow(`SELECT token, list_id, address, action, created_at FROM pending WHERE token=?`, token).
Scan(&p.Token, &p.ListID, &p.Address, &p.Action, &ts)
if errors.Is(err, sql.ErrNoRows) {
return Pending{}, ErrNotFound
}
if err != nil {
return Pending{}, err
}
if _, err := s.db.Exec(`DELETE FROM pending WHERE token=?`, token); err != nil {
return Pending{}, err
}
if s.Now().Sub(time.Unix(ts, 0)) > pendingTTL {
return Pending{}, ErrNotFound
}
return p, nil
}
// Secret returns the HMAC secret, generating and saving it on first use.
func (s *Store) Secret() ([]byte, error) {
var v string
err := s.db.QueryRow(`SELECT value FROM settings WHERE key='secret'`).Scan(&v)
if errors.Is(err, sql.ErrNoRows) {
v, err = randomHex(32)
if err != nil {
return nil, err
}
if _, err = s.db.Exec(`INSERT INTO settings(key, value) VALUES('secret', ?)`, v); err != nil {
return nil, err
}
} else if err != nil {
return nil, err
}
return hex.DecodeString(v)
}