Send reply mail from the post event bus.

cmd/server/main.go

@@ -37,14 +37,15 @@ func main() {
 		log.Fatalf("mail: %v", err)
 	}
 	bus := events.New()
-	bot, err := discord.FromEnv(store.NewDiscordLinks(db), bus)
+	mail.Subscribe(bus, store.NewPostgres(db), notifier)
+	bot, err := discord.FromEnv(store.NewDiscordLinks(db), bus, store.NewPostgres(db), notifier)
 	if err != nil {
 		log.Fatalf("discord: %v", err)
 	}
 	if bot != nil {
 		defer bot.Close()
 	}
-	handler := newHandler(db, sessions, uploader, notifier, bus)
+	handler := newHandler(db, sessions, uploader, bus)
 	run(&http.Server{
 		Addr:              listenAddr(),
 		Handler:           handler,
@@ -68,13 +69,12 @@ func openDB() (*sql.DB, *store.SessionStore) {
 	return db, sessions
 }
 
-func newHandler(db *sql.DB, sessions *store.SessionStore, uploader blob.Uploader, notifier mail.Notifier, bus events.Publisher) http.Handler {
+func newHandler(db *sql.DB, sessions *store.SessionStore, uploader blob.Uploader, bus events.Publisher) http.Handler {
 	srv, err := web.New(store.NewPostgres(db), sessions.Store(), plumber.TemplateFS, plumber.StaticFS, web.Config{
 		AdminSetupSecret: strings.TrimSpace(os.Getenv("ADMIN_SETUP_SECRET")),
 		SecureCookie:     secureCookieFromEnv(),
 		TrustedProxies:   parseTrustedProxies(os.Getenv("TRUSTED_PROXY_CIDRS")),
 		Blob:             uploader,
-		Mail:             notifier,
 		Events:           bus,
 		BaseURL:          strings.TrimRight(strings.TrimSpace(os.Getenv("APP_BASE_URL")), "/"),
 	})

internal/discord/bot.go

@@ -13,6 +13,7 @@ import (
 	"github.com/bwmarrin/discordgo"
 
 	"plumber/internal/events"
+	"plumber/internal/mail"
 	"plumber/internal/store"
 )
 
@@ -23,6 +24,10 @@ type Bot struct {
 	channelID string
 	links     store.DiscordLinkStore
 	api       API
+	store     store.Store
+	mail      mail.Notifier
+	admins    map[string]string
+	botUserID string
 }
 
 // New constructs an outbound subscriber. Tests inject a fake API.
@@ -31,7 +36,7 @@ func New(channelID string, links store.DiscordLinkStore, api API) *Bot {
 }
 
 // FromEnv builds a bot when Discord env is set. Missing config is a no-op.
-func FromEnv(links store.DiscordLinkStore, bus *events.Bus) (*Bot, error) {
+func FromEnv(links store.DiscordLinkStore, bus *events.Bus, st store.Store, mailer mail.Notifier) (*Bot, error) {
 	token := strings.TrimSpace(os.Getenv("DISCORD_BOT_TOKEN"))
 	channelID := strings.TrimSpace(os.Getenv("DISCORD_CHANNEL_ID"))
 	if token == "" && channelID == "" {
@@ -50,11 +55,26 @@ func FromEnv(links store.DiscordLinkStore, bus *events.Bus) (*Bot, error) {
 	if err != nil {
 		return nil, err
 	}
+	session.Identify.Intents = discordgo.IntentsGuilds | discordgo.IntentsGuildMessages | discordgo.IntentsMessageContent
+	if mailer == nil {
+		mailer = mail.Nop{}
+	}
 	bot := New(channelID, links, &sessionAPI{session: session})
+	bot.store = st
+	bot.mail = mailer
+	bot.admins = parseAdminMap(os.Getenv("DISCORD_ADMIN_MAP"))
+	session.AddHandler(bot.onMessageCreate)
 	if bus != nil {
 		bus.Subscribe(bot.Handle)
 	}
-	log.Printf("discord: outbound subscriber enabled")
+	if err := session.Open(); err != nil {
+		_ = session.Close()
+		return nil, fmt.Errorf("discord gateway: %w", err)
+	}
+	if session.State != nil && session.State.User != nil {
+		bot.botUserID = session.State.User.ID
+	}
+	log.Printf("discord: subscriber enabled")
 	return bot, nil
 }
 

internal/discord/bot_test.go

@@ -204,7 +204,7 @@ func TestFormatMessage(t *testing.T) {
 func TestFromEnvDisabled(t *testing.T) {
 	t.Setenv("DISCORD_BOT_TOKEN", "")
 	t.Setenv("DISCORD_CHANNEL_ID", "")
-	bot, err := FromEnv(newMemoryLinks(), nil)
+	bot, err := FromEnv(newMemoryLinks(), nil, nil, nil)
 	if err != nil || bot != nil {
 		t.Fatalf("disabled FromEnv = (%v, %v)", bot, err)
 	}
@@ -213,12 +213,12 @@ func TestFromEnvDisabled(t *testing.T) {
 func TestFromEnvRequiresBoth(t *testing.T) {
 	t.Setenv("DISCORD_BOT_TOKEN", "token")
 	t.Setenv("DISCORD_CHANNEL_ID", "")
-	if _, err := FromEnv(newMemoryLinks(), nil); err == nil {
+	if _, err := FromEnv(newMemoryLinks(), nil, nil, nil); err == nil {
 		t.Fatal("expected error when channel is missing")
 	}
 	t.Setenv("DISCORD_BOT_TOKEN", "")
 	t.Setenv("DISCORD_CHANNEL_ID", "channel")
-	if _, err := FromEnv(newMemoryLinks(), nil); err == nil {
+	if _, err := FromEnv(newMemoryLinks(), nil, nil, nil); err == nil {
 		t.Fatal("expected error when token is missing")
 	}
 }

internal/discord/inbound.go

@@ -0,0 +1,227 @@
+package discord
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"log"
+	"strings"
+	"time"
+
+	"github.com/bwmarrin/discordgo"
+
+	"plumber/internal/mail"
+	"plumber/internal/store"
+)
+
+const inboundBodyLimit = 12000
+
+type inboundMessage struct {
+	ID                  string
+	ChannelID           string
+	GuildID             string
+	AuthorID            string
+	Content             string
+	ReferencedMessageID string
+	Bot                 bool
+	Attachments         int
+}
+
+func parseAdminMap(raw string) map[string]string {
+	out := map[string]string{}
+	for _, part := range strings.Split(raw, ",") {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+		id, username, ok := strings.Cut(part, ":")
+		id = strings.TrimSpace(id)
+		username = store.NormalizeUsername(username)
+		if !ok || id == "" || username == "" {
+			log.Printf("discord: skip invalid DISCORD_ADMIN_MAP entry %q", part)
+			continue
+		}
+		out[id] = username
+	}
+	return out
+}
+
+func (b *Bot) onMessageCreate(_ *discordgo.Session, m *discordgo.MessageCreate) {
+	if b == nil || m == nil || m.Author == nil {
+		return
+	}
+	in := inboundMessage{
+		ID:          m.ID,
+		ChannelID:   m.ChannelID,
+		GuildID:     m.GuildID,
+		AuthorID:    m.Author.ID,
+		Content:     m.Content,
+		Bot:         m.Author.Bot,
+		Attachments: len(m.Attachments),
+	}
+	if m.MessageReference != nil {
+		in.ReferencedMessageID = m.MessageReference.MessageID
+	}
+	b.handleInbound(in)
+}
+
+func (b *Bot) handleInbound(in inboundMessage) {
+	if b == nil || b.store == nil {
+		return
+	}
+	if in.Bot || strings.TrimSpace(in.GuildID) == "" {
+		return
+	}
+	if b.botUserID != "" && in.AuthorID == b.botUserID {
+		return
+	}
+	body := strings.TrimSpace(in.Content)
+	if in.Attachments > 0 {
+		log.Printf("discord: ignoring %d attachment(s) on %s", in.Attachments, in.ID)
+	}
+	if body == "" {
+		return
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), discordTimeout)
+	defer cancel()
+	if !b.knownChannel(ctx, in.ChannelID) {
+		return
+	}
+	username := b.admins[in.AuthorID]
+	if username == "" {
+		return
+	}
+	author, err := b.store.UserByUsername(ctx, username)
+	if err != nil {
+		if !errors.Is(err, sql.ErrNoRows) {
+			log.Printf("discord: inbound author %s: %v", username, err)
+		}
+		return
+	}
+	if !author.Admin() {
+		log.Printf("discord: inbound %s is not an admin", username)
+		return
+	}
+	parent, root, err := b.inboundParent(ctx, in)
+	if err != nil {
+		if !errors.Is(err, sql.ErrNoRows) {
+			log.Printf("discord: inbound parent %s: %v", in.ID, err)
+		}
+		return
+	}
+	if root.PostState == store.PostStateHidden {
+		return
+	}
+	reply := &store.Post{
+		AuthorID: author.ID,
+		Body:     truncateRunes(body, inboundBodyLimit),
+		ParentID: &parent.ID,
+	}
+	if err := b.store.CreatePost(ctx, reply); err != nil {
+		log.Printf("discord: create inbound %s: %v", in.ID, err)
+		return
+	}
+	if err := b.links.Upsert(ctx, store.DiscordLink{
+		PostID:    reply.ID,
+		MessageID: in.ID,
+	}); err != nil {
+		log.Printf("discord: save inbound link %s: %v", reply.ID, err)
+	}
+	b.notifyInboundReply(parent, root, reply, author)
+	log.Printf("discord: inbound reply %s -> post %s", in.ID, reply.ID)
+}
+
+func (b *Bot) knownChannel(ctx context.Context, channelID string) bool {
+	if strings.TrimSpace(channelID) == "" {
+		return false
+	}
+	if channelID == b.channelID {
+		return true
+	}
+	_, err := b.links.GetRootByThreadID(ctx, channelID)
+	return err == nil
+}
+
+func (b *Bot) inboundParent(ctx context.Context, in inboundMessage) (*store.Post, *store.Post, error) {
+	if ref := strings.TrimSpace(in.ReferencedMessageID); ref != "" {
+		link, err := b.links.GetByMessageID(ctx, ref)
+		if err == nil {
+			return b.postAndRoot(ctx, link.PostID)
+		}
+		if !errors.Is(err, sql.ErrNoRows) {
+			return nil, nil, err
+		}
+	}
+	link, err := b.links.GetRootByThreadID(ctx, in.ChannelID)
+	if err != nil {
+		return nil, nil, err
+	}
+	return b.postAndRoot(ctx, link.PostID)
+}
+
+func (b *Bot) postAndRoot(ctx context.Context, postID string) (*store.Post, *store.Post, error) {
+	postID = strings.TrimSpace(postID)
+	if postID == "" {
+		return nil, nil, sql.ErrNoRows
+	}
+	post, err := b.store.GetPost(ctx, postID)
+	if err != nil {
+		return nil, nil, err
+	}
+	current := post
+	seen := map[string]bool{}
+	for current.ParentID != nil {
+		if seen[current.ID] {
+			return nil, nil, fmt.Errorf("post ancestry cycle at %s", current.ID)
+		}
+		seen[current.ID] = true
+		current, err = b.store.GetPost(ctx, *current.ParentID)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+	return post, current, nil
+}
+
+func (b *Bot) notifyInboundReply(parent, root, reply *store.Post, author *store.User) {
+	if parent == nil || root == nil || reply == nil || author == nil || b.mail == nil {
+		return
+	}
+	if _, disabled := b.mail.(mail.Nop); disabled {
+		return
+	}
+	recipientID := parent.AuthorID
+	if author.Admin() {
+		recipientID = root.AuthorID
+	}
+	if recipientID == author.ID {
+		return
+	}
+	msg := mail.PostReply{
+		RootID:          root.ID,
+		RootTitle:       root.Title,
+		ReplyID:         reply.ID,
+		ReplyBody:       reply.Body,
+		ReplyAuthorName: author.Name,
+	}
+	go func() {
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+		recipient, err := b.store.UserByID(ctx, recipientID)
+		if err != nil {
+			log.Printf("notify reply %s: load recipient: %v", msg.ReplyID, err)
+			return
+		}
+		if recipient == nil || strings.TrimSpace(recipient.Email) == "" {
+			return
+		}
+		msg.ToEmail = recipient.Email
+		msg.ToName = recipient.Name
+		if err := b.mail.NotifyPostReply(ctx, msg); err != nil {
+			log.Printf("notify reply %s: %v", msg.ReplyID, err)
+			return
+		}
+		log.Printf("notify reply %s: accepted", msg.ReplyID)
+	}()
+}

internal/discord/inbound_test.go

@@ -0,0 +1,218 @@
+package discord
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"plumber/internal/events"
+	"plumber/internal/mail"
+	"plumber/internal/pacific"
+	"plumber/internal/store"
+)
+
+func TestParseAdminMap(t *testing.T) {
+	t.Parallel()
+
+	got := parseAdminMap(" 123:Plumber ,456:other,bad, :empty,789: ")
+	if got["123"] != "plumber" || got["456"] != "other" || len(got) != 2 {
+		t.Fatalf("parseAdminMap = %#v", got)
+	}
+}
+
+func TestInboundCreatesSiteReply(t *testing.T) {
+	t.Parallel()
+
+	mem, homeowner, admin := seedInboundUsers(t)
+	links := newMemoryLinks()
+	api := &fakeAPI{}
+	mailer := &mail.Recording{}
+	bot := inboundTestBot(mem, links, api, mailer, admin.Username)
+	bus := events.New()
+	defer bus.Close()
+	bus.Subscribe(bot.Handle)
+	root := seedLinkedRoot(t, mem, links, homeowner.ID, "thread-1")
+
+	bot.handleInbound(inboundMessage{
+		ID:        "d-reply-1",
+		ChannelID: "thread-1",
+		GuildID:   "guild-1",
+		AuthorID:  "snow-admin",
+		Content:   "Replace the cartridge.",
+	})
+
+	thread, err := mem.GetPostThread(context.Background(), root.ID)
+	if err != nil || len(thread.Replies) != 1 {
+		t.Fatalf("thread = %+v, %v", thread, err)
+	}
+	reply := thread.Replies[0]
+	if reply.AuthorID != admin.ID || reply.Body != "Replace the cartridge." || reply.ParentID == nil || *reply.ParentID != root.ID {
+		t.Fatalf("reply = %+v", reply)
+	}
+	link, err := links.GetByPostID(context.Background(), reply.ID)
+	if err != nil || link.MessageID != "d-reply-1" || link.ThreadID != "" {
+		t.Fatalf("inbound link = %+v, %v", link, err)
+	}
+	time.Sleep(20 * time.Millisecond)
+	if len(api.sends) != 0 || len(api.edits) != 0 {
+		t.Fatalf("inbound echoed to Discord: sends=%+v edits=%+v", api.sends, api.edits)
+	}
+	msgs := waitForMail(t, mailer, 1)
+	if msgs[0].ToEmail != homeowner.Email || msgs[0].ReplyID != reply.ID || msgs[0].RootID != root.ID {
+		t.Fatalf("mail = %+v", msgs[0])
+	}
+}
+
+func TestInboundParentsFromReference(t *testing.T) {
+	t.Parallel()
+
+	mem, homeowner, admin := seedInboundUsers(t)
+	links := newMemoryLinks()
+	bot := inboundTestBot(mem, links, &fakeAPI{}, &mail.Recording{}, admin.Username)
+	root := seedLinkedRoot(t, mem, links, homeowner.ID, "thread-1")
+	plumberReply := &store.Post{ParentID: &root.ID, AuthorID: admin.ID, Body: "First look."}
+	if err := mem.CreatePost(context.Background(), plumberReply); err != nil {
+		t.Fatal(err)
+	}
+	if err := links.Upsert(context.Background(), store.DiscordLink{
+		PostID:    plumberReply.ID,
+		MessageID: "d-plumber-1",
+	}); err != nil {
+		t.Fatal(err)
+	}
+
+	bot.handleInbound(inboundMessage{
+		ID:                  "d-nested",
+		ChannelID:           "thread-1",
+		GuildID:             "guild-1",
+		AuthorID:            "snow-admin",
+		Content:             "More detail.",
+		ReferencedMessageID: "d-plumber-1",
+	})
+
+	thread, err := mem.GetPostThread(context.Background(), root.ID)
+	if err != nil || len(thread.Replies) != 1 || len(thread.Replies[0].Replies) != 1 {
+		t.Fatalf("thread = %+v, %v", thread, err)
+	}
+	nested := thread.Replies[0].Replies[0]
+	if nested.ParentID == nil || *nested.ParentID != plumberReply.ID {
+		t.Fatalf("nested parent = %+v", nested)
+	}
+}
+
+func TestInboundIgnoresAllowlistHiddenAndEchoSources(t *testing.T) {
+	t.Parallel()
+
+	mem, homeowner, admin := seedInboundUsers(t)
+	links := newMemoryLinks()
+	api := &fakeAPI{}
+	bot := inboundTestBot(mem, links, api, mail.Nop{}, admin.Username)
+	root := seedLinkedRoot(t, mem, links, homeowner.ID, "thread-1")
+	hidden := &store.Post{
+		AuthorID:  homeowner.ID,
+		Title:     "Hidden",
+		Body:      "No.",
+		PostDate:  pacific.Today(),
+		PostState: store.PostStateHidden,
+	}
+	if err := mem.CreatePost(context.Background(), hidden); err != nil {
+		t.Fatal(err)
+	}
+	if err := links.Upsert(context.Background(), store.DiscordLink{
+		PostID:    hidden.ID,
+		MessageID: "d-hidden",
+		ThreadID:  "thread-hidden",
+	}); err != nil {
+		t.Fatal(err)
+	}
+
+	cases := []inboundMessage{
+		{ID: "bot", ChannelID: "thread-1", GuildID: "g", AuthorID: "snow-admin", Content: "x", Bot: true},
+		{ID: "dm", ChannelID: "thread-1", AuthorID: "snow-admin", Content: "x"},
+		{ID: "self", ChannelID: "thread-1", GuildID: "g", AuthorID: "bot-1", Content: "x"},
+		{ID: "stranger", ChannelID: "thread-1", GuildID: "g", AuthorID: "snow-other", Content: "x"},
+		{ID: "elsewhere", ChannelID: "other-thread", GuildID: "g", AuthorID: "snow-admin", Content: "x"},
+		{ID: "empty", ChannelID: "thread-1", GuildID: "g", AuthorID: "snow-admin", Content: "   ", Attachments: 1},
+		{ID: "hidden", ChannelID: "thread-hidden", GuildID: "g", AuthorID: "snow-admin", Content: "x"},
+		{ID: "channel-root", ChannelID: "channel-1", GuildID: "g", AuthorID: "snow-admin", Content: "new question"},
+	}
+	for _, in := range cases {
+		bot.handleInbound(in)
+	}
+	thread, err := mem.GetPostThread(context.Background(), root.ID)
+	if err != nil || len(thread.Replies) != 0 {
+		t.Fatalf("unexpected replies: %+v, %v", thread, err)
+	}
+	if len(api.sends) != 0 {
+		t.Fatalf("unexpected discord sends %+v", api.sends)
+	}
+}
+
+func inboundTestBot(mem *store.Memory, links *memoryLinks, api *fakeAPI, mailer mail.Notifier, adminUsername string) *Bot {
+	bot := New("channel-1", links, api)
+	bot.store = mem
+	bot.mail = mailer
+	bot.admins = map[string]string{"snow-admin": adminUsername}
+	bot.botUserID = "bot-1"
+	return bot
+}
+
+func seedInboundUsers(t *testing.T) (*store.Memory, *store.User, *store.User) {
+	t.Helper()
+	mem := store.NewMemory()
+	homeowner := &store.User{
+		Username:     "homeowner",
+		Name:         "Sam",
+		Email:        "sam@example.com",
+		PasswordHash: "x",
+		Role:         store.RoleUser,
+	}
+	if err := mem.CreateUser(context.Background(), homeowner); err != nil {
+		t.Fatal(err)
+	}
+	admin := &store.User{
+		Username:     "plumber",
+		Name:         "Pat",
+		Email:        "pat@example.com",
+		PasswordHash: "x",
+		Role:         store.RoleAdmin,
+	}
+	if err := mem.CreateUser(context.Background(), admin); err != nil {
+		t.Fatal(err)
+	}
+	return mem, homeowner, admin
+}
+
+func seedLinkedRoot(t *testing.T, mem *store.Memory, links *memoryLinks, authorID, threadID string) *store.Post {
+	t.Helper()
+	root := &store.Post{
+		AuthorID: authorID,
+		Title:    "Leaky sink",
+		Body:     "It drips.",
+		PostDate: pacific.Today(),
+	}
+	if err := mem.CreatePost(context.Background(), root); err != nil {
+		t.Fatal(err)
+	}
+	if err := links.Upsert(context.Background(), store.DiscordLink{
+		PostID:    root.ID,
+		MessageID: "d-root",
+		ThreadID:  threadID,
+	}); err != nil {
+		t.Fatal(err)
+	}
+	return root
+}
+
+func waitForMail(t *testing.T, recording *mail.Recording, want int) []mail.PostReply {
+	t.Helper()
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		if recording.Len() >= want {
+			return recording.Snapshot()
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+	t.Fatalf("recorded %d notifications, want %d", recording.Len(), want)
+	return nil
+}

internal/mail/subscriber.go

@@ -0,0 +1,89 @@
+package mail
+
+import (
+	"context"
+	"log"
+	"strings"
+	"time"
+
+	"plumber/internal/events"
+	"plumber/internal/store"
+)
+
+// Subscribe sends reply emails from PostCreated events. Nop or nil is a no-op.
+func Subscribe(bus *events.Bus, st store.Store, n Notifier) {
+	if bus == nil || st == nil || n == nil {
+		return
+	}
+	if _, disabled := n.(Nop); disabled {
+		return
+	}
+	s := subscriber{store: st, mail: n}
+	bus.Subscribe(s.handle)
+}
+
+type subscriber struct {
+	store store.Store
+	mail  Notifier
+}
+
+func (s subscriber) handle(_ context.Context, ev any) {
+	created, ok := ev.(events.PostCreated)
+	if !ok {
+		return
+	}
+	if strings.TrimSpace(created.ParentID) == "" {
+		return
+	}
+	go s.notifyReply(created.PostEvent)
+}
+
+func (s subscriber) notifyReply(ev events.PostEvent) {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	parent, err := s.store.GetPost(ctx, ev.ParentID)
+	if err != nil {
+		log.Printf("notify reply %s: load parent: %v", ev.PostID, err)
+		return
+	}
+	root, err := s.store.GetPost(ctx, ev.RootID)
+	if err != nil {
+		log.Printf("notify reply %s: load root: %v", ev.PostID, err)
+		return
+	}
+	author, err := s.store.UserByID(ctx, ev.AuthorID)
+	if err != nil {
+		log.Printf("notify reply %s: load author: %v", ev.PostID, err)
+		return
+	}
+	recipientID := parent.AuthorID
+	if author.Admin() {
+		recipientID = root.AuthorID
+	}
+	if recipientID == author.ID {
+		return
+	}
+	msg := PostReply{
+		RootID:          root.ID,
+		RootTitle:       root.Title,
+		ReplyID:         ev.PostID,
+		ReplyBody:       ev.Body,
+		ReplyAuthorName: author.Name,
+	}
+	recipient, err := s.store.UserByID(ctx, recipientID)
+	if err != nil {
+		log.Printf("notify reply %s: load recipient: %v", msg.ReplyID, err)
+		return
+	}
+	if recipient == nil || strings.TrimSpace(recipient.Email) == "" {
+		return
+	}
+	msg.ToEmail = recipient.Email
+	msg.ToName = recipient.Name
+	if err := s.mail.NotifyPostReply(ctx, msg); err != nil {
+		log.Printf("notify reply %s: %v", msg.ReplyID, err)
+		return
+	}
+	log.Printf("notify reply %s: accepted", msg.ReplyID)
+}

internal/mail/subscriber_test.go

@@ -0,0 +1,200 @@
+package mail
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"plumber/internal/events"
+	"plumber/internal/pacific"
+	"plumber/internal/store"
+)
+
+func TestSubscribeReplyNotifications(t *testing.T) {
+	t.Parallel()
+
+	mem := store.NewMemory()
+	homeowner := seedMailUser(t, mem, "homeowner", store.RoleUser, "sam@example.com")
+	admin := seedMailUser(t, mem, "plumber", store.RoleAdmin, "pat@example.com")
+	root := seedMailRoot(t, mem, homeowner.ID, "Leaky sink", "It drips.")
+	adminReply := seedMailReply(t, mem, admin.ID, root.ID)
+	homeownerReply := seedMailReply(t, mem, homeowner.ID, adminReply.ID)
+
+	bus := events.New()
+	defer bus.Close()
+	recording := &Recording{}
+	Subscribe(bus, mem, recording)
+
+	ctx := context.Background()
+	bus.Publish(ctx, events.PostCreated{PostEvent: events.PostEvent{
+		PostID:   root.ID,
+		RootID:   root.ID,
+		Title:    root.Title,
+		Body:     root.Body,
+		AuthorID: homeowner.ID,
+	}})
+	bus.Publish(ctx, events.PostUpdated{PostEvent: events.PostEvent{
+		PostID:   adminReply.ID,
+		RootID:   root.ID,
+		ParentID: root.ID,
+		Body:     "Edited",
+		AuthorID: admin.ID,
+	}})
+
+	bus.Publish(ctx, events.PostCreated{PostEvent: events.PostEvent{
+		PostID:   adminReply.ID,
+		RootID:   root.ID,
+		ParentID: root.ID,
+		Body:     adminReply.Body,
+		AuthorID: admin.ID,
+	}})
+	msgs := waitForMail(t, recording, 1)
+	if msg := msgs[0]; msg.ToEmail != homeowner.Email ||
+		msg.RootID != root.ID ||
+		msg.RootTitle != root.Title ||
+		msg.ReplyID != adminReply.ID ||
+		msg.ReplyBody != adminReply.Body ||
+		msg.ReplyAuthorName != admin.Name {
+		t.Fatalf("admin reply = %+v", msg)
+	}
+
+	bus.Publish(ctx, events.PostCreated{PostEvent: events.PostEvent{
+		PostID:   homeownerReply.ID,
+		RootID:   root.ID,
+		ParentID: adminReply.ID,
+		Body:     homeownerReply.Body,
+		AuthorID: homeowner.ID,
+	}})
+	msgs = waitForMail(t, recording, 2)
+	if msg := msgs[1]; msg.ToEmail != admin.Email ||
+		msg.RootID != root.ID ||
+		msg.ReplyID != homeownerReply.ID ||
+		msg.ReplyAuthorName != homeowner.Name {
+		t.Fatalf("homeowner reply = %+v", msg)
+	}
+
+	nestedAdmin := seedMailReply(t, mem, admin.ID, adminReply.ID)
+	bus.Publish(ctx, events.PostCreated{PostEvent: events.PostEvent{
+		PostID:   nestedAdmin.ID,
+		RootID:   root.ID,
+		ParentID: adminReply.ID,
+		Body:     nestedAdmin.Body,
+		AuthorID: admin.ID,
+	}})
+	msgs = waitForMail(t, recording, 3)
+	if msg := msgs[2]; msg.ToEmail != homeowner.Email ||
+		msg.RootID != root.ID ||
+		msg.ReplyBody != nestedAdmin.Body ||
+		msg.ReplyAuthorName != admin.Name {
+		t.Fatalf("nested admin reply = %+v", msg)
+	}
+
+	self := seedMailReply(t, mem, homeowner.ID, root.ID)
+	bus.Publish(ctx, events.PostCreated{PostEvent: events.PostEvent{
+		PostID:   self.ID,
+		RootID:   root.ID,
+		ParentID: root.ID,
+		Body:     self.Body,
+		AuthorID: homeowner.ID,
+	}})
+
+	noEmail := seedMailUser(t, mem, "quiet", store.RoleUser, "")
+	quietRoot := seedMailRoot(t, mem, noEmail.ID, "Quiet thread", "No email.")
+	quietReply := seedMailReply(t, mem, admin.ID, quietRoot.ID)
+	bus.Publish(ctx, events.PostCreated{PostEvent: events.PostEvent{
+		PostID:   quietReply.ID,
+		RootID:   quietRoot.ID,
+		ParentID: quietRoot.ID,
+		Body:     quietReply.Body,
+		AuthorID: admin.ID,
+	}})
+
+	time.Sleep(50 * time.Millisecond)
+	if recording.Len() != 3 {
+		t.Fatalf("self, root, edit, or no-email sent mail: %+v", recording.Snapshot())
+	}
+}
+
+func TestSubscribeNopIgnoresReplies(t *testing.T) {
+	t.Parallel()
+
+	mem := store.NewMemory()
+	homeowner := seedMailUser(t, mem, "homeowner", store.RoleUser, "sam@example.com")
+	admin := seedMailUser(t, mem, "plumber", store.RoleAdmin, "pat@example.com")
+	root := seedMailRoot(t, mem, homeowner.ID, "Leaky sink", "It drips.")
+	reply := seedMailReply(t, mem, admin.ID, root.ID)
+
+	bus := events.New()
+	defer bus.Close()
+	recording := &Recording{}
+	Subscribe(bus, mem, Nop{})
+	Subscribe(nil, mem, recording)
+	Subscribe(bus, mem, nil)
+
+	bus.Publish(context.Background(), events.PostCreated{PostEvent: events.PostEvent{
+		PostID:   reply.ID,
+		RootID:   root.ID,
+		ParentID: root.ID,
+		Body:     reply.Body,
+		AuthorID: admin.ID,
+	}})
+	time.Sleep(50 * time.Millisecond)
+	if recording.Len() != 0 {
+		t.Fatalf("Nop or nil subscribe sent mail: %+v", recording.Snapshot())
+	}
+}
+
+func seedMailUser(t *testing.T, mem *store.Memory, username string, role store.Role, email string) *store.User {
+	t.Helper()
+	u := &store.User{
+		Username:     username,
+		Name:         username,
+		Email:        email,
+		PasswordHash: "x",
+		Role:         role,
+	}
+	if err := mem.CreateUser(context.Background(), u); err != nil {
+		t.Fatal(err)
+	}
+	return u
+}
+
+func seedMailRoot(t *testing.T, mem *store.Memory, authorID, title, body string) *store.Post {
+	t.Helper()
+	root := &store.Post{
+		AuthorID: authorID,
+		Title:    title,
+		Body:     body,
+		PostDate: pacific.Today(),
+	}
+	if err := mem.CreatePost(context.Background(), root); err != nil {
+		t.Fatal(err)
+	}
+	return root
+}
+
+func seedMailReply(t *testing.T, mem *store.Memory, authorID, parentID string) *store.Post {
+	t.Helper()
+	reply := &store.Post{
+		ParentID: &parentID,
+		AuthorID: authorID,
+		Body:     "Reply from " + authorID,
+	}
+	if err := mem.CreatePost(context.Background(), reply); err != nil {
+		t.Fatal(err)
+	}
+	return reply
+}
+
+func waitForMail(t *testing.T, recording *Recording, want int) []PostReply {
+	t.Helper()
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		if recording.Len() >= want {
+			return recording.Snapshot()
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+	t.Fatalf("recorded %d notifications, want %d", recording.Len(), want)
+	return nil
+}

internal/web/posts.go

@@ -5,15 +5,12 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
-	"log"
 	"net/http"
 	"net/url"
 	"strings"
-	"time"
 
 	"github.com/go-chi/chi/v5"
 
-	"plumber/internal/mail"
 	"plumber/internal/store"
 )
 
@@ -82,9 +79,6 @@ func (s *Server) handleCreatePost(w http.ResponseWriter, r *http.Request) {
 	if root == nil {
 		root = post
 	}
-	if parent != nil {
-		s.notifyPostReply(parent, root, post, user)
-	}
 	s.publishPostCreated(post, root, user)
 	http.Redirect(
 		w,
@@ -94,59 +88,6 @@ func (s *Server) handleCreatePost(w http.ResponseWriter, r *http.Request) {
 	)
 }
 
-// notifyPostReply emails the root homeowner for admin replies and the direct
-// parent author for homeowner replies.
-func (s *Server) notifyPostReply(
-	parent *store.Post,
-	root *store.Post,
-	reply *store.Post,
-	replyAuthor *store.User,
-) {
-	if parent == nil ||
-		root == nil ||
-		reply == nil ||
-		replyAuthor == nil ||
-		s.cfg.Mail == nil {
-		return
-	}
-	if _, disabled := s.cfg.Mail.(mail.Nop); disabled {
-		return
-	}
-	recipientID := parent.AuthorID
-	if replyAuthor.Admin() {
-		recipientID = root.AuthorID
-	}
-	if recipientID == replyAuthor.ID {
-		return
-	}
-	msg := mail.PostReply{
-		RootID:          root.ID,
-		RootTitle:       root.Title,
-		ReplyID:         reply.ID,
-		ReplyBody:       reply.Body,
-		ReplyAuthorName: replyAuthor.Name,
-	}
-	go func() {
-		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-		defer cancel()
-		recipient, err := s.store.UserByID(ctx, recipientID)
-		if err != nil {
-			log.Printf("notify reply %s: load recipient: %v", msg.ReplyID, err)
-			return
-		}
-		if recipient == nil || strings.TrimSpace(recipient.Email) == "" {
-			return
-		}
-		msg.ToEmail = recipient.Email
-		msg.ToName = recipient.Name
-		if err := s.cfg.Mail.NotifyPostReply(ctx, msg); err != nil {
-			log.Printf("notify reply %s: %v", msg.ReplyID, err)
-			return
-		}
-		log.Printf("notify reply %s: accepted", msg.ReplyID)
-	}()
-}
-
 // handleEditPost updates only a post's body after verifying that the current
 // homeowner owns it or that an admin is editing an admin-authored post.
 func (s *Server) handleEditPost(w http.ResponseWriter, r *http.Request) {

internal/web/posts_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 	"time"
 
+	"plumber/internal/events"
 	"plumber/internal/mail"
 	"plumber/internal/pacific"
 	"plumber/internal/store"
@@ -263,8 +264,12 @@ func TestEditPostRoutePermissions(t *testing.T) {
 func TestPostReplyNotifications(t *testing.T) {
 	t.Parallel()
 
+	mem := store.NewMemory()
+	bus := events.New()
+	defer bus.Close()
 	recording := &mail.Recording{}
-	srv, mem := newTestServer(t, Config{Mail: recording})
+	mail.Subscribe(bus, mem, recording)
+	srv := newTestServerStore(t, mem, Config{Events: bus})
 	handler := srv.Handler()
 	homeowner := seedUser(t, mem, uniq("homeowner"), "hunter22", store.RoleUser)
 	admin := seedUser(t, mem, uniq("admin"), "hunter22", store.RoleAdmin)

internal/web/server.go

@@ -22,7 +22,6 @@ import (
 	"plumber/internal/blob"
 	"plumber/internal/events"
 	"plumber/internal/geo"
-	"plumber/internal/mail"
 	"plumber/internal/pacific"
 	"plumber/internal/store"
 )
@@ -35,7 +34,6 @@ type Config struct {
 	// TrustedProxies are CIDRs allowed to set X-Forwarded-For (direct peer).
 	TrustedProxies []*net.IPNet
 	Blob           blob.Uploader
-	Mail           mail.Notifier
 	Events         events.Publisher
 	BaseURL        string
 }
@@ -110,9 +108,6 @@ func New(st store.Store, sessionStore scs.Store, templateFS fs.FS, staticFS fs.F
 	if cfg.Blob == nil {
 		cfg.Blob = blob.Disabled{}
 	}
-	if cfg.Mail == nil {
-		cfg.Mail = mail.Nop{}
-	}
 	if cfg.Events == nil {
 		cfg.Events = events.Nop{}
 	}