feat(router): accept posts only from list members

- Add Router.Route resolving list, checking sender membership
- Return ErrUnknownList and ErrNotMember
- Return subscriber addresses as recipients
This commit is contained in:
tgiachi 2026-11-09 14:47:44 +01:00
commit eb9e992f4a
2 changed files with 113 additions and 0 deletions

55
internal/router/router.go Normal file
View file

@ -0,0 +1,55 @@
// Package router decides what happens to an incoming message.
package router
import (
"errors"
"codeberg.org/squidd/parsimony/internal/store"
)
var (
// ErrUnknownList means the recipient address is not a list.
ErrUnknownList = errors.New("unknown list")
// ErrNotMember means the sender may not post to the list.
ErrNotMember = errors.New("sender is not a member")
)
// Result describes how to deliver an accepted message.
type Result struct {
List store.List
Recipients []string // subscriber addresses
Data []byte // message to send
}
// Router applies list policy to incoming messages.
type Router struct{ store *store.Store }
// New creates a Router backed by s.
func New(s *store.Store) *Router { return &Router{store: s} }
// Route validates a message from sender to the list address rcpt.
func (r *Router) Route(sender, rcpt string, data []byte) (Result, error) {
l, err := r.store.FindList(rcpt)
if errors.Is(err, store.ErrNotFound) {
return Result{}, ErrUnknownList
}
if err != nil {
return Result{}, err
}
ok, err := r.store.IsMember(l.ID, sender)
if err != nil {
return Result{}, err
}
if !ok {
return Result{}, ErrNotMember
}
members, err := r.store.Members(l.ID)
if err != nil {
return Result{}, err
}
rcpts := make([]string, len(members))
for i, m := range members {
rcpts[i] = m.Address
}
return Result{List: l, Recipients: rcpts, Data: data}, nil
}

View file

@ -0,0 +1,58 @@
package router
import (
"errors"
"testing"
"codeberg.org/squidd/parsimony/internal/store"
)
func setup(t *testing.T) *Router {
t.Helper()
s, err := store.Open(":memory:")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { s.Close() })
l, _ := s.CreateList("dev", "example.org", "Dev")
s.AddMember(l.ID, "alice@example.com", "Alice")
s.AddMember(l.ID, "bob@example.com", "Bob")
return New(s)
}
func TestRouteMemberPost(t *testing.T) {
r := setup(t)
res, err := r.Route("alice@example.com", "dev@example.org", []byte("Subject: hi\r\n\r\nbody\r\n"))
if err != nil {
t.Fatalf("route: %v", err)
}
if res.List.Name != "dev" {
t.Fatalf("list: %+v", res.List)
}
if len(res.Recipients) != 2 {
t.Fatalf("want 2 recipients, got %v", res.Recipients)
}
}
func TestRouteSenderCaseInsensitive(t *testing.T) {
r := setup(t)
if _, err := r.Route("ALICE@Example.com", "dev@example.org", nil); err != nil {
t.Fatalf("route: %v", err)
}
}
func TestRouteNonMemberRejected(t *testing.T) {
r := setup(t)
_, err := r.Route("mallory@evil.com", "dev@example.org", nil)
if !errors.Is(err, ErrNotMember) {
t.Fatalf("want ErrNotMember, got %v", err)
}
}
func TestRouteUnknownList(t *testing.T) {
r := setup(t)
_, err := r.Route("alice@example.com", "nope@example.org", nil)
if !errors.Is(err, ErrUnknownList) {
t.Fatalf("want ErrUnknownList, got %v", err)
}
}