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:
parent
131299dc0c
commit
9eb4d14a70
2 changed files with 554 additions and 73 deletions
185
internal/store/m2_test.go
Normal file
185
internal/store/m2_test.go
Normal 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()
|
||||
}
|
||||
|
|
@ -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)
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue