Initial Ask a Plumber First server

.env.example

@@ -14,11 +14,6 @@ SECURE_COOKIE=0
 # Comma-separated CIDRs of reverse proxies allowed to set X-Forwarded-For
 # (direct peer must match). Leave unset to ignore XFF and use RemoteAddr.
 # TRUSTED_PROXY_CIDRS=10.0.0.0/8,192.168.0.0/16
-# Resend (answer notifications). Leave RESEND_API_KEY unset to disable.
-# RESEND_API_KEY=re_xxxxxxxxx
-# RESEND_FROM=Ask a Plumber <notify@yourdomain.com>
-# Public site origin used in email links (required when Resend is enabled):
-# APP_BASE_URL=https://www.askaplumberfirst.com
 # DigitalOcean Spaces (profile avatars). Leave unset to disable uploads.
 # SPACES_KEY=
 # SPACES_SECRET=

cmd/server/main.go

@@ -17,7 +17,6 @@ import (
 
 	"plumber"
 	"plumber/internal/blob"
-	"plumber/internal/mail"
 	"plumber/internal/store"
 	"plumber/internal/web"
 )
@@ -30,11 +29,7 @@ func main() {
 	defer sessions.Close()
 
 	uploader := blob.FromEnv()
-	notifier, err := mail.FromEnv()
-	if err != nil {
-		log.Fatalf("mail: %v", err)
-	}
-	handler := newHandler(db, sessions, uploader, notifier)
+	handler := newHandler(db, sessions, uploader)
 	run(&http.Server{
 		Addr:              listenAddr(),
 		Handler:           handler,
@@ -58,13 +53,12 @@ func openDB() (*sql.DB, *store.SessionStore) {
 	return db, sessions
 }
 
-func newHandler(db *sql.DB, sessions *store.SessionStore, uploader blob.Uploader, notifier mail.Notifier) http.Handler {
+func newHandler(db *sql.DB, sessions *store.SessionStore, uploader blob.Uploader) 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,
 	})
 	if err != nil {
 		log.Fatalf("server: %v", err)

db/queries/answers.sql

@@ -0,0 +1,11 @@
+-- name: UpsertAnswer :exec
+INSERT INTO answers (question_id, author_id, body, created_at, updated_at)
+VALUES ($1, $2, $3, $4, $5)
+ON CONFLICT (question_id) DO UPDATE
+SET body = excluded.body, author_id = excluded.author_id, updated_at = excluded.updated_at;
+
+-- name: GetAnswer :one
+SELECT a.question_id, a.author_id, u.name AS author_name, a.body, a.created_at, a.updated_at
+FROM answers a
+JOIN users u ON u.id = a.author_id
+WHERE a.question_id = $1;

db/queries/posts.sql

@@ -1,183 +0,0 @@
--- name: CreatePost :exec
-INSERT INTO posts (
-  id, parent_id, author_id, title, body, city, post_date, post_state, created_at, updated_at
-)
-VALUES (
-  sqlc.arg(id),
-  sqlc.arg(parent_id),
-  sqlc.arg(author_id),
-  sqlc.arg(title),
-  sqlc.arg(body),
-  sqlc.arg(city),
-  sqlc.arg(post_date),
-  sqlc.arg(post_state),
-  sqlc.arg(created_at),
-  sqlc.arg(updated_at)
-);
-
--- name: GetPost :one
-SELECT
-  p.id, p.parent_id, p.author_id, u.name AS author_name, u.role AS author_role,
-  p.title, p.body, p.city, p.post_date, p.post_state, p.created_at, p.updated_at
-FROM posts p
-JOIN users u ON u.id = p.author_id
-WHERE p.id = sqlc.arg(id);
-
--- name: ListPostThread :many
-WITH RECURSIVE thread AS (
-  SELECT p.*
-  FROM posts p
-  WHERE p.id = sqlc.arg(root_id) AND p.parent_id IS NULL
-
-  UNION ALL
-
-  SELECT child.*
-  FROM posts child
-  JOIN thread parent ON child.parent_id = parent.id
-)
-SELECT
-  thread.id, thread.parent_id, thread.author_id,
-  u.name AS author_name, u.role AS author_role,
-  thread.title, thread.body, thread.city, thread.post_date,
-  thread.post_state, thread.created_at, thread.updated_at
-FROM thread
-JOIN users u ON u.id = thread.author_id
-ORDER BY thread.created_at, thread.id;
-
--- name: GetRootPostVoteSummary :one
-SELECT
-  COALESCE(SUM(value), 0)::bigint AS score,
-  COALESCE(
-    MAX(value) FILTER (WHERE user_id = sqlc.arg(viewer_id)),
-    0
-  )::bigint AS user_vote
-FROM post_votes
-WHERE post_id = sqlc.arg(root_id);
-
--- name: UpdatePost :execrows
-UPDATE posts
-SET
-  body = sqlc.arg(body),
-  updated_at = sqlc.arg(updated_at)
-WHERE id = sqlc.arg(id);
-
--- name: UpdateRootPostState :execrows
-UPDATE posts
-SET
-  post_state = sqlc.arg(post_state),
-  updated_at = sqlc.arg(updated_at)
-WHERE id = sqlc.arg(id)
-  AND parent_id IS NULL;
-
--- name: ListRootPosts :many
-WITH RECURSIVE roots AS (
-  SELECT p.*
-  FROM posts p
-  WHERE p.parent_id IS NULL
-    AND p.post_date = sqlc.arg(post_date)
-    AND p.post_state <> sqlc.arg(hidden_state)
-),
-thread AS (
-  SELECT roots.id AS root_id, child.id AS post_id, child.author_id
-  FROM roots
-  JOIN posts child ON child.parent_id = roots.id
-
-  UNION ALL
-
-  SELECT thread.root_id, child.id, child.author_id
-  FROM thread
-  JOIN posts child ON child.parent_id = thread.post_id
-),
-answered AS (
-  SELECT DISTINCT thread.root_id
-  FROM thread
-  JOIN users u ON u.id = thread.author_id
-  WHERE u.role = 'admin'
-),
-scores AS (
-  SELECT votes.post_id, SUM(votes.value)::bigint AS score
-  FROM roots
-  JOIN post_votes votes ON votes.post_id = roots.id
-  GROUP BY votes.post_id
-)
-SELECT
-  roots.id, roots.parent_id, roots.author_id,
-  u.name AS author_name, u.role AS author_role,
-  roots.title, roots.body, roots.city, roots.post_date,
-  roots.post_state, roots.created_at, roots.updated_at,
-  COALESCE(scores.score, 0)::bigint AS score,
-  (answered.root_id IS NOT NULL)::bool AS answered,
-  COALESCE(viewer_vote.value, 0)::bigint AS user_vote
-FROM roots
-JOIN users u ON u.id = roots.author_id
-LEFT JOIN scores ON scores.post_id = roots.id
-LEFT JOIN answered ON answered.root_id = roots.id
-LEFT JOIN post_votes viewer_vote
-  ON viewer_vote.user_id = sqlc.arg(viewer_id)
-  AND viewer_vote.post_id = roots.id
-ORDER BY score DESC, roots.created_at, roots.id
-LIMIT sqlc.arg(row_limit);
-
--- name: ListRootPostsByAuthor :many
-SELECT
-  p.id, p.parent_id, p.author_id,
-  u.name AS author_name, u.role AS author_role,
-  p.title, p.body, p.city, p.post_date,
-  p.post_state, p.created_at, p.updated_at
-FROM posts p
-JOIN users u ON u.id = p.author_id
-WHERE p.parent_id IS NULL
-  AND p.author_id = sqlc.arg(author_id)
-  AND p.post_state <> sqlc.arg(hidden_state)
-ORDER BY p.created_at DESC, p.id DESC
-LIMIT sqlc.arg(row_limit);
-
--- name: ListRootPostsAnsweredBy :many
-WITH RECURSIVE ancestors AS (
-  SELECT p.id, p.parent_id
-  FROM posts p
-  WHERE p.author_id = sqlc.arg(admin_id)
-    AND p.parent_id IS NOT NULL
-
-  UNION
-
-  SELECT parent.id, parent.parent_id
-  FROM posts parent
-  JOIN ancestors child ON child.parent_id = parent.id
-)
-SELECT DISTINCT
-  root.id, root.parent_id, root.author_id,
-  u.name AS author_name, u.role AS author_role,
-  root.title, root.body, root.city, root.post_date,
-  root.post_state, root.created_at, root.updated_at
-FROM posts root
-JOIN ancestors ON ancestors.id = root.id
-JOIN users u ON u.id = root.author_id
-WHERE root.parent_id IS NULL
-  AND root.post_state <> sqlc.arg(hidden_state)
-ORDER BY root.created_at DESC, root.id DESC
-LIMIT sqlc.arg(row_limit);
-
--- name: PostIsVisibleRoot :one
-SELECT EXISTS(
-  SELECT 1
-  FROM posts
-  WHERE id = sqlc.arg(id)
-    AND parent_id IS NULL
-    AND post_state <> sqlc.arg(hidden_state)
-)::bool;
-
--- name: DeletePostVote :exec
-DELETE FROM post_votes
-WHERE user_id = sqlc.arg(user_id)
-  AND post_id = sqlc.arg(post_id);
-
--- name: UpsertPostVoteOnVisibleRoot :execrows
-INSERT INTO post_votes (user_id, post_id, value)
-SELECT sqlc.arg(user_id), sqlc.arg(post_id), sqlc.arg(value)
-FROM posts p
-WHERE p.id = sqlc.arg(post_id)
-  AND p.parent_id IS NULL
-  AND p.post_state <> sqlc.arg(hidden_state)
-ON CONFLICT (user_id, post_id) DO UPDATE
-SET value = excluded.value;

db/queries/questions.sql

@@ -0,0 +1,62 @@
+-- name: CreateQuestion :exec
+INSERT INTO questions (id, author_id, title, body, city, hunt_date, hidden, created_at)
+VALUES ($1, $2, $3, $4, $5, $6, 0, $7);
+
+-- name: HideQuestion :exec
+UPDATE questions
+SET hidden = 1
+WHERE id = $1;
+
+-- name: ListHunt :many
+SELECT q.id, q.author_id, u.name AS author_name, q.title, q.body, q.city, q.hunt_date, q.hidden, q.created_at,
+       COALESCE(SUM(v.value), 0)::bigint AS score,
+       CASE WHEN a.question_id IS NULL THEN 0 ELSE 1 END::bigint AS answered,
+       COALESCE((
+         SELECT votes.value FROM votes
+         WHERE votes.user_id = sqlc.arg(viewer_id) AND votes.question_id = q.id
+       ), 0)::bigint AS user_vote
+FROM questions q
+JOIN users u ON u.id = q.author_id
+LEFT JOIN votes v ON v.question_id = q.id
+LEFT JOIN answers a ON a.question_id = q.id
+WHERE q.hunt_date = sqlc.arg(hunt_date) AND q.hidden = 0
+GROUP BY q.id, q.author_id, u.name, q.title, q.body, q.city, q.hunt_date, q.hidden, q.created_at, a.question_id
+ORDER BY score DESC, q.created_at ASC
+LIMIT sqlc.arg(row_limit);
+
+-- name: GetQuestion :one
+SELECT q.id, q.author_id, u.name AS author_name, q.title, q.body, q.city, q.hunt_date, q.hidden, q.created_at,
+       COALESCE((SELECT SUM(votes.value) FROM votes WHERE votes.question_id = q.id), 0)::bigint AS score,
+       CASE WHEN a.question_id IS NULL THEN 0 ELSE 1 END::bigint AS answered,
+       COALESCE((
+         SELECT votes.value FROM votes
+         WHERE votes.user_id = sqlc.arg(viewer_id) AND votes.question_id = q.id
+       ), 0)::bigint AS user_vote
+FROM questions q
+JOIN users u ON u.id = q.author_id
+LEFT JOIN answers a ON a.question_id = q.id
+WHERE q.id = sqlc.arg(id);
+
+-- name: ListQuestionsByAuthor :many
+SELECT q.id, q.author_id, u.name AS author_name, q.title, q.body, q.city, q.hunt_date, q.hidden, q.created_at,
+       COALESCE((SELECT SUM(votes.value) FROM votes WHERE votes.question_id = q.id), 0)::bigint AS score,
+       CASE WHEN a.question_id IS NULL THEN 0 ELSE 1 END::bigint AS answered,
+       0::bigint AS user_vote
+FROM questions q
+JOIN users u ON u.id = q.author_id
+LEFT JOIN answers a ON a.question_id = q.id
+WHERE q.author_id = sqlc.arg(author_id) AND q.hidden = 0
+ORDER BY q.created_at DESC
+LIMIT sqlc.arg(row_limit);
+
+-- name: ListQuestionsAnsweredBy :many
+SELECT q.id, q.author_id, u.name AS author_name, q.title, q.body, q.city, q.hunt_date, q.hidden, q.created_at,
+       COALESCE((SELECT SUM(votes.value) FROM votes WHERE votes.question_id = q.id), 0)::bigint AS score,
+       1::bigint AS answered,
+       0::bigint AS user_vote
+FROM answers ans
+JOIN questions q ON q.id = ans.question_id
+JOIN users u ON u.id = q.author_id
+WHERE ans.author_id = sqlc.arg(admin_id) AND q.hidden = 0
+ORDER BY ans.updated_at DESC
+LIMIT sqlc.arg(row_limit);

db/queries/users.sql

@@ -1,25 +1,24 @@
 -- name: CreateUser :exec
-INSERT INTO users (id, username, name, password_hash, role, email, avatar_url, state, created_at)
-VALUES ($1, $2, $3, $4, $5, $6, '', '', $7);
+INSERT INTO users (id, username, name, password_hash, role, avatar_url, state, created_at)
+VALUES ($1, $2, $3, $4, $5, '', '', $6);
 
 -- name: GetUserByID :one
-SELECT id, username, name, role, email, avatar_url, state, created_at
+SELECT id, username, name, role, avatar_url, state, created_at
 FROM users
 WHERE id = $1;
 
 -- name: GetUserByUsername :one
-SELECT id, username, name, role, email, avatar_url, state, created_at, password_hash
+SELECT id, username, name, role, avatar_url, state, created_at, password_hash
 FROM users
 WHERE username = $1;
 
 -- name: ListUsers :many
-SELECT id, username, name, role, email, avatar_url, state, created_at
+SELECT id, username, name, role, avatar_url, state, created_at
 FROM users
 WHERE (
   sqlc.arg(search) = ''
   OR username ILIKE '%' || sqlc.arg(search) || '%'
   OR name ILIKE '%' || sqlc.arg(search) || '%'
-  OR email ILIKE '%' || sqlc.arg(search) || '%'
 )
 AND (
   sqlc.arg(cursor_created) = ''
@@ -44,12 +43,12 @@ UPDATE users
 SET role = $1
 WHERE id = $2;
 
--- name: UpdateUserProfile :exec
+-- name: UpdateUserState :exec
 UPDATE users
-SET state = $1, email = $2
-WHERE id = $3;
+SET state = $1
+WHERE id = $2;
 
--- name: UpdateUserProfileAndAvatar :exec
+-- name: UpdateUserStateAndAvatar :exec
 UPDATE users
-SET state = $1, email = $2, avatar_url = $3
-WHERE id = $4;
+SET state = $1, avatar_url = $2
+WHERE id = $3;

db/queries/votes.sql

@@ -0,0 +1,24 @@
+-- name: GetVote :one
+SELECT value
+FROM votes
+WHERE user_id = $1 AND question_id = $2;
+
+-- name: QuestionIsVisible :one
+SELECT EXISTS(
+  SELECT 1 FROM questions WHERE id = $1 AND hidden = 0
+)::bool;
+
+-- name: DeleteVote :exec
+DELETE FROM votes
+WHERE user_id = $1 AND question_id = $2;
+
+-- name: UpsertVoteOnVisible :execrows
+INSERT INTO votes (user_id, question_id, value)
+SELECT $1, $2, $3
+FROM questions q
+WHERE q.id = $2 AND q.hidden = 0
+ON CONFLICT (user_id, question_id) DO UPDATE
+SET value = excluded.value
+WHERE EXISTS (
+  SELECT 1 FROM questions q2 WHERE q2.id = excluded.question_id AND q2.hidden = 0
+);

go.mod

@@ -28,7 +28,6 @@ require (
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
 	github.com/jackc/puddle/v2 v2.2.2 // indirect
-	github.com/resend/resend-go/v3 v3.16.0 // indirect
 	golang.org/x/sync v0.22.0 // indirect
 	golang.org/x/text v0.41.0 // indirect
 )

go.sum

@@ -43,8 +43,6 @@ github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/resend/resend-go/v3 v3.16.0 h1:t0Z/7k2sxnJGw8SjsCM9O8qkq3YRRHzTxWQNjhF2KhE=
-github.com/resend/resend-go/v3 v3.16.0/go.mod h1:iI7VA0NoGjWvsNii5iNC5Dy0llsI3HncXPejhniYzwE=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=

internal/mail/mail.go

@@ -1,205 +0,0 @@
-package mail
-
-import (
-	"context"
-	_ "embed"
-	"fmt"
-	"html"
-	"net/url"
-	"os"
-	"strings"
-
-	"github.com/resend/resend-go/v3"
-)
-
-//go:embed mark.png
-var markPNG []byte
-
-// PostReply is the payload for notifying a post author of a direct reply.
-type PostReply struct {
-	ToEmail         string
-	ToName          string
-	RootID          string
-	RootTitle       string
-	ReplyID         string
-	ReplyBody       string
-	ReplyAuthorName string
-}
-
-// Notifier sends transactional email about post replies.
-type Notifier interface {
-	NotifyPostReply(ctx context.Context, msg PostReply) error
-}
-
-// Nop is a no-op Notifier used when Resend is not configured.
-type Nop struct{}
-
-func (Nop) NotifyPostReply(context.Context, PostReply) error { return nil }
-
-// Resend sends via the Resend HTTP API.
-type Resend struct {
-	client  *resend.Client
-	from    string
-	baseURL string
-}
-
-// FromEnv builds a Notifier from RESEND_* and APP_BASE_URL.
-// Returns Nop when RESEND_API_KEY is unset.
-func FromEnv() (Notifier, error) {
-	key := strings.TrimSpace(os.Getenv("RESEND_API_KEY"))
-	if key == "" {
-		return Nop{}, nil
-	}
-	from := strings.TrimSpace(os.Getenv("RESEND_FROM"))
-	base := strings.TrimRight(strings.TrimSpace(os.Getenv("APP_BASE_URL")), "/")
-	if from == "" {
-		return nil, fmt.Errorf("RESEND_FROM is required when RESEND_API_KEY is set")
-	}
-	if base == "" {
-		return nil, fmt.Errorf("APP_BASE_URL is required when RESEND_API_KEY is set")
-	}
-	return &Resend{
-		client:  resend.NewClient(key),
-		from:    from,
-		baseURL: base,
-	}, nil
-}
-
-func (r *Resend) NotifyPostReply(ctx context.Context, msg PostReply) error {
-	if r == nil || r.client == nil {
-		return nil
-	}
-	to := strings.TrimSpace(msg.ToEmail)
-	if to == "" {
-		return nil
-	}
-	text, htmlBody := postReplyContent(r.baseURL, msg)
-	params := &resend.SendEmailRequest{
-		From:    r.from,
-		To:      []string{to},
-		Subject: "New reply to your post",
-		Text:    text,
-		Html:    htmlBody,
-		Attachments: []*resend.Attachment{{
-			Content:     markPNG,
-			Filename:    "ask-a-plumber-first.png",
-			ContentType: "image/png",
-			ContentId:   "reply-notification-mark",
-		}},
-	}
-	opts := &resend.SendEmailOptions{
-		IdempotencyKey: "post-reply:" + msg.ReplyID,
-	}
-	_, err := r.client.Emails.SendWithOptions(ctx, params, opts)
-	return err
-}
-
-func postReplyContent(baseURL string, msg PostReply) (string, string) {
-	link := strings.TrimRight(baseURL, "/") +
-		"/questions/" + url.PathEscape(msg.RootID) +
-		"#post-" + url.PathEscape(msg.ReplyID)
-	title := replyRootTitle(msg.RootTitle)
-	author := strings.TrimSpace(msg.ReplyAuthorName)
-	if author == "" {
-		author = "Someone"
-	}
-	text := fmt.Sprintf(
-		"Hi%s,\n\n%s replied in %q:\n\n%s\n\nView the reply:\n%s\n",
-		greetingName(msg.ToName),
-		author,
-		title,
-		msg.ReplyBody,
-		link,
-	)
-	htmlBody := strings.NewReplacer(
-		"{{PREHEADER}}", html.EscapeString(author+" replied in "+title+"."),
-		"{{GREETING}}", html.EscapeString(greetingName(msg.ToName)),
-		"{{TITLE}}", html.EscapeString(title),
-		"{{AUTHOR}}", html.EscapeString(author),
-		"{{REPLY}}", html.EscapeString(msg.ReplyBody),
-		"{{LINK}}", html.EscapeString(link),
-		"{{MARK}}", "cid:reply-notification-mark",
-	).Replace(postReplyHTML)
-	return text, htmlBody
-}
-
-func replyRootTitle(title string) string {
-	title = strings.TrimSpace(title)
-	if title == "" {
-		return "your conversation"
-	}
-	return title
-}
-
-const postReplyHTML = `<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <meta name="color-scheme" content="dark">
-  <meta name="supported-color-schemes" content="dark">
-  <title>New reply to your conversation</title>
-</head>
-<body style="margin:0;padding:0;background:#161719;color:#ecebe7;font-family:Arial,'Helvetica Neue',sans-serif;">
-  <div style="display:none;max-height:0;overflow:hidden;opacity:0;color:transparent;">{{PREHEADER}}</div>
-  <table role="presentation" width="100%" cellspacing="0" cellpadding="0" border="0" style="width:100%;background:#161719;">
-    <tr>
-      <td align="center" style="padding:32px 16px;">
-        <table role="presentation" width="560" cellspacing="0" cellpadding="0" border="0" style="width:100%;max-width:560px;background:#1e2023;border:1px solid #2e3136;border-top:3px solid #e96a26;border-radius:3px;">
-          <tr>
-            <td style="padding:24px 28px 20px;border-bottom:1px solid #2e3136;">
-              <table role="presentation" cellspacing="0" cellpadding="0" border="0">
-                <tr>
-                  <td style="padding-right:12px;vertical-align:middle;">
-                    <img src="{{MARK}}" width="32" height="32" alt="" style="display:block;width:32px;height:32px;border:0;">
-                  </td>
-                  <td style="vertical-align:middle;">
-                    <div style="color:#ecebe7;font-size:14px;font-weight:700;line-height:1.2;letter-spacing:1px;text-transform:uppercase;">Ask a Plumber First</div>
-                    <div style="margin-top:4px;color:#8d9096;font-family:'Courier New',monospace;font-size:10px;line-height:1.2;letter-spacing:1.4px;text-transform:uppercase;">Bay Area · Shop Dispatch</div>
-                  </td>
-                </tr>
-              </table>
-            </td>
-          </tr>
-          <tr>
-            <td style="padding:30px 28px 32px;">
-              <div style="margin:0 0 10px;color:#e96a26;font-family:'Courier New',monospace;font-size:11px;font-weight:700;line-height:1.4;letter-spacing:1.8px;text-transform:uppercase;">New reply</div>
-              <h1 style="margin:0;color:#ecebe7;font-size:28px;font-weight:600;line-height:1.2;letter-spacing:-0.4px;">The conversation has a new reply.</h1>
-              <p style="margin:18px 0 0;color:#b8babf;font-size:16px;line-height:1.6;">Hi{{GREETING}}, {{AUTHOR}} replied in:</p>
-              <p style="margin:8px 0 0;color:#ecebe7;font-size:17px;font-weight:600;line-height:1.45;">“{{TITLE}}”</p>
-              <table role="presentation" width="100%" cellspacing="0" cellpadding="0" border="0" style="width:100%;margin-top:24px;background:#161719;border:1px solid #2e3136;border-radius:3px;">
-                <tr>
-                  <td style="padding:20px 18px;">
-                    <div style="margin:0 0 10px;color:#8d9096;font-family:'Courier New',monospace;font-size:10px;font-weight:700;line-height:1.4;letter-spacing:1.5px;text-transform:uppercase;">The reply</div>
-                    <div style="margin:0;color:#ecebe7;font-size:16px;line-height:1.65;white-space:pre-wrap;">{{REPLY}}</div>
-                  </td>
-                </tr>
-              </table>
-              <table role="presentation" cellspacing="0" cellpadding="0" border="0" style="margin-top:26px;">
-                <tr>
-                  <td bgcolor="#e96a26" style="border-radius:3px;">
-                    <a href="{{LINK}}" style="display:inline-block;padding:13px 18px;color:#161719;font-family:'Courier New',monospace;font-size:12px;font-weight:700;line-height:1;text-decoration:none;letter-spacing:0.8px;text-transform:uppercase;">View the reply&nbsp;&rarr;</a>
-                  </td>
-                </tr>
-              </table>
-            </td>
-          </tr>
-          <tr>
-            <td style="padding:18px 28px;border-top:1px solid #2e3136;color:#8d9096;font-family:'Courier New',monospace;font-size:10px;line-height:1.6;letter-spacing:0.4px;">
-              You received this because someone replied to your post on Ask a Plumber First.
-            </td>
-          </tr>
-        </table>
-      </td>
-    </tr>
-  </table>
-</body>
-</html>`
-
-func greetingName(name string) string {
-	name = strings.TrimSpace(name)
-	if name == "" {
-		return ""
-	}
-	return " " + name
-}

internal/mail/mail_test.go

@@ -1,80 +0,0 @@
-package mail
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-)
-
-func TestEmbeddedMarkIsPNG(t *testing.T) {
-	t.Parallel()
-
-	if !bytes.HasPrefix(markPNG, []byte("\x89PNG\r\n\x1a\n")) {
-		t.Fatal("embedded mark is not PNG data")
-	}
-}
-
-func TestPostReplyContent(t *testing.T) {
-	t.Parallel()
-
-	text, htmlBody := postReplyContent("https://www.askaplumberfirst.com/", PostReply{
-		ToName:          `<Sam & Pat>`,
-		RootID:          "question-123",
-		RootTitle:       `<b>Leaky sink</b>`,
-		ReplyID:         "reply-456",
-		ReplyBody:       "Replace the cartridge.\nThen test the handle. <script>alert('x')</script>",
-		ReplyAuthorName: `<Jo & Co>`,
-	})
-
-	for _, want := range []string{
-		"Ask a Plumber First",
-		"New reply",
-		"cid:reply-notification-mark",
-		"https://www.askaplumberfirst.com/questions/question-123#post-reply-456",
-		"white-space:pre-wrap",
-		"&lt;Sam &amp; Pat&gt;",
-		"&lt;b&gt;Leaky sink&lt;/b&gt;",
-		"&lt;Jo &amp; Co&gt;",
-		"&lt;script&gt;alert(&#39;x&#39;)&lt;/script&gt;",
-	} {
-		if !strings.Contains(htmlBody, want) {
-			t.Errorf("HTML missing %q", want)
-		}
-	}
-	for _, unsafe := range []string{
-		"<Sam & Pat>",
-		"<b>Leaky sink</b>",
-		"<Jo & Co>",
-		"<script>alert('x')</script>",
-	} {
-		if strings.Contains(htmlBody, unsafe) {
-			t.Errorf("HTML contains unescaped content %q", unsafe)
-		}
-	}
-	if strings.Contains(htmlBody, "{{") {
-		t.Error("HTML contains an unresolved template token")
-	}
-	for _, want := range []string{
-		`Hi <Sam & Pat>,`,
-		`<Jo & Co> replied in "<b>Leaky sink</b>"`,
-		"Replace the cartridge.\nThen test the handle.",
-		"https://www.askaplumberfirst.com/questions/question-123#post-reply-456",
-	} {
-		if !strings.Contains(text, want) {
-			t.Errorf("text missing %q", want)
-		}
-	}
-}
-
-func TestPostReplyContentUsesFallbacks(t *testing.T) {
-	t.Parallel()
-
-	text, htmlBody := postReplyContent("https://www.askaplumberfirst.com", PostReply{})
-	if !strings.Contains(text, `Someone replied in "your conversation"`) {
-		t.Errorf("text missing fallback title")
-	}
-	if !strings.Contains(htmlBody, "Someone replied in:</p>") ||
-		!strings.Contains(htmlBody, "“your conversation”") {
-		t.Errorf("HTML missing fallbacks")
-	}
-}

internal/mail/recording.go

@@ -1,34 +0,0 @@
-package mail
-
-import (
-	"context"
-	"sync"
-)
-
-// Recording is a test Notifier that records calls.
-type Recording struct {
-	mu   sync.Mutex
-	Msgs []PostReply
-}
-
-func (r *Recording) NotifyPostReply(_ context.Context, msg PostReply) error {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	r.Msgs = append(r.Msgs, msg)
-	return nil
-}
-
-func (r *Recording) Len() int {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	return len(r.Msgs)
-}
-
-// Snapshot returns a copy of recorded messages.
-func (r *Recording) Snapshot() []PostReply {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	out := make([]PostReply, len(r.Msgs))
-	copy(out, r.Msgs)
-	return out
-}

internal/store/answer.go

@@ -0,0 +1,63 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+	"time"
+
+	"plumber/internal/store/sqlc"
+)
+
+// Answer is an admin reply to a question.
+type Answer struct {
+	QuestionID string
+	AuthorID   string
+	AuthorName string
+	Body       string
+	CreatedAt  string
+	UpdatedAt  string
+	db         *sql.DB
+}
+
+// NewAnswer returns an Answer bound to db.
+func NewAnswer(db *sql.DB) *Answer {
+	return &Answer{db: db}
+}
+
+// Upsert inserts or updates the answer for QuestionID.
+func (a *Answer) Upsert(ctx context.Context) error {
+	if a == nil || a.db == nil {
+		return fmt.Errorf("answer: no database")
+	}
+	a.Body = strings.TrimSpace(a.Body)
+	now := time.Now().UTC().Format(time.RFC3339)
+	if a.CreatedAt == "" {
+		a.CreatedAt = now
+	}
+	a.UpdatedAt = now
+	return sqlc.New(a.db).UpsertAnswer(ctx, sqlc.UpsertAnswerParams{
+		QuestionID: a.QuestionID,
+		AuthorID:   a.AuthorID,
+		Body:       a.Body,
+		CreatedAt:  a.CreatedAt,
+		UpdatedAt:  a.UpdatedAt,
+	})
+}
+
+func GetAnswer(ctx context.Context, db *sql.DB, questionID string) (*Answer, error) {
+	r, err := sqlc.New(db).GetAnswer(ctx, questionID)
+	if err != nil {
+		return nil, err
+	}
+	return &Answer{
+		QuestionID: r.QuestionID,
+		AuthorID:   r.AuthorID,
+		AuthorName: r.AuthorName,
+		Body:       r.Body,
+		CreatedAt:  r.CreatedAt,
+		UpdatedAt:  r.UpdatedAt,
+		db:         db,
+	}, nil
+}

internal/store/email.go

@@ -1,52 +0,0 @@
-package store
-
-import (
-	"fmt"
-	"net/mail"
-	"strings"
-	"unicode/utf8"
-)
-
-const (
-	minEmailLen = 3
-	maxEmailLen = 254
-)
-
-// NormalizeEmail trims and lowercases an address for storage/comparison.
-func NormalizeEmail(s string) string {
-	return strings.ToLower(strings.TrimSpace(s))
-}
-
-// ValidateEmail returns a normalized address or an error message suitable for UI.
-func ValidateEmail(raw string) (normalized string, errMsg string) {
-	normalized = NormalizeEmail(raw)
-	if normalized == "" {
-		return "", "Email is required."
-	}
-	n := utf8.RuneCountInString(normalized)
-	if n < minEmailLen || len(normalized) > maxEmailLen {
-		return "", "Enter a valid email address."
-	}
-	addr, err := mail.ParseAddress(normalized)
-	if err != nil || addr.Address != normalized {
-		return "", "Enter a valid email address."
-	}
-	at := strings.LastIndex(normalized, "@")
-	if at < 1 || at == len(normalized)-1 {
-		return "", "Enter a valid email address."
-	}
-	domain := normalized[at+1:]
-	if !strings.Contains(domain, ".") || strings.HasPrefix(domain, ".") || strings.HasSuffix(domain, ".") {
-		return "", "Enter a valid email address."
-	}
-	return normalized, ""
-}
-
-// MustValidateEmail is like ValidateEmail but returns a Go error.
-func MustValidateEmail(raw string) (string, error) {
-	n, msg := ValidateEmail(raw)
-	if msg != "" {
-		return "", fmt.Errorf("%s", msg)
-	}
-	return n, nil
-}

internal/store/email_test.go

@@ -1,21 +0,0 @@
-package store
-
-import "testing"
-
-func TestValidateEmail(t *testing.T) {
-	cases := []struct {
-		in, want, err string
-	}{
-		{"", "", "Email is required."},
-		{"  Alice@Example.COM ", "alice@example.com", ""},
-		{"not-an-email", "", "Enter a valid email address."},
-		{"a@b", "", "Enter a valid email address."},
-		{"ok@example.com", "ok@example.com", ""},
-	}
-	for _, tc := range cases {
-		got, msg := ValidateEmail(tc.in)
-		if got != tc.want || msg != tc.err {
-			t.Fatalf("%q: got (%q, %q) want (%q, %q)", tc.in, got, msg, tc.want, tc.err)
-		}
-	}
-}

internal/store/memory.go

@@ -10,15 +10,18 @@ import (
 	"time"
 
 	"github.com/google/uuid"
+
+	"plumber/internal/pacific"
 )
 
 // Memory is an in-process Store for tests.
 type Memory struct {
 	mu        sync.Mutex
-	users     map[string]*User          // id -> user
-	byName    map[string]string         // username -> id
-	posts     map[string]*Post          // id -> post
-	postVotes map[string]map[string]int // postID -> userID -> value
+	users     map[string]*User           // id -> user
+	byName    map[string]string          // username -> id
+	questions map[string]*RankedQuestion // id -> question
+	answers   map[string]*Answer         // questionID -> answer
+	votes     map[string]map[string]int  // questionID -> userID -> value
 }
 
 // NewMemory returns an empty Memory store.
@@ -26,8 +29,9 @@ func NewMemory() *Memory {
 	return &Memory{
 		users:     map[string]*User{},
 		byName:    map[string]string{},
-		posts:     map[string]*Post{},
-		postVotes: map[string]map[string]int{},
+		questions: map[string]*RankedQuestion{},
+		answers:   map[string]*Answer{},
+		votes:     map[string]map[string]int{},
 	}
 }
 
@@ -38,17 +42,9 @@ func (m *Memory) CreateUser(_ context.Context, u *User) error {
 		return fmt.Errorf("invalid role")
 	}
 	u.Username = NormalizeUsername(u.Username)
-	u.Email = NormalizeEmail(u.Email)
 	if _, ok := m.byName[u.Username]; ok {
 		return ErrDuplicateUsername
 	}
-	if u.Email != "" {
-		for _, existing := range m.users {
-			if existing.Email == u.Email {
-				return ErrDuplicateEmail
-			}
-		}
-	}
 	if u.ID == "" {
 		u.ID = uuid.NewString()
 	}
@@ -183,283 +179,198 @@ func (m *Memory) SaveUserProfile(_ context.Context, u *User) error {
 	if !ok {
 		return sql.ErrNoRows
 	}
-	email := NormalizeEmail(u.Email)
-	if email != "" {
-		for id, existing := range m.users {
-			if id != u.ID && existing.Email == email {
-				return ErrDuplicateEmail
-			}
-		}
-	}
 	cur.State = strings.TrimSpace(u.State)
-	cur.Email = email
 	if u.AvatarURL != "" {
 		cur.AvatarURL = u.AvatarURL
 	}
 	u.State = cur.State
-	u.Email = cur.Email
 	u.AvatarURL = cur.AvatarURL
 	return nil
 }
 
-func (m *Memory) CreatePost(_ context.Context, post *Post) error {
-	if post == nil {
-		return fmt.Errorf("%w: post is nil", ErrInvalidPost)
-	}
-	if err := preparePost(post); err != nil {
-		return err
-	}
+func (m *Memory) CreateQuestion(_ context.Context, q *RankedQuestion) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	if _, ok := m.users[post.AuthorID]; !ok {
-		return fmt.Errorf("%w: unknown author", ErrInvalidPost)
+	q.Title = strings.TrimSpace(q.Title)
+	q.Body = strings.TrimSpace(q.Body)
+	q.City = strings.TrimSpace(q.City)
+	if q.ID == "" {
+		q.ID = uuid.NewString()
 	}
-	if _, exists := m.posts[post.ID]; exists {
-		return fmt.Errorf("%w: duplicate id", ErrInvalidPost)
+	if q.HuntDate == "" {
+		q.HuntDate = pacific.Today()
 	}
-	if post.ParentID != nil {
-		if _, ok := m.posts[*post.ParentID]; !ok {
-			return fmt.Errorf("%w: unknown parent", ErrInvalidPost)
-		}
+	if q.CreatedAt == "" {
+		q.CreatedAt = time.Now().UTC().Format(time.RFC3339)
 	}
-	cp := clonePost(post)
+	author, ok := m.users[q.AuthorID]
+	if !ok {
+		return fmt.Errorf("unknown author")
+	}
+	cp := *q
+	cp.AuthorName = author.Name
 	cp.db = nil
-	m.posts[cp.ID] = cp
-	*post = *clonePost(cp)
+	m.questions[cp.ID] = &cp
+	*q = cp
 	return nil
 }
 
-func (m *Memory) GetPost(_ context.Context, id string) (*Post, error) {
+func (m *Memory) annotate(q *RankedQuestion, viewerID string) RankedQuestion {
+	out := *q
+	score := 0
+	userVote := 0
+	if votes, ok := m.votes[q.ID]; ok {
+		for uid, v := range votes {
+			score += v
+			if uid == viewerID {
+				userVote = v
+			}
+		}
+	}
+	_, answered := m.answers[q.ID]
+	out.Score = score
+	out.Answered = answered
+	out.UserVote = userVote
+	out.db = nil
+	return out
+}
+
+func (m *Memory) GetQuestion(_ context.Context, id, viewerID string) (*RankedQuestion, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	post, ok := m.posts[id]
+	q, ok := m.questions[id]
 	if !ok {
 		return nil, sql.ErrNoRows
 	}
-	return clonePostWithAuthor(post, m.users), nil
+	out := m.annotate(q, viewerID)
+	return &out, nil
 }
 
-func (m *Memory) GetPostThread(_ context.Context, rootID string) (*Post, error) {
+func (m *Memory) ListHunt(_ context.Context, huntDate, viewerID string) ([]RankedQuestion, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	root, ok := m.posts[rootID]
-	if !ok || root.ParentID != nil {
-		return nil, sql.ErrNoRows
-	}
-	inThread := map[string]bool{rootID: true}
-	for changed := true; changed; {
-		changed = false
-		for id, post := range m.posts {
-			if inThread[id] || post.ParentID == nil || !inThread[*post.ParentID] {
-				continue
-			}
-			inThread[id] = true
-			changed = true
+	out := make([]RankedQuestion, 0)
+	for _, q := range m.questions {
+		if q.HuntDate != huntDate || q.Hidden {
+			continue
 		}
+		out = append(out, m.annotate(q, viewerID))
 	}
-	posts := make([]Post, 0, len(inThread))
-	for id := range inThread {
-		posts = append(posts, *clonePostWithAuthor(m.posts[id], m.users))
+	sort.Slice(out, func(i, j int) bool {
+		if out[i].Score != out[j].Score {
+			return out[i].Score > out[j].Score
+		}
+		return out[i].CreatedAt < out[j].CreatedAt
+	})
+	if len(out) > HuntListLimit {
+		out = out[:HuntListLimit]
 	}
-	return buildPostTree(posts, rootID)
+	return out, nil
 }
 
-func (m *Memory) GetPostThreadForViewer(ctx context.Context, rootID, viewerID string) (*Post, error) {
-	root, err := m.GetPostThread(ctx, rootID)
-	if err != nil {
-		return nil, err
-	}
+func (m *Memory) ListQuestionsByAuthor(_ context.Context, authorID string) ([]RankedQuestion, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	for _, value := range m.postVotes[rootID] {
-		root.Score += value
+	out := make([]RankedQuestion, 0)
+	for _, q := range m.questions {
+		if q.AuthorID != authorID || q.Hidden {
+			continue
+		}
+		out = append(out, m.annotate(q, ""))
 	}
-	root.UserVote = m.postVotes[rootID][viewerID]
-	root.Answered = m.threadContainsAdminReply(rootID)
-	return root, nil
+	sort.Slice(out, func(i, j int) bool { return out[i].CreatedAt > out[j].CreatedAt })
+	if len(out) > ProfileListLimit {
+		out = out[:ProfileListLimit]
+	}
+	return out, nil
 }
 
-func (m *Memory) UpdatePost(_ context.Context, post *Post) error {
-	if post == nil {
-		return fmt.Errorf("%w: post is nil", ErrInvalidPost)
-	}
-	body := strings.TrimSpace(post.Body)
-	if body == "" {
-		return fmt.Errorf("%w: body is required", ErrInvalidPost)
-	}
+func (m *Memory) ListQuestionsAnsweredBy(_ context.Context, adminID string) ([]RankedQuestion, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	existing, ok := m.posts[post.ID]
+	out := make([]RankedQuestion, 0)
+	for qid, a := range m.answers {
+		if a.AuthorID != adminID {
+			continue
+		}
+		q, ok := m.questions[qid]
+		if !ok || q.Hidden {
+			continue
+		}
+		rq := m.annotate(q, "")
+		rq.Answered = true
+		out = append(out, rq)
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].CreatedAt > out[j].CreatedAt })
+	if len(out) > ProfileListLimit {
+		out = out[:ProfileListLimit]
+	}
+	return out, nil
+}
+
+func (m *Memory) HideQuestion(_ context.Context, id string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	q, ok := m.questions[id]
 	if !ok {
 		return sql.ErrNoRows
 	}
-	existing.Body = body
-	existing.UpdatedAt = time.Now().UTC().Format(time.RFC3339Nano)
-	*post = *clonePostWithAuthor(existing, m.users)
+	q.Hidden = true
 	return nil
 }
 
-func (m *Memory) ListRootPosts(_ context.Context, postDate, viewerID string) ([]Post, error) {
+func (m *Memory) GetAnswer(_ context.Context, questionID string) (*Answer, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	posts := make([]Post, 0)
-	for _, post := range m.posts {
-		if post.ParentID != nil || post.PostDate != postDate || post.PostState == PostStateHidden {
-			continue
-		}
-		cp := clonePostWithAuthor(post, m.users)
-		for _, value := range m.postVotes[post.ID] {
-			cp.Score += value
-		}
-		cp.UserVote = m.postVotes[post.ID][viewerID]
-		cp.Answered = m.threadContainsAdminReply(post.ID)
-		posts = append(posts, *cp)
+	a, ok := m.answers[questionID]
+	if !ok {
+		return nil, sql.ErrNoRows
 	}
-	sort.Slice(posts, func(i, j int) bool {
-		if posts[i].Score != posts[j].Score {
-			return posts[i].Score > posts[j].Score
-		}
-		if posts[i].CreatedAt != posts[j].CreatedAt {
-			return posts[i].CreatedAt < posts[j].CreatedAt
-		}
-		return posts[i].ID < posts[j].ID
-	})
-	if len(posts) > HuntListLimit {
-		posts = posts[:HuntListLimit]
+	cp := *a
+	if u, ok := m.users[a.AuthorID]; ok {
+		cp.AuthorName = u.Name
 	}
-	return posts, nil
+	return &cp, nil
 }
 
-func (m *Memory) ListRootPostsByAuthor(_ context.Context, authorID string) ([]Post, error) {
+func (m *Memory) UpsertAnswer(_ context.Context, a *Answer) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	posts := make([]Post, 0)
-	for _, post := range m.posts {
-		if post.ParentID != nil ||
-			post.AuthorID != authorID ||
-			post.PostState == PostStateHidden {
-			continue
-		}
-		posts = append(posts, *clonePostWithAuthor(post, m.users))
+	if _, ok := m.questions[a.QuestionID]; !ok {
+		return fmt.Errorf("unknown question")
 	}
-	return sortProfilePosts(posts), nil
-}
-
-func (m *Memory) ListRootPostsAnsweredBy(_ context.Context, adminID string) ([]Post, error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	posts := make([]Post, 0)
-	for _, root := range m.posts {
-		if root.ParentID != nil || root.PostState == PostStateHidden {
-			continue
-		}
-		participated := false
-		for _, post := range m.posts {
-			if post.AuthorID == adminID && m.postIsDescendantOf(post, root.ID) {
-				participated = true
-				break
-			}
-		}
-		if participated {
-			posts = append(posts, *clonePostWithAuthor(root, m.users))
-		}
+	a.Body = strings.TrimSpace(a.Body)
+	now := time.Now().UTC().Format(time.RFC3339)
+	if existing, ok := m.answers[a.QuestionID]; ok {
+		a.CreatedAt = existing.CreatedAt
+	} else if a.CreatedAt == "" {
+		a.CreatedAt = now
 	}
-	return sortProfilePosts(posts), nil
-}
-
-func (m *Memory) SetRootPostState(_ context.Context, id string, state PostState) error {
-	switch state {
-	case PostStateVisible, PostStateHidden, PostStateLocked:
-	default:
-		return fmt.Errorf("%w: invalid post state", ErrInvalidPost)
-	}
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	post, ok := m.posts[id]
-	if !ok || post.ParentID != nil {
-		return sql.ErrNoRows
-	}
-	post.PostState = state
-	post.UpdatedAt = time.Now().UTC().Format(time.RFC3339Nano)
+	a.UpdatedAt = now
+	cp := *a
+	cp.db = nil
+	m.answers[a.QuestionID] = &cp
+	*a = cp
 	return nil
 }
 
-func sortProfilePosts(posts []Post) []Post {
-	sort.Slice(posts, func(i, j int) bool {
-		if posts[i].CreatedAt != posts[j].CreatedAt {
-			return posts[i].CreatedAt > posts[j].CreatedAt
-		}
-		return posts[i].ID > posts[j].ID
-	})
-	if len(posts) > ProfileListLimit {
-		posts = posts[:ProfileListLimit]
-	}
-	return posts
-}
-
-func (m *Memory) VotePost(_ context.Context, userID, postID string, value int) error {
+func (m *Memory) Vote(_ context.Context, userID, questionID string, value int) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	if value != 1 && value != -1 && value != 0 {
 		return fmt.Errorf("invalid vote")
 	}
-	post, ok := m.posts[postID]
-	if !ok || post.ParentID != nil || post.PostState == PostStateHidden {
-		return ErrPostNotVotable
+	q, ok := m.questions[questionID]
+	if !ok || q.Hidden {
+		return ErrHiddenOrMissing
 	}
-	if m.postVotes[postID] == nil {
-		m.postVotes[postID] = map[string]int{}
+	if m.votes[questionID] == nil {
+		m.votes[questionID] = map[string]int{}
 	}
 	if value == 0 {
-		delete(m.postVotes[postID], userID)
+		delete(m.votes[questionID], userID)
 		return nil
 	}
-	m.postVotes[postID][userID] = value
+	m.votes[questionID][userID] = value
 	return nil
 }
-
-func (m *Memory) threadContainsAdminReply(rootID string) bool {
-	for id, post := range m.posts {
-		if id == rootID || !m.postIsDescendantOf(post, rootID) {
-			continue
-		}
-		if author := m.users[post.AuthorID]; author != nil && author.Role == RoleAdmin {
-			return true
-		}
-	}
-	return false
-}
-
-func (m *Memory) postIsDescendantOf(post *Post, rootID string) bool {
-	seen := map[string]bool{}
-	for post != nil && post.ParentID != nil {
-		if *post.ParentID == rootID {
-			return true
-		}
-		if seen[*post.ParentID] {
-			return false
-		}
-		seen[*post.ParentID] = true
-		post = m.posts[*post.ParentID]
-	}
-	return false
-}
-
-func clonePost(post *Post) *Post {
-	cp := *post
-	if post.ParentID != nil {
-		parentID := *post.ParentID
-		cp.ParentID = &parentID
-	}
-	cp.Replies = nil
-	return &cp
-}
-
-func clonePostWithAuthor(post *Post, users map[string]*User) *Post {
-	cp := clonePost(post)
-	if author := users[post.AuthorID]; author != nil {
-		cp.AuthorName = author.Name
-		cp.AuthorRole = author.Role
-	}
-	return cp
-}

internal/store/migrate.go

@@ -21,244 +21,6 @@ func migrateUserProfileColumns(ctx context.Context, exec execContext) error {
 	return nil
 }
 
-// migrateUserEmail adds email and a partial unique index on lower(email).
-func migrateUserEmail(ctx context.Context, exec execContext) error {
-	if _, err := exec.ExecContext(ctx, `ALTER TABLE users ADD COLUMN IF NOT EXISTS email TEXT NOT NULL DEFAULT ''`); err != nil {
-		return fmt.Errorf("add column email: %w", err)
-	}
-	if _, err := exec.ExecContext(ctx, `
-CREATE UNIQUE INDEX IF NOT EXISTS users_email_lower_uidx
-  ON users (lower(email))
-  WHERE email <> ''`); err != nil {
-		return fmt.Errorf("users_email_lower_uidx: %w", err)
-	}
-	return nil
-}
-
-// migratePosts creates the unified post model.
-func migratePosts(ctx context.Context, exec execContext) error {
-	steps := []struct {
-		name string
-		sql  string
-	}{
-		{name: "create posts", sql: `
-CREATE TABLE IF NOT EXISTS posts (
-  id TEXT PRIMARY KEY,
-  parent_id TEXT REFERENCES posts(id) ON DELETE CASCADE,
-  author_id TEXT NOT NULL REFERENCES users(id),
-  title TEXT NOT NULL DEFAULT '',
-  body TEXT NOT NULL,
-  city TEXT NOT NULL DEFAULT '',
-  post_date TEXT NOT NULL DEFAULT '',
-  post_state TEXT NOT NULL,
-  created_at TEXT NOT NULL,
-  updated_at TEXT NOT NULL,
-  CONSTRAINT posts_shape_check CHECK (
-    (parent_id IS NULL AND title <> '' AND post_date <> '')
-    OR
-    (parent_id IS NOT NULL AND title = '' AND city = '' AND post_date = '')
-  )
-)`},
-		{name: "index post replies", sql: `
-CREATE INDEX IF NOT EXISTS idx_posts_parent_created
-  ON posts(parent_id, created_at, id)`},
-		{name: "index post authors", sql: `
-CREATE INDEX IF NOT EXISTS idx_posts_author_created
-  ON posts(author_id, created_at DESC, id DESC)`},
-		{name: "index root posts", sql: `
-CREATE INDEX IF NOT EXISTS idx_posts_root_date
-  ON posts(post_date, post_state)
-  WHERE parent_id IS NULL`},
-		{name: "create post votes", sql: `
-CREATE TABLE IF NOT EXISTS post_votes (
-  user_id TEXT NOT NULL REFERENCES users(id),
-  post_id TEXT NOT NULL REFERENCES posts(id) ON DELETE CASCADE,
-  value INTEGER NOT NULL CHECK (value IN (-1, 1)),
-  PRIMARY KEY (user_id, post_id)
-)`},
-	}
-	for _, step := range steps {
-		if _, err := exec.ExecContext(ctx, step.sql); err != nil {
-			return fmt.Errorf("%s: %w", step.name, err)
-		}
-	}
-	return nil
-}
-
-func migratePostVoteIndex(ctx context.Context, exec execContext) error {
-	if _, err := exec.ExecContext(ctx, `
-CREATE INDEX IF NOT EXISTS idx_post_votes_post_id
-  ON post_votes(post_id)`); err != nil {
-		return fmt.Errorf("idx_post_votes_post_id: %w", err)
-	}
-	return nil
-}
-
-func migratePostAuthorIndex(ctx context.Context, exec execContext) error {
-	if _, err := exec.ExecContext(ctx, `
-CREATE INDEX IF NOT EXISTS idx_posts_author_created
-  ON posts(author_id, created_at DESC, id DESC)`); err != nil {
-		return fmt.Errorf("idx_posts_author_created: %w", err)
-	}
-	return nil
-}
-
-func migrateDropLegacyPostTables(ctx context.Context, exec execContext) error {
-	steps := []struct {
-		name string
-		sql  string
-	}{
-		{"drop legacy answers", `DROP TABLE IF EXISTS answers`},
-		{"drop legacy votes", `DROP TABLE IF EXISTS votes`},
-		{"drop legacy questions", `DROP TABLE IF EXISTS questions`},
-	}
-	for _, step := range steps {
-		if _, err := exec.ExecContext(ctx, step.sql); err != nil {
-			return fmt.Errorf("%s: %w", step.name, err)
-		}
-	}
-	return nil
-}
-
-func migratePostDate(ctx context.Context, exec execContext) error {
-	steps := []struct {
-		name string
-		sql  string
-	}{
-		{"rename post date", `
-DO $migration$
-BEGIN
-  IF EXISTS (
-    SELECT 1
-    FROM information_schema.columns
-    WHERE table_schema = current_schema()
-      AND table_name = 'posts'
-      AND column_name = 'hunt_date'
-  ) AND NOT EXISTS (
-    SELECT 1
-    FROM information_schema.columns
-    WHERE table_schema = current_schema()
-      AND table_name = 'posts'
-      AND column_name = 'post_date'
-  ) THEN
-    ALTER TABLE posts RENAME COLUMN hunt_date TO post_date;
-  END IF;
-END
-$migration$`},
-		{"drop legacy root date index", `
-DROP INDEX IF EXISTS idx_posts_root_hunt`},
-		{"create root date index", `
-DO $migration$
-BEGIN
-  IF EXISTS (
-    SELECT 1
-    FROM information_schema.columns
-    WHERE table_schema = current_schema()
-      AND table_name = 'posts'
-      AND column_name = 'post_state'
-  ) THEN
-    CREATE INDEX IF NOT EXISTS idx_posts_root_date
-      ON posts(post_date, post_state)
-      WHERE parent_id IS NULL;
-  ELSE
-    CREATE INDEX IF NOT EXISTS idx_posts_root_date
-      ON posts(post_date, hidden)
-      WHERE parent_id IS NULL;
-  END IF;
-END
-$migration$`},
-	}
-	for _, step := range steps {
-		if _, err := exec.ExecContext(ctx, step.sql); err != nil {
-			return fmt.Errorf("%s: %w", step.name, err)
-		}
-	}
-	return nil
-}
-
-func migratePostState(ctx context.Context, exec execContext) error {
-	if _, err := exec.ExecContext(ctx, `
-ALTER TABLE posts
-  ADD COLUMN IF NOT EXISTS post_state TEXT`); err != nil {
-		return fmt.Errorf("add post state: %w", err)
-	}
-	hasHidden, err := migrationColumnExists(ctx, exec, "posts", "hidden")
-	if err != nil {
-		return fmt.Errorf("check hidden column: %w", err)
-	}
-	if hasHidden {
-		if _, err := exec.ExecContext(ctx, `
-UPDATE posts
-SET post_state = CASE
-  WHEN hidden = 0 THEN $1
-  ELSE $2
-END`, string(PostStateVisible), string(PostStateHidden)); err != nil {
-			return fmt.Errorf("copy hidden state: %w", err)
-		}
-	}
-
-	steps := []struct {
-		name string
-		sql  string
-	}{
-		{"drop root date index", `
-DROP INDEX IF EXISTS idx_posts_root_date`},
-		{"drop legacy post shape constraint", `
-ALTER TABLE posts DROP CONSTRAINT IF EXISTS posts_check`},
-		{"drop post shape constraint", `
-ALTER TABLE posts DROP CONSTRAINT IF EXISTS posts_shape_check`},
-		{"drop hidden", `
-ALTER TABLE posts DROP COLUMN IF EXISTS hidden`},
-		{"require post state", `
-ALTER TABLE posts ALTER COLUMN post_state SET NOT NULL`},
-		{"create post shape constraint", `
-ALTER TABLE posts
-  ADD CONSTRAINT posts_shape_check CHECK (
-    (parent_id IS NULL AND title <> '' AND post_date <> '')
-    OR
-    (parent_id IS NOT NULL AND title = '' AND city = '' AND post_date = '')
-  )`},
-		{"create root date index", `
-CREATE INDEX idx_posts_root_date
-  ON posts(post_date, post_state)
-  WHERE parent_id IS NULL`},
-	}
-	for _, step := range steps {
-		if _, err := exec.ExecContext(ctx, step.sql); err != nil {
-			return fmt.Errorf("%s: %w", step.name, err)
-		}
-	}
-	return nil
-}
-
-func migrationColumnExists(
-	ctx context.Context,
-	exec execContext,
-	tableName string,
-	columnName string,
-) (bool, error) {
-	rows, err := exec.QueryContext(ctx, `
-SELECT EXISTS (
-  SELECT 1
-  FROM information_schema.columns
-  WHERE table_schema = current_schema()
-    AND table_name = $1
-    AND column_name = $2
-)`, tableName, columnName)
-	if err != nil {
-		return false, err
-	}
-	defer rows.Close()
-	if !rows.Next() {
-		return false, rows.Err()
-	}
-	var exists bool
-	if err := rows.Scan(&exists); err != nil {
-		return false, err
-	}
-	return exists, rows.Err()
-}
-
 type execContext interface {
 	ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
 	QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error)
@@ -304,13 +66,6 @@ CREATE TABLE IF NOT EXISTS schema_migrations (
 			return applySchema(ctx, exec, schemaSQL)
 		}},
 		{"002_user_profile_columns", migrateUserProfileColumns},
-		{"003_user_email", migrateUserEmail},
-		{"004_posts", migratePosts},
-		{"005_post_vote_post_id_index", migratePostVoteIndex},
-		{"006_post_date", migratePostDate},
-		{"007_post_state", migratePostState},
-		{"008_post_author_index", migratePostAuthorIndex},
-		{"009_drop_legacy_post_tables", migrateDropLegacyPostTables},
 	}
 	for _, m := range migrations {
 		if applied[m.version] {

internal/store/migrate_posts_test.go

@@ -1,483 +0,0 @@
-package store
-
-import (
-	"context"
-	"database/sql"
-	"fmt"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/google/uuid"
-
-	"plumber/internal/store/sqlc"
-)
-
-func TestPostMigrationsAndQueries(t *testing.T) {
-	rawURL := strings.TrimSpace(os.Getenv("TEST_DATABASE_URL"))
-	if rawURL == "" {
-		t.Skip("TEST_DATABASE_URL is not set")
-	}
-	dsn, err := postgresDSN(rawURL)
-	if err != nil {
-		t.Fatal(err)
-	}
-	db, err := sql.Open("pgx", dsn)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	ctx := context.Background()
-	conn, err := db.Conn(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer conn.Close()
-
-	schemaName := "test_posts_" + strings.ReplaceAll(uuid.NewString(), "-", "")
-	if _, err := conn.ExecContext(ctx, "CREATE SCHEMA "+schemaName); err != nil {
-		t.Fatal(err)
-	}
-	defer func() {
-		_, _ = conn.ExecContext(context.Background(), "SET search_path TO public")
-		_, _ = conn.ExecContext(context.Background(), "DROP SCHEMA "+schemaName+" CASCADE")
-	}()
-	if _, err := conn.ExecContext(ctx, "SET search_path TO "+schemaName); err != nil {
-		t.Fatal(err)
-	}
-
-	baseSchema := `
-CREATE TABLE users (
-  id TEXT PRIMARY KEY,
-  name TEXT NOT NULL,
-  role TEXT NOT NULL
-);`
-	if err := applySchema(ctx, conn, baseSchema); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := migratePosts(ctx, conn); err != nil {
-		t.Fatal(err)
-	}
-	if err := migratePosts(ctx, conn); err != nil {
-		t.Fatalf("migration is not idempotent: %v", err)
-	}
-	if err := migratePostVoteIndex(ctx, conn); err != nil {
-		t.Fatal(err)
-	}
-	if err := migratePostVoteIndex(ctx, conn); err != nil {
-		t.Fatalf("post vote index migration is not idempotent: %v", err)
-	}
-	if err := migratePostAuthorIndex(ctx, conn); err != nil {
-		t.Fatal(err)
-	}
-	if err := migratePostAuthorIndex(ctx, conn); err != nil {
-		t.Fatalf("post author index migration is not idempotent: %v", err)
-	}
-	if _, err := conn.ExecContext(ctx, `
-INSERT INTO users (id, name, role)
-VALUES ('homeowner', 'Home Owner', 'user'), ('plumber', 'The Plumber', 'admin');
-INSERT INTO posts (
-  id, parent_id, author_id, title, body, city, post_date, post_state, created_at, updated_at
-) VALUES
-  (
-    'root-1', NULL, 'homeowner', 'Leaky sink', 'It drips.', 'Oakland',
-    '2026-08-26', 'visible', '2026-08-26T08:00:00Z', '2026-08-26T08:00:00Z'
-  ),
-  (
-    'reply-1', 'root-1', 'plumber', '', 'Replace the cartridge.', '', '',
-    'visible', '2026-08-26T09:00:00Z', '2026-08-26T09:05:00Z'
-  );
-INSERT INTO post_votes (user_id, post_id, value)
-VALUES ('homeowner', 'root-1', 1);`); err != nil {
-		t.Fatal(err)
-	}
-
-	var postCount, voteCount int
-	if err := conn.QueryRowContext(ctx, "SELECT count(*) FROM posts").Scan(&postCount); err != nil {
-		t.Fatal(err)
-	}
-	if err := conn.QueryRowContext(ctx, "SELECT count(*) FROM post_votes").Scan(&voteCount); err != nil {
-		t.Fatal(err)
-	}
-	if postCount != 2 || voteCount != 1 {
-		t.Fatalf("counts posts=%d votes=%d", postCount, voteCount)
-	}
-	var postVoteIndexCount int
-	if err := conn.QueryRowContext(ctx, `
-SELECT count(*)
-FROM pg_indexes
-WHERE schemaname = current_schema()
-  AND tablename = 'post_votes'
-  AND indexname = 'idx_post_votes_post_id'`).Scan(&postVoteIndexCount); err != nil {
-		t.Fatal(err)
-	}
-	if postVoteIndexCount != 1 {
-		t.Fatalf("post vote index count = %d, want 1", postVoteIndexCount)
-	}
-	var postAuthorIndexCount int
-	if err := conn.QueryRowContext(ctx, `
-SELECT count(*)
-FROM pg_indexes
-WHERE schemaname = current_schema()
-  AND tablename = 'posts'
-  AND indexname = 'idx_posts_author_created'`).Scan(&postAuthorIndexCount); err != nil {
-		t.Fatal(err)
-	}
-	if postAuthorIndexCount != 1 {
-		t.Fatalf("post author index count = %d, want 1", postAuthorIndexCount)
-	}
-	if _, err := conn.ExecContext(ctx, `
-INSERT INTO post_votes (user_id, post_id, value)
-VALUES ('homeowner', 'root-1', -1)`); err == nil {
-		t.Fatal("duplicate user/post vote unexpectedly succeeded")
-	}
-
-	var rootParent sql.NullString
-	var rootAuthor, title, rootBody, city, postDate, rootState, rootCreated, rootUpdated string
-	if err := conn.QueryRowContext(ctx, `
-SELECT parent_id, author_id, title, body, city, post_date, post_state, created_at, updated_at
-FROM posts
-WHERE id = 'root-1'`).Scan(
-		&rootParent,
-		&rootAuthor,
-		&title,
-		&rootBody,
-		&city,
-		&postDate,
-		&rootState,
-		&rootCreated,
-		&rootUpdated,
-	); err != nil {
-		t.Fatal(err)
-	}
-	if rootParent.Valid ||
-		rootAuthor != "homeowner" ||
-		title != "Leaky sink" ||
-		rootBody != "It drips." ||
-		city != "Oakland" ||
-		postDate != "2026-08-26" ||
-		rootState != "visible" ||
-		rootCreated != "2026-08-26T08:00:00Z" ||
-		rootUpdated != rootCreated {
-		t.Fatalf("unexpected root post")
-	}
-
-	var replyParent, replyAuthor, replyBody, replyState, replyCreated, replyUpdated string
-	if err := conn.QueryRowContext(ctx, `
-SELECT parent_id, author_id, body, post_state, created_at, updated_at
-FROM posts
-WHERE id = 'reply-1'`).Scan(
-		&replyParent,
-		&replyAuthor,
-		&replyBody,
-		&replyState,
-		&replyCreated,
-		&replyUpdated,
-	); err != nil {
-		t.Fatal(err)
-	}
-	if replyParent != "root-1" ||
-		replyAuthor != "plumber" ||
-		replyBody != "Replace the cartridge." ||
-		replyState != "visible" ||
-		replyCreated != "2026-08-26T09:00:00Z" ||
-		replyUpdated != "2026-08-26T09:05:00Z" {
-		t.Fatalf("unexpected reply post")
-	}
-
-	var voteValue int
-	if err := conn.QueryRowContext(ctx, `
-SELECT value FROM post_votes
-WHERE user_id = 'homeowner' AND post_id = 'root-1'`).Scan(&voteValue); err != nil {
-		t.Fatal(err)
-	}
-	if voteValue != 1 {
-		t.Fatalf("vote value = %d, want 1", voteValue)
-	}
-
-	if _, err := conn.ExecContext(ctx, `
-INSERT INTO posts (
-  id, parent_id, author_id, title, body, city, post_date, post_state, created_at, updated_at
-) VALUES (
-  'invalid-reply', 'root-1', 'homeowner', 'Replies cannot have titles', 'Body', '', '',
-  'visible', 'now', 'now'
-)`); err == nil {
-		t.Fatal("reply with root-only title unexpectedly succeeded")
-	}
-
-	queries := sqlc.New(conn)
-	if err := queries.CreatePost(ctx, sqlc.CreatePostParams{
-		ID:        "follow-up",
-		ParentID:  sql.NullString{String: "reply-1", Valid: true},
-		AuthorID:  "homeowner",
-		Body:      "It is still dripping.",
-		PostState: string(PostStateVisible),
-		CreatedAt: "2026-08-26T10:00:00Z",
-		UpdatedAt: "2026-08-26T10:00:00Z",
-	}); err != nil {
-		t.Fatal(err)
-	}
-	thread, err := queries.ListPostThread(ctx, "root-1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(thread) != 3 ||
-		thread[0].ID != "root-1" ||
-		thread[1].ID != "reply-1" ||
-		thread[2].ID != "follow-up" {
-		t.Fatalf("recursive thread = %+v", thread)
-	}
-	nonRootThread, err := queries.ListPostThread(ctx, "reply-1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(nonRootThread) != 0 {
-		t.Fatalf("non-root thread lookup returned %+v", nonRootThread)
-	}
-	if n, err := queries.UpdatePost(ctx, sqlc.UpdatePostParams{
-		ID:        "follow-up",
-		Body:      "The drip continues.",
-		UpdatedAt: "2026-08-26T10:05:00Z",
-	}); err != nil || n != 1 {
-		t.Fatalf("update rows=%d error=%v", n, err)
-	}
-	if n, err := queries.UpsertPostVoteOnVisibleRoot(ctx, sqlc.UpsertPostVoteOnVisibleRootParams{
-		UserID:      "plumber",
-		PostID:      "root-1",
-		Value:       1,
-		HiddenState: string(PostStateHidden),
-	}); err != nil || n != 1 {
-		t.Fatalf("vote rows=%d error=%v", n, err)
-	}
-	roots, err := queries.ListRootPosts(ctx, sqlc.ListRootPostsParams{
-		ViewerID:    "plumber",
-		RowLimit:    100,
-		PostDate:    "2026-08-26",
-		HiddenState: string(PostStateHidden),
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(roots) != 1 ||
-		roots[0].Score != 2 ||
-		!roots[0].Answered ||
-		roots[0].UserVote != 1 {
-		t.Fatalf("root annotations = %+v", roots)
-	}
-	summary, err := queries.GetRootPostVoteSummary(ctx, sqlc.GetRootPostVoteSummaryParams{
-		ViewerID: "plumber",
-		RootID:   "root-1",
-	})
-	if err != nil || summary.Score != 2 || summary.UserVote != 1 {
-		t.Fatalf("root vote summary = %+v, %v", summary, err)
-	}
-	byAuthor, err := queries.ListRootPostsByAuthor(ctx, sqlc.ListRootPostsByAuthorParams{
-		AuthorID:    "homeowner",
-		HiddenState: string(PostStateHidden),
-		RowLimit:    50,
-	})
-	if err != nil || len(byAuthor) != 1 || byAuthor[0].ID != "root-1" {
-		t.Fatalf("roots by author = %+v, %v", byAuthor, err)
-	}
-	answeredBy, err := queries.ListRootPostsAnsweredBy(ctx, sqlc.ListRootPostsAnsweredByParams{
-		HiddenState: string(PostStateHidden),
-		AdminID:     "plumber",
-		RowLimit:    50,
-	})
-	if err != nil || len(answeredBy) != 1 || answeredBy[0].ID != "root-1" {
-		t.Fatalf("roots answered by admin = %+v, %v", answeredBy, err)
-	}
-	for _, state := range []PostState{PostStateLocked, PostStateVisible} {
-		n, err := queries.UpdateRootPostState(ctx, sqlc.UpdateRootPostStateParams{
-			PostState: string(state),
-			UpdatedAt: "2026-08-26T10:10:00Z",
-			ID:        "root-1",
-		})
-		if err != nil || n != 1 {
-			t.Fatalf("set root state %q rows=%d error=%v", state, n, err)
-		}
-	}
-
-	if _, err := conn.ExecContext(ctx, `
-DROP INDEX idx_posts_root_date;
-ALTER TABLE posts RENAME COLUMN post_date TO hunt_date;
-CREATE INDEX idx_posts_root_hunt
-  ON posts(hunt_date, post_state)
-  WHERE parent_id IS NULL;`); err != nil {
-		t.Fatal(err)
-	}
-	if err := migratePostDate(ctx, conn); err != nil {
-		t.Fatal(err)
-	}
-	if err := migratePostDate(ctx, conn); err != nil {
-		t.Fatalf("post date migration is not idempotent: %v", err)
-	}
-
-	var postDateColumnCount, huntDateColumnCount, rootDateIndexCount, legacyIndexCount int
-	if err := conn.QueryRowContext(ctx, `
-SELECT
-  count(*) FILTER (WHERE column_name = 'post_date'),
-  count(*) FILTER (WHERE column_name = 'hunt_date')
-FROM information_schema.columns
-WHERE table_schema = current_schema()
-  AND table_name = 'posts'`).Scan(&postDateColumnCount, &huntDateColumnCount); err != nil {
-		t.Fatal(err)
-	}
-	if err := conn.QueryRowContext(ctx, `
-SELECT
-  count(*) FILTER (WHERE indexname = 'idx_posts_root_date'),
-  count(*) FILTER (WHERE indexname = 'idx_posts_root_hunt')
-FROM pg_indexes
-WHERE schemaname = current_schema()
-  AND tablename = 'posts'`).Scan(&rootDateIndexCount, &legacyIndexCount); err != nil {
-		t.Fatal(err)
-	}
-	var migratedPostDate string
-	if err := conn.QueryRowContext(ctx, `
-SELECT post_date FROM posts WHERE id = 'root-1'`).Scan(&migratedPostDate); err != nil {
-		t.Fatal(err)
-	}
-	if postDateColumnCount != 1 ||
-		huntDateColumnCount != 0 ||
-		rootDateIndexCount != 1 ||
-		legacyIndexCount != 0 ||
-		migratedPostDate != "2026-08-26" {
-		t.Fatalf(
-			"post date migration columns=%d legacy_columns=%d indexes=%d legacy_indexes=%d date=%q",
-			postDateColumnCount,
-			huntDateColumnCount,
-			rootDateIndexCount,
-			legacyIndexCount,
-			migratedPostDate,
-		)
-	}
-
-	if _, err := conn.ExecContext(ctx, `
-DROP INDEX idx_posts_root_date;
-ALTER TABLE posts DROP CONSTRAINT posts_shape_check;
-ALTER TABLE posts ADD COLUMN hidden INTEGER NOT NULL DEFAULT 0;
-UPDATE posts SET hidden = CASE WHEN id = 'root-1' THEN 1 ELSE 0 END;
-ALTER TABLE posts DROP COLUMN post_state;
-ALTER TABLE posts ADD CONSTRAINT posts_check CHECK (
-  (parent_id IS NULL AND title <> '' AND post_date <> '')
-  OR
-  (parent_id IS NOT NULL AND title = '' AND city = '' AND post_date = '' AND hidden = 0)
-);
-CREATE INDEX idx_posts_root_date
-  ON posts(post_date, hidden)
-  WHERE parent_id IS NULL;`); err != nil {
-		t.Fatal(err)
-	}
-	if err := migratePostState(ctx, conn); err != nil {
-		t.Fatal(err)
-	}
-	if err := migratePostState(ctx, conn); err != nil {
-		t.Fatalf("post state migration is not idempotent: %v", err)
-	}
-
-	var postStateColumnCount, hiddenColumnCount int
-	if err := conn.QueryRowContext(ctx, `
-SELECT
-  count(*) FILTER (WHERE column_name = 'post_state'),
-  count(*) FILTER (WHERE column_name = 'hidden')
-FROM information_schema.columns
-WHERE table_schema = current_schema()
-  AND table_name = 'posts'`).Scan(&postStateColumnCount, &hiddenColumnCount); err != nil {
-		t.Fatal(err)
-	}
-	var hiddenState, replyStateAfterMigration string
-	if err := conn.QueryRowContext(ctx, `
-SELECT post_state FROM posts WHERE id = 'root-1'`).Scan(&hiddenState); err != nil {
-		t.Fatal(err)
-	}
-	if err := conn.QueryRowContext(ctx, `
-SELECT post_state FROM posts WHERE id = 'reply-1'`).Scan(&replyStateAfterMigration); err != nil {
-		t.Fatal(err)
-	}
-	var postStateDataType string
-	if err := conn.QueryRowContext(ctx, `
-SELECT data_type
-FROM information_schema.columns
-WHERE table_schema = current_schema()
-  AND table_name = 'posts'
-  AND column_name = 'post_state'`).Scan(&postStateDataType); err != nil {
-		t.Fatal(err)
-	}
-	var stateIndexCount int
-	if err := conn.QueryRowContext(ctx, `
-SELECT count(*)
-FROM pg_indexes
-WHERE schemaname = current_schema()
-  AND tablename = 'posts'
-  AND indexname = 'idx_posts_root_date'
-  AND indexdef LIKE '%(post_date, post_state)%'`).Scan(&stateIndexCount); err != nil {
-		t.Fatal(err)
-	}
-	if postStateColumnCount != 1 ||
-		hiddenColumnCount != 0 ||
-		hiddenState != "hidden" ||
-		replyStateAfterMigration != "visible" ||
-		postStateDataType != "text" ||
-		stateIndexCount != 1 {
-		t.Fatalf(
-			"post state migration columns=%d hidden_columns=%d root=%q reply=%q type=%q indexes=%d",
-			postStateColumnCount,
-			hiddenColumnCount,
-			hiddenState,
-			replyStateAfterMigration,
-			postStateDataType,
-			stateIndexCount,
-		)
-	}
-
-	if _, err := conn.ExecContext(ctx, `
-CREATE TABLE questions (id TEXT PRIMARY KEY);
-CREATE TABLE votes (id TEXT PRIMARY KEY);
-CREATE TABLE answers (id TEXT PRIMARY KEY);`); err != nil {
-		t.Fatal(err)
-	}
-	if err := migrateDropLegacyPostTables(ctx, conn); err != nil {
-		t.Fatal(err)
-	}
-	if err := migrateDropLegacyPostTables(ctx, conn); err != nil {
-		t.Fatalf("legacy table cleanup is not idempotent: %v", err)
-	}
-	for _, table := range []string{"questions", "votes", "answers"} {
-		var relation sql.NullString
-		if err := conn.QueryRowContext(ctx, "SELECT to_regclass($1)", table).Scan(&relation); err != nil {
-			t.Fatal(err)
-		}
-		if relation.Valid {
-			t.Fatalf("legacy table %q still exists", table)
-		}
-	}
-}
-
-func TestMigratePostsReportsStep(t *testing.T) {
-	t.Parallel()
-
-	exec := &failingMigrationExec{failAt: 5}
-	err := migratePosts(context.Background(), exec)
-	if err == nil || !strings.Contains(err.Error(), "create post votes") {
-		t.Fatalf("error = %v, want create post votes context", err)
-	}
-}
-
-type failingMigrationExec struct {
-	calls  int
-	failAt int
-}
-
-func (f *failingMigrationExec) ExecContext(context.Context, string, ...any) (sql.Result, error) {
-	f.calls++
-	if f.calls == f.failAt {
-		return nil, fmt.Errorf("boom")
-	}
-	return nil, nil
-}
-
-func (*failingMigrationExec) QueryContext(context.Context, string, ...any) (*sql.Rows, error) {
-	return nil, fmt.Errorf("not implemented")
-}

internal/store/post.go

@@ -1,488 +0,0 @@
-package store
-
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"fmt"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgconn"
-
-	"plumber/internal/pacific"
-	"plumber/internal/store/sqlc"
-)
-
-var (
-	ErrInvalidPost    = errors.New("invalid post")
-	ErrPostNotVotable = errors.New("post not votable")
-)
-
-type PostState string
-
-const (
-	PostStateVisible PostState = "visible"
-	PostStateHidden  PostState = "hidden"
-	PostStateLocked  PostState = "locked"
-)
-
-// Post is either a root question (ParentID nil) or a reply to another post.
-type Post struct {
-	ID         string
-	ParentID   *string
-	AuthorID   string
-	AuthorName string
-	AuthorRole Role
-	Title      string
-	Body       string
-	City       string
-	PostDate   string
-	PostState  PostState
-	CreatedAt  string
-	UpdatedAt  string
-	Score      int
-	Answered   bool
-	UserVote   int
-	Replies    []*Post
-	db         *sql.DB
-}
-
-// NewPost returns a post bound to db.
-func NewPost(db *sql.DB) *Post {
-	return &Post{db: db}
-}
-
-// Create inserts a root post or reply according to ParentID.
-func (p *Post) Create(ctx context.Context) error {
-	if p == nil || p.db == nil {
-		return fmt.Errorf("post: no database")
-	}
-	if err := preparePost(p); err != nil {
-		return err
-	}
-	err := sqlc.New(p.db).CreatePost(ctx, sqlc.CreatePostParams{
-		ID:        p.ID,
-		ParentID:  nullableParentID(p.ParentID),
-		AuthorID:  p.AuthorID,
-		Title:     p.Title,
-		Body:      p.Body,
-		City:      p.City,
-		PostDate:  p.PostDate,
-		PostState: string(p.PostState),
-		CreatedAt: p.CreatedAt,
-		UpdatedAt: p.UpdatedAt,
-	})
-	return mapPostCreateError(err)
-}
-
-// Update changes only the post body and update timestamp.
-func (p *Post) Update(ctx context.Context) error {
-	if p == nil || p.db == nil {
-		return fmt.Errorf("post: no database")
-	}
-	p.Body = strings.TrimSpace(p.Body)
-	if p.Body == "" {
-		return fmt.Errorf("%w: body is required", ErrInvalidPost)
-	}
-	p.UpdatedAt = time.Now().UTC().Format(time.RFC3339Nano)
-	n, err := sqlc.New(p.db).UpdatePost(ctx, sqlc.UpdatePostParams{
-		ID:        p.ID,
-		Body:      p.Body,
-		UpdatedAt: p.UpdatedAt,
-	})
-	if err != nil {
-		return err
-	}
-	if n == 0 {
-		return sql.ErrNoRows
-	}
-	return nil
-}
-
-func preparePost(p *Post) error {
-	p.ID = strings.TrimSpace(p.ID)
-	p.AuthorID = strings.TrimSpace(p.AuthorID)
-	p.Title = strings.TrimSpace(p.Title)
-	p.Body = strings.TrimSpace(p.Body)
-	p.City = strings.TrimSpace(p.City)
-	p.PostDate = strings.TrimSpace(p.PostDate)
-	if p.PostState == "" {
-		p.PostState = PostStateVisible
-	}
-	switch p.PostState {
-	case PostStateVisible, PostStateHidden, PostStateLocked:
-	default:
-		return fmt.Errorf("%w: invalid post state", ErrInvalidPost)
-	}
-	if p.AuthorID == "" {
-		return fmt.Errorf("%w: author is required", ErrInvalidPost)
-	}
-	if p.Body == "" {
-		return fmt.Errorf("%w: body is required", ErrInvalidPost)
-	}
-	if p.ParentID == nil {
-		if p.Title == "" {
-			return fmt.Errorf("%w: root title is required", ErrInvalidPost)
-		}
-		if p.PostDate == "" {
-			p.PostDate = pacific.Today()
-		}
-	} else {
-		parentID := strings.TrimSpace(*p.ParentID)
-		if parentID == "" {
-			return fmt.Errorf("%w: parent is required", ErrInvalidPost)
-		}
-		p.ParentID = &parentID
-		if p.Title != "" || p.City != "" || p.PostDate != "" || p.PostState != PostStateVisible {
-			return fmt.Errorf("%w: reply contains root-only fields", ErrInvalidPost)
-		}
-	}
-	if p.ID == "" {
-		p.ID = uuid.NewString()
-	}
-	now := time.Now().UTC().Format(time.RFC3339Nano)
-	if p.CreatedAt == "" {
-		p.CreatedAt = now
-	}
-	if p.UpdatedAt == "" {
-		p.UpdatedAt = p.CreatedAt
-	}
-	return nil
-}
-
-func nullableParentID(parentID *string) sql.NullString {
-	if parentID == nil {
-		return sql.NullString{}
-	}
-	return sql.NullString{String: *parentID, Valid: true}
-}
-
-func parentIDFromNull(parentID sql.NullString) *string {
-	if !parentID.Valid {
-		return nil
-	}
-	id := parentID.String
-	return &id
-}
-
-func mapPostCreateError(err error) error {
-	if err == nil {
-		return nil
-	}
-	var pgErr *pgconn.PgError
-	if errors.As(err, &pgErr) {
-		switch pgErr.Code {
-		case "23503", "23505", "23514":
-			return fmt.Errorf("%w: %v", ErrInvalidPost, err)
-		}
-	}
-	return err
-}
-
-func postFromValues(
-	db *sql.DB,
-	id string,
-	parentID sql.NullString,
-	authorID, authorName, authorRole, title, body, city, postDate string,
-	postState string,
-	createdAt, updatedAt string,
-) Post {
-	return Post{
-		ID:         id,
-		ParentID:   parentIDFromNull(parentID),
-		AuthorID:   authorID,
-		AuthorName: authorName,
-		AuthorRole: Role(authorRole),
-		Title:      title,
-		Body:       body,
-		City:       city,
-		PostDate:   postDate,
-		PostState:  PostState(postState),
-		CreatedAt:  createdAt,
-		UpdatedAt:  updatedAt,
-		db:         db,
-	}
-}
-
-// GetPost returns one post without loading its replies.
-func GetPost(ctx context.Context, db *sql.DB, id string) (*Post, error) {
-	r, err := sqlc.New(db).GetPost(ctx, id)
-	if err != nil {
-		return nil, err
-	}
-	p := postFromValues(
-		db,
-		r.ID,
-		r.ParentID,
-		r.AuthorID,
-		r.AuthorName,
-		r.AuthorRole,
-		r.Title,
-		r.Body,
-		r.City,
-		r.PostDate,
-		r.PostState,
-		r.CreatedAt,
-		r.UpdatedAt,
-	)
-	return &p, nil
-}
-
-// GetPostThread returns a root post with all descendants nested under Replies.
-func GetPostThread(ctx context.Context, db *sql.DB, rootID string) (*Post, error) {
-	rows, err := sqlc.New(db).ListPostThread(ctx, rootID)
-	if err != nil {
-		return nil, err
-	}
-	posts := make([]Post, 0, len(rows))
-	for _, r := range rows {
-		posts = append(posts, postFromValues(
-			db,
-			r.ID,
-			r.ParentID,
-			r.AuthorID,
-			r.AuthorName,
-			r.AuthorRole,
-			r.Title,
-			r.Body,
-			r.City,
-			r.PostDate,
-			r.PostState,
-			r.CreatedAt,
-			r.UpdatedAt,
-		))
-	}
-	return buildPostTree(posts, rootID)
-}
-
-// GetPostThreadForViewer includes root voting and answered annotations.
-func GetPostThreadForViewer(
-	ctx context.Context,
-	db *sql.DB,
-	rootID string,
-	viewerID string,
-) (*Post, error) {
-	root, err := GetPostThread(ctx, db, rootID)
-	if err != nil {
-		return nil, err
-	}
-	summary, err := sqlc.New(db).GetRootPostVoteSummary(ctx, sqlc.GetRootPostVoteSummaryParams{
-		ViewerID: viewerID,
-		RootID:   rootID,
-	})
-	if err != nil {
-		return nil, err
-	}
-	root.Score = int(summary.Score)
-	root.UserVote = int(summary.UserVote)
-	root.Answered = postTreeContainsRole(root, RoleAdmin)
-	return root, nil
-}
-
-func postTreeContainsRole(post *Post, role Role) bool {
-	for _, reply := range post.Replies {
-		if reply.AuthorRole == role || postTreeContainsRole(reply, role) {
-			return true
-		}
-	}
-	return false
-}
-
-func buildPostTree(posts []Post, rootID string) (*Post, error) {
-	byID := make(map[string]*Post, len(posts))
-	for i := range posts {
-		posts[i].Replies = nil
-		byID[posts[i].ID] = &posts[i]
-	}
-	root, ok := byID[rootID]
-	if !ok || root.ParentID != nil {
-		return nil, sql.ErrNoRows
-	}
-	for i := range posts {
-		post := &posts[i]
-		if post.ID == rootID {
-			continue
-		}
-		if post.ParentID == nil {
-			return nil, fmt.Errorf("post %s is not in thread %s", post.ID, rootID)
-		}
-		parent, ok := byID[*post.ParentID]
-		if !ok {
-			return nil, fmt.Errorf("post %s has missing parent %s", post.ID, *post.ParentID)
-		}
-		parent.Replies = append(parent.Replies, post)
-	}
-	var sortReplies func(*Post)
-	sortReplies = func(post *Post) {
-		sort.Slice(post.Replies, func(i, j int) bool {
-			if post.Replies[i].CreatedAt != post.Replies[j].CreatedAt {
-				return post.Replies[i].CreatedAt < post.Replies[j].CreatedAt
-			}
-			return post.Replies[i].ID < post.Replies[j].ID
-		})
-		for _, reply := range post.Replies {
-			sortReplies(reply)
-		}
-	}
-	sortReplies(root)
-	return root, nil
-}
-
-// ListRootPosts returns visible root posts for a post date.
-func ListRootPosts(ctx context.Context, db *sql.DB, postDate, viewerID string) ([]Post, error) {
-	rows, err := sqlc.New(db).ListRootPosts(ctx, sqlc.ListRootPostsParams{
-		ViewerID:    viewerID,
-		RowLimit:    HuntListLimit,
-		PostDate:    postDate,
-		HiddenState: string(PostStateHidden),
-	})
-	if err != nil {
-		return nil, err
-	}
-	posts := make([]Post, 0, len(rows))
-	for _, r := range rows {
-		post := postFromValues(
-			db,
-			r.ID,
-			r.ParentID,
-			r.AuthorID,
-			r.AuthorName,
-			r.AuthorRole,
-			r.Title,
-			r.Body,
-			r.City,
-			r.PostDate,
-			r.PostState,
-			r.CreatedAt,
-			r.UpdatedAt,
-		)
-		post.Score = int(r.Score)
-		post.Answered = r.Answered
-		post.UserVote = int(r.UserVote)
-		posts = append(posts, post)
-	}
-	return posts, nil
-}
-
-// ListRootPostsByAuthor returns visible roots created by an author, newest first.
-func ListRootPostsByAuthor(ctx context.Context, db *sql.DB, authorID string) ([]Post, error) {
-	rows, err := sqlc.New(db).ListRootPostsByAuthor(ctx, sqlc.ListRootPostsByAuthorParams{
-		AuthorID:    authorID,
-		HiddenState: string(PostStateHidden),
-		RowLimit:    ProfileListLimit,
-	})
-	if err != nil {
-		return nil, err
-	}
-	posts := make([]Post, 0, len(rows))
-	for _, r := range rows {
-		posts = append(posts, postFromValues(
-			db,
-			r.ID,
-			r.ParentID,
-			r.AuthorID,
-			r.AuthorName,
-			r.AuthorRole,
-			r.Title,
-			r.Body,
-			r.City,
-			r.PostDate,
-			r.PostState,
-			r.CreatedAt,
-			r.UpdatedAt,
-		))
-	}
-	return posts, nil
-}
-
-// ListRootPostsAnsweredBy returns visible roots containing a reply by adminID.
-func ListRootPostsAnsweredBy(ctx context.Context, db *sql.DB, adminID string) ([]Post, error) {
-	rows, err := sqlc.New(db).ListRootPostsAnsweredBy(ctx, sqlc.ListRootPostsAnsweredByParams{
-		HiddenState: string(PostStateHidden),
-		AdminID:     adminID,
-		RowLimit:    ProfileListLimit,
-	})
-	if err != nil {
-		return nil, err
-	}
-	posts := make([]Post, 0, len(rows))
-	for _, r := range rows {
-		posts = append(posts, postFromValues(
-			db,
-			r.ID,
-			r.ParentID,
-			r.AuthorID,
-			r.AuthorName,
-			r.AuthorRole,
-			r.Title,
-			r.Body,
-			r.City,
-			r.PostDate,
-			r.PostState,
-			r.CreatedAt,
-			r.UpdatedAt,
-		))
-	}
-	return posts, nil
-}
-
-// SetRootPostState changes a root post's state.
-func SetRootPostState(ctx context.Context, db *sql.DB, id string, state PostState) error {
-	switch state {
-	case PostStateVisible, PostStateHidden, PostStateLocked:
-	default:
-		return fmt.Errorf("%w: invalid post state", ErrInvalidPost)
-	}
-	n, err := sqlc.New(db).UpdateRootPostState(ctx, sqlc.UpdateRootPostStateParams{
-		PostState: string(state),
-		UpdatedAt: time.Now().UTC().Format(time.RFC3339Nano),
-		ID:        id,
-	})
-	if err != nil {
-		return err
-	}
-	if n == 0 {
-		return sql.ErrNoRows
-	}
-	return nil
-}
-
-// SetPostVote sets value to 1, -1, or 0 on a visible root post.
-func SetPostVote(ctx context.Context, db *sql.DB, userID, postID string, value int) error {
-	if value != 1 && value != -1 && value != 0 {
-		return fmt.Errorf("invalid vote")
-	}
-	q := sqlc.New(db)
-	if value == 0 {
-		visible, err := q.PostIsVisibleRoot(ctx, sqlc.PostIsVisibleRootParams{
-			ID:          postID,
-			HiddenState: string(PostStateHidden),
-		})
-		if err != nil {
-			return err
-		}
-		if !visible {
-			return ErrPostNotVotable
-		}
-		return q.DeletePostVote(ctx, sqlc.DeletePostVoteParams{
-			UserID: userID,
-			PostID: postID,
-		})
-	}
-	n, err := q.UpsertPostVoteOnVisibleRoot(ctx, sqlc.UpsertPostVoteOnVisibleRootParams{
-		UserID:      userID,
-		PostID:      postID,
-		Value:       int32(value),
-		HiddenState: string(PostStateHidden),
-	})
-	if err != nil {
-		return err
-	}
-	if n == 0 {
-		return ErrPostNotVotable
-	}
-	return nil
-}

internal/store/post_test.go

@@ -1,272 +0,0 @@
-package store
-
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"testing"
-
-	"github.com/jackc/pgx/v5/pgconn"
-)
-
-func TestMapPostCreateError(t *testing.T) {
-	t.Parallel()
-
-	for _, code := range []string{"23503", "23505", "23514"} {
-		err := mapPostCreateError(&pgconn.PgError{Code: code})
-		if !errors.Is(err, ErrInvalidPost) {
-			t.Errorf("code %s error = %v, want ErrInvalidPost", code, err)
-		}
-	}
-	original := &pgconn.PgError{Code: "08006"}
-	if err := mapPostCreateError(original); !errors.Is(err, original) {
-		t.Errorf("unexpected database error was replaced: %v", err)
-	}
-}
-
-func TestMemoryPostLifecycle(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	mem := NewMemory()
-	homeowner := &User{Username: "homeowner", PasswordHash: "hash", Role: RoleUser}
-	plumber := &User{Username: "plumber", PasswordHash: "hash", Role: RoleAdmin}
-	voter := &User{Username: "voter", PasswordHash: "hash", Role: RoleUser}
-	for _, user := range []*User{homeowner, plumber, voter} {
-		if err := mem.CreateUser(ctx, user); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	root := &Post{
-		ID:        "root",
-		AuthorID:  homeowner.ID,
-		Title:     "Leaky sink",
-		Body:      "It drips.",
-		City:      "Oakland",
-		PostDate:  "2026-08-26",
-		CreatedAt: "2026-08-26T08:00:00Z",
-	}
-	if err := mem.CreatePost(ctx, root); err != nil {
-		t.Fatal(err)
-	}
-	if root.PostState != PostStateVisible {
-		t.Fatalf("default post state = %q, want visible", root.PostState)
-	}
-
-	rootID := root.ID
-	later := &Post{
-		ID:        "later",
-		ParentID:  &rootID,
-		AuthorID:  plumber.ID,
-		Body:      "Is it a single-handle faucet?",
-		CreatedAt: "2026-08-26T09:00:00Z",
-	}
-	earlier := &Post{
-		ID:        "earlier",
-		ParentID:  &rootID,
-		AuthorID:  plumber.ID,
-		Body:      "Can you share the model number?",
-		CreatedAt: "2026-08-26T08:30:00Z",
-	}
-	if err := mem.CreatePost(ctx, later); err != nil {
-		t.Fatal(err)
-	}
-	if err := mem.CreatePost(ctx, earlier); err != nil {
-		t.Fatal(err)
-	}
-
-	laterID := later.ID
-	nested := &Post{
-		ID:        "nested",
-		ParentID:  &laterID,
-		AuthorID:  homeowner.ID,
-		Body:      "Yes, it is.",
-		CreatedAt: "2026-08-26T09:30:00Z",
-	}
-	if err := mem.CreatePost(ctx, nested); err != nil {
-		t.Fatal(err)
-	}
-
-	thread, err := mem.GetPostThread(ctx, root.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if thread.AuthorName != homeowner.Name || thread.AuthorRole != RoleUser {
-		t.Fatalf("root author = %q %q", thread.AuthorName, thread.AuthorRole)
-	}
-	if len(thread.Replies) != 2 ||
-		thread.Replies[0].ID != earlier.ID ||
-		thread.Replies[1].ID != later.ID {
-		t.Fatalf("root replies are not oldest-first: %+v", thread.Replies)
-	}
-	if len(thread.Replies[1].Replies) != 1 || thread.Replies[1].Replies[0].ID != nested.ID {
-		t.Fatalf("nested reply missing: %+v", thread.Replies[1].Replies)
-	}
-
-	otherParent := earlier.ID
-	nested.ParentID = &otherParent
-	nested.AuthorID = voter.ID
-	nested.Body = "Yes—one handle."
-	if err := mem.UpdatePost(ctx, nested); err != nil {
-		t.Fatal(err)
-	}
-	saved, err := mem.GetPost(ctx, nested.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if saved.ParentID == nil || *saved.ParentID != later.ID {
-		t.Fatalf("update changed parent to %+v", saved.ParentID)
-	}
-	if saved.AuthorID != homeowner.ID {
-		t.Fatalf("update changed author to %q", saved.AuthorID)
-	}
-	if saved.Body != "Yes—one handle." || saved.UpdatedAt == saved.CreatedAt {
-		t.Fatalf("body update not applied: %+v", saved)
-	}
-
-	if err := mem.VotePost(ctx, voter.ID, root.ID, 1); err != nil {
-		t.Fatal(err)
-	}
-	roots, err := mem.ListRootPosts(ctx, root.PostDate, voter.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(roots) != 1 || roots[0].ID != root.ID {
-		t.Fatalf("root list = %+v", roots)
-	}
-	if roots[0].Score != 1 || roots[0].UserVote != 1 || !roots[0].Answered {
-		t.Fatalf("root annotations = %+v", roots[0])
-	}
-	if err := mem.VotePost(ctx, voter.ID, later.ID, 1); !errors.Is(err, ErrPostNotVotable) {
-		t.Fatalf("reply vote error = %v", err)
-	}
-	byAuthor, err := mem.ListRootPostsByAuthor(ctx, homeowner.ID)
-	if err != nil || len(byAuthor) != 1 || byAuthor[0].ID != root.ID {
-		t.Fatalf("roots by author = %+v, %v", byAuthor, err)
-	}
-	answeredBy, err := mem.ListRootPostsAnsweredBy(ctx, plumber.ID)
-	if err != nil || len(answeredBy) != 1 || answeredBy[0].ID != root.ID {
-		t.Fatalf("roots answered by admin = %+v, %v", answeredBy, err)
-	}
-	if err := mem.SetRootPostState(ctx, later.ID, PostStateHidden); !errors.Is(err, sql.ErrNoRows) {
-		t.Fatalf("reply state error = %v, want sql.ErrNoRows", err)
-	}
-	if err := mem.SetRootPostState(ctx, root.ID, PostStateHidden); err != nil {
-		t.Fatal(err)
-	}
-	if roots, err := mem.ListRootPostsByAuthor(ctx, homeowner.ID); err != nil || len(roots) != 0 {
-		t.Fatalf("hidden author roots = %+v, %v", roots, err)
-	}
-	if roots, err := mem.ListRootPostsAnsweredBy(ctx, plumber.ID); err != nil || len(roots) != 0 {
-		t.Fatalf("hidden answered roots = %+v, %v", roots, err)
-	}
-}
-
-func TestMemoryPostValidation(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	mem := NewMemory()
-	homeowner := &User{Username: "homeowner", PasswordHash: "hash", Role: RoleUser}
-	if err := mem.CreateUser(ctx, homeowner); err != nil {
-		t.Fatal(err)
-	}
-
-	tests := []struct {
-		name string
-		post *Post
-	}{
-		{
-			name: "root without title",
-			post: &Post{AuthorID: homeowner.ID, Body: "Body"},
-		},
-		{
-			name: "empty parent",
-			post: &Post{ParentID: ptr(""), AuthorID: homeowner.ID, Body: "Body"},
-		},
-		{
-			name: "missing parent",
-			post: &Post{ParentID: ptr("missing"), AuthorID: homeowner.ID, Body: "Body"},
-		},
-		{
-			name: "reply with root fields",
-			post: &Post{
-				ParentID: ptr("missing"),
-				AuthorID: homeowner.ID,
-				Title:    "Not allowed",
-				Body:     "Body",
-			},
-		},
-		{
-			name: "invalid post state",
-			post: &Post{
-				AuthorID:  homeowner.ID,
-				Title:     "Invalid state",
-				Body:      "Body",
-				PostState: PostState("archived"),
-			},
-		},
-		{
-			name: "reply with non-visible state",
-			post: &Post{
-				ParentID:  ptr("missing"),
-				AuthorID:  homeowner.ID,
-				Body:      "Body",
-				PostState: PostStateLocked,
-			},
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			if err := mem.CreatePost(ctx, test.post); !errors.Is(err, ErrInvalidPost) {
-				t.Fatalf("error = %v, want ErrInvalidPost", err)
-			}
-		})
-	}
-
-	hidden := &Post{
-		ID:        "hidden",
-		AuthorID:  homeowner.ID,
-		Title:     "Hidden",
-		Body:      "Body",
-		PostDate:  "2026-08-26",
-		PostState: PostStateHidden,
-	}
-	if err := mem.CreatePost(ctx, hidden); err != nil {
-		t.Fatal(err)
-	}
-	if err := mem.VotePost(ctx, homeowner.ID, hidden.ID, 1); !errors.Is(err, ErrPostNotVotable) {
-		t.Fatalf("hidden root vote error = %v", err)
-	}
-
-	locked := &Post{
-		ID:        "locked",
-		AuthorID:  homeowner.ID,
-		Title:     "Locked",
-		Body:      "Body",
-		PostDate:  "2026-08-26",
-		PostState: PostStateLocked,
-	}
-	if err := mem.CreatePost(ctx, locked); err != nil {
-		t.Fatal(err)
-	}
-	if err := mem.VotePost(ctx, homeowner.ID, locked.ID, 1); err != nil {
-		t.Fatalf("locked root should remain votable: %v", err)
-	}
-	roots, err := mem.ListRootPosts(ctx, locked.PostDate, homeowner.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(roots) != 1 || roots[0].ID != locked.ID || roots[0].PostState != PostStateLocked {
-		t.Fatalf("locked root should remain visible: %+v", roots)
-	}
-
-	if _, err := mem.GetPostThread(ctx, "missing"); !errors.Is(err, sql.ErrNoRows) {
-		t.Fatalf("missing thread error = %v", err)
-	}
-}
-
-func ptr(value string) *string {
-	return &value
-}

internal/store/postgres_store.go

@@ -29,7 +29,6 @@ func (p *Postgres) CreateUser(ctx context.Context, u *User) error {
 		return fmt.Errorf("invalid role")
 	}
 	u.Username = NormalizeUsername(u.Username)
-	u.Email = NormalizeEmail(u.Email)
 	if u.ID == "" {
 		u.ID = uuid.NewString()
 	}
@@ -70,7 +69,6 @@ func (p *Postgres) CreateUser(ctx context.Context, u *User) error {
 		Name:         u.Name,
 		PasswordHash: u.PasswordHash,
 		Role:         string(role),
-		Email:        u.Email,
 		CreatedAt:    u.CreatedAt,
 	}); err != nil {
 		return mapUniqueViolation(err)
@@ -109,44 +107,41 @@ func (p *Postgres) SaveUserProfile(ctx context.Context, u *User) error {
 	return u.SaveProfile(ctx)
 }
 
-func (p *Postgres) CreatePost(ctx context.Context, post *Post) error {
-	post.db = p.db
-	return post.Create(ctx)
+func (p *Postgres) CreateQuestion(ctx context.Context, q *RankedQuestion) error {
+	q.db = p.db
+	return q.Create(ctx)
 }
 
-func (p *Postgres) GetPost(ctx context.Context, id string) (*Post, error) {
-	return GetPost(ctx, p.db, id)
+func (p *Postgres) GetQuestion(ctx context.Context, id, viewerID string) (*RankedQuestion, error) {
+	return GetQuestion(ctx, p.db, id, viewerID)
 }
 
-func (p *Postgres) GetPostThread(ctx context.Context, rootID string) (*Post, error) {
-	return GetPostThread(ctx, p.db, rootID)
+func (p *Postgres) ListHunt(ctx context.Context, huntDate, viewerID string) ([]RankedQuestion, error) {
+	return ListHunt(ctx, p.db, huntDate, viewerID)
 }
 
-func (p *Postgres) GetPostThreadForViewer(ctx context.Context, rootID, viewerID string) (*Post, error) {
-	return GetPostThreadForViewer(ctx, p.db, rootID, viewerID)
+func (p *Postgres) ListQuestionsByAuthor(ctx context.Context, authorID string) ([]RankedQuestion, error) {
+	return ListQuestionsByAuthor(ctx, p.db, authorID)
 }
 
-func (p *Postgres) UpdatePost(ctx context.Context, post *Post) error {
-	post.db = p.db
-	return post.Update(ctx)
+func (p *Postgres) ListQuestionsAnsweredBy(ctx context.Context, adminID string) ([]RankedQuestion, error) {
+	return ListQuestionsAnsweredBy(ctx, p.db, adminID)
 }
 
-func (p *Postgres) ListRootPosts(ctx context.Context, postDate, viewerID string) ([]Post, error) {
-	return ListRootPosts(ctx, p.db, postDate, viewerID)
+func (p *Postgres) HideQuestion(ctx context.Context, id string) error {
+	q := &RankedQuestion{ID: id, db: p.db}
+	return q.Hide(ctx)
 }
 
-func (p *Postgres) ListRootPostsByAuthor(ctx context.Context, authorID string) ([]Post, error) {
-	return ListRootPostsByAuthor(ctx, p.db, authorID)
+func (p *Postgres) GetAnswer(ctx context.Context, questionID string) (*Answer, error) {
+	return GetAnswer(ctx, p.db, questionID)
 }
 
-func (p *Postgres) ListRootPostsAnsweredBy(ctx context.Context, adminID string) ([]Post, error) {
-	return ListRootPostsAnsweredBy(ctx, p.db, adminID)
+func (p *Postgres) UpsertAnswer(ctx context.Context, a *Answer) error {
+	a.db = p.db
+	return a.Upsert(ctx)
 }
 
-func (p *Postgres) SetRootPostState(ctx context.Context, id string, state PostState) error {
-	return SetRootPostState(ctx, p.db, id, state)
-}
-
-func (p *Postgres) VotePost(ctx context.Context, userID, postID string, value int) error {
-	return SetPostVote(ctx, p.db, userID, postID, value)
+func (p *Postgres) Vote(ctx context.Context, userID, questionID string, value int) error {
+	return Vote(ctx, p.db, userID, questionID, value)
 }

internal/store/question.go

@@ -0,0 +1,156 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/google/uuid"
+
+	"plumber/internal/pacific"
+	"plumber/internal/store/sqlc"
+)
+
+// RankedQuestion is a question row with score / vote annotations for lists.
+type RankedQuestion struct {
+	ID         string
+	AuthorID   string
+	AuthorName string
+	Title      string
+	Body       string
+	City       string
+	HuntDate   string
+	Hidden     bool
+	CreatedAt  string
+	Score      int
+	Answered   bool
+	UserVote   int
+	db         *sql.DB
+}
+
+// NewQuestion returns a question bound to db (not yet inserted).
+func NewQuestion(db *sql.DB) *RankedQuestion {
+	return &RankedQuestion{db: db}
+}
+
+// Create inserts the question. Sets ID, HuntDate, and CreatedAt when empty.
+func (q *RankedQuestion) Create(ctx context.Context) error {
+	if q == nil || q.db == nil {
+		return fmt.Errorf("question: no database")
+	}
+	q.Title = strings.TrimSpace(q.Title)
+	q.Body = strings.TrimSpace(q.Body)
+	q.City = strings.TrimSpace(q.City)
+	if q.ID == "" {
+		q.ID = uuid.NewString()
+	}
+	if q.HuntDate == "" {
+		q.HuntDate = pacific.Today()
+	}
+	if q.CreatedAt == "" {
+		q.CreatedAt = time.Now().UTC().Format(time.RFC3339)
+	}
+	return sqlc.New(q.db).CreateQuestion(ctx, sqlc.CreateQuestionParams{
+		ID:        q.ID,
+		AuthorID:  q.AuthorID,
+		Title:     q.Title,
+		Body:      q.Body,
+		City:      q.City,
+		HuntDate:  q.HuntDate,
+		CreatedAt: q.CreatedAt,
+	})
+}
+
+// Hide marks the question hidden.
+func (q *RankedQuestion) Hide(ctx context.Context) error {
+	if q == nil || q.db == nil {
+		return fmt.Errorf("question: no database")
+	}
+	if err := sqlc.New(q.db).HideQuestion(ctx, q.ID); err != nil {
+		return err
+	}
+	q.Hidden = true
+	return nil
+}
+
+func rankedFrom(
+	db *sql.DB,
+	id, authorID, authorName, title, body, city, huntDate, createdAt string,
+	hidden int32, score, answered, userVote int64,
+) RankedQuestion {
+	return RankedQuestion{
+		ID:         id,
+		AuthorID:   authorID,
+		AuthorName: authorName,
+		Title:      title,
+		Body:       body,
+		City:       city,
+		HuntDate:   huntDate,
+		Hidden:     hidden != 0,
+		CreatedAt:  createdAt,
+		Score:      int(score),
+		Answered:   answered != 0,
+		UserVote:   int(userVote),
+		db:         db,
+	}
+}
+
+func ListHunt(ctx context.Context, db *sql.DB, huntDate, viewerID string) ([]RankedQuestion, error) {
+	rows, err := sqlc.New(db).ListHunt(ctx, sqlc.ListHuntParams{
+		ViewerID: viewerID,
+		HuntDate: huntDate,
+		RowLimit: HuntListLimit,
+	})
+	if err != nil {
+		return nil, err
+	}
+	out := make([]RankedQuestion, 0, len(rows))
+	for _, r := range rows {
+		out = append(out, rankedFrom(db, r.ID, r.AuthorID, r.AuthorName, r.Title, r.Body, r.City, r.HuntDate, r.CreatedAt, r.Hidden, r.Score, r.Answered, r.UserVote))
+	}
+	return out, nil
+}
+
+func GetQuestion(ctx context.Context, db *sql.DB, id, viewerID string) (*RankedQuestion, error) {
+	r, err := sqlc.New(db).GetQuestion(ctx, sqlc.GetQuestionParams{
+		ViewerID: viewerID,
+		ID:       id,
+	})
+	if err != nil {
+		return nil, err
+	}
+	q := rankedFrom(db, r.ID, r.AuthorID, r.AuthorName, r.Title, r.Body, r.City, r.HuntDate, r.CreatedAt, r.Hidden, r.Score, r.Answered, r.UserVote)
+	return &q, nil
+}
+
+func ListQuestionsByAuthor(ctx context.Context, db *sql.DB, authorID string) ([]RankedQuestion, error) {
+	rows, err := sqlc.New(db).ListQuestionsByAuthor(ctx, sqlc.ListQuestionsByAuthorParams{
+		AuthorID: authorID,
+		RowLimit: ProfileListLimit,
+	})
+	if err != nil {
+		return nil, err
+	}
+	out := make([]RankedQuestion, 0, len(rows))
+	for _, r := range rows {
+		out = append(out, rankedFrom(db, r.ID, r.AuthorID, r.AuthorName, r.Title, r.Body, r.City, r.HuntDate, r.CreatedAt, r.Hidden, r.Score, r.Answered, r.UserVote))
+	}
+	return out, nil
+}
+
+func ListQuestionsAnsweredBy(ctx context.Context, db *sql.DB, adminID string) ([]RankedQuestion, error) {
+	rows, err := sqlc.New(db).ListQuestionsAnsweredBy(ctx, sqlc.ListQuestionsAnsweredByParams{
+		AdminID:  adminID,
+		RowLimit: ProfileListLimit,
+	})
+	if err != nil {
+		return nil, err
+	}
+	out := make([]RankedQuestion, 0, len(rows))
+	for _, r := range rows {
+		out = append(out, rankedFrom(db, r.ID, r.AuthorID, r.AuthorName, r.Title, r.Body, r.City, r.HuntDate, r.CreatedAt, r.Hidden, r.Score, r.Answered, r.UserVote))
+	}
+	return out, nil
+}

internal/store/sqlc/answers.sql.go

@@ -0,0 +1,66 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.31.1
+// source: answers.sql
+
+package sqlc
+
+import (
+	"context"
+)
+
+const getAnswer = `-- name: GetAnswer :one
+SELECT a.question_id, a.author_id, u.name AS author_name, a.body, a.created_at, a.updated_at
+FROM answers a
+JOIN users u ON u.id = a.author_id
+WHERE a.question_id = $1
+`
+
+type GetAnswerRow struct {
+	QuestionID string
+	AuthorID   string
+	AuthorName string
+	Body       string
+	CreatedAt  string
+	UpdatedAt  string
+}
+
+func (q *Queries) GetAnswer(ctx context.Context, questionID string) (GetAnswerRow, error) {
+	row := q.db.QueryRowContext(ctx, getAnswer, questionID)
+	var i GetAnswerRow
+	err := row.Scan(
+		&i.QuestionID,
+		&i.AuthorID,
+		&i.AuthorName,
+		&i.Body,
+		&i.CreatedAt,
+		&i.UpdatedAt,
+	)
+	return i, err
+}
+
+const upsertAnswer = `-- name: UpsertAnswer :exec
+INSERT INTO answers (question_id, author_id, body, created_at, updated_at)
+VALUES ($1, $2, $3, $4, $5)
+ON CONFLICT (question_id) DO UPDATE
+SET body = excluded.body, author_id = excluded.author_id, updated_at = excluded.updated_at
+`
+
+type UpsertAnswerParams struct {
+	QuestionID string
+	AuthorID   string
+	Body       string
+	CreatedAt  string
+	UpdatedAt  string
+}
+
+func (q *Queries) UpsertAnswer(ctx context.Context, arg UpsertAnswerParams) error {
+	_, err := q.db.ExecContext(ctx, upsertAnswer,
+		arg.QuestionID,
+		arg.AuthorID,
+		arg.Body,
+		arg.CreatedAt,
+		arg.UpdatedAt,
+	)
+	return err
+}

internal/store/sqlc/models.go

@@ -5,27 +5,26 @@
 package sqlc
 
 import (
-	"database/sql"
 	"time"
 )
 
-type Post struct {
+type Answer struct {
+	QuestionID string
+	AuthorID   string
+	Body       string
+	CreatedAt  string
+	UpdatedAt  string
+}
+
+type Question struct {
 	ID        string
-	ParentID  sql.NullString
 	AuthorID  string
 	Title     string
 	Body      string
 	City      string
-	PostDate  string
-	PostState string
+	HuntDate  string
+	Hidden    int32
 	CreatedAt string
-	UpdatedAt string
-}
-
-type PostVote struct {
-	UserID string
-	PostID string
-	Value  int32
 }
 
 type Session struct {
@@ -40,8 +39,13 @@ type User struct {
 	Name         string
 	PasswordHash string
 	Role         string
-	Email        string
 	AvatarUrl    string
 	State        string
 	CreatedAt    string
 }
+
+type Vote struct {
+	UserID     string
+	QuestionID string
+	Value      int32
+}

internal/store/sqlc/posts.sql.go

@@ -1,592 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.31.1
-// source: posts.sql
-
-package sqlc
-
-import (
-	"context"
-	"database/sql"
-)
-
-const createPost = `-- name: CreatePost :exec
-INSERT INTO posts (
-  id, parent_id, author_id, title, body, city, post_date, post_state, created_at, updated_at
-)
-VALUES (
-  $1,
-  $2,
-  $3,
-  $4,
-  $5,
-  $6,
-  $7,
-  $8,
-  $9,
-  $10
-)
-`
-
-type CreatePostParams struct {
-	ID        string
-	ParentID  sql.NullString
-	AuthorID  string
-	Title     string
-	Body      string
-	City      string
-	PostDate  string
-	PostState string
-	CreatedAt string
-	UpdatedAt string
-}
-
-func (q *Queries) CreatePost(ctx context.Context, arg CreatePostParams) error {
-	_, err := q.db.ExecContext(ctx, createPost,
-		arg.ID,
-		arg.ParentID,
-		arg.AuthorID,
-		arg.Title,
-		arg.Body,
-		arg.City,
-		arg.PostDate,
-		arg.PostState,
-		arg.CreatedAt,
-		arg.UpdatedAt,
-	)
-	return err
-}
-
-const deletePostVote = `-- name: DeletePostVote :exec
-DELETE FROM post_votes
-WHERE user_id = $1
-  AND post_id = $2
-`
-
-type DeletePostVoteParams struct {
-	UserID string
-	PostID string
-}
-
-func (q *Queries) DeletePostVote(ctx context.Context, arg DeletePostVoteParams) error {
-	_, err := q.db.ExecContext(ctx, deletePostVote, arg.UserID, arg.PostID)
-	return err
-}
-
-const getPost = `-- name: GetPost :one
-SELECT
-  p.id, p.parent_id, p.author_id, u.name AS author_name, u.role AS author_role,
-  p.title, p.body, p.city, p.post_date, p.post_state, p.created_at, p.updated_at
-FROM posts p
-JOIN users u ON u.id = p.author_id
-WHERE p.id = $1
-`
-
-type GetPostRow struct {
-	ID         string
-	ParentID   sql.NullString
-	AuthorID   string
-	AuthorName string
-	AuthorRole string
-	Title      string
-	Body       string
-	City       string
-	PostDate   string
-	PostState  string
-	CreatedAt  string
-	UpdatedAt  string
-}
-
-func (q *Queries) GetPost(ctx context.Context, id string) (GetPostRow, error) {
-	row := q.db.QueryRowContext(ctx, getPost, id)
-	var i GetPostRow
-	err := row.Scan(
-		&i.ID,
-		&i.ParentID,
-		&i.AuthorID,
-		&i.AuthorName,
-		&i.AuthorRole,
-		&i.Title,
-		&i.Body,
-		&i.City,
-		&i.PostDate,
-		&i.PostState,
-		&i.CreatedAt,
-		&i.UpdatedAt,
-	)
-	return i, err
-}
-
-const getRootPostVoteSummary = `-- name: GetRootPostVoteSummary :one
-SELECT
-  COALESCE(SUM(value), 0)::bigint AS score,
-  COALESCE(
-    MAX(value) FILTER (WHERE user_id = $1),
-    0
-  )::bigint AS user_vote
-FROM post_votes
-WHERE post_id = $2
-`
-
-type GetRootPostVoteSummaryParams struct {
-	ViewerID string
-	RootID   string
-}
-
-type GetRootPostVoteSummaryRow struct {
-	Score    int64
-	UserVote int64
-}
-
-func (q *Queries) GetRootPostVoteSummary(ctx context.Context, arg GetRootPostVoteSummaryParams) (GetRootPostVoteSummaryRow, error) {
-	row := q.db.QueryRowContext(ctx, getRootPostVoteSummary, arg.ViewerID, arg.RootID)
-	var i GetRootPostVoteSummaryRow
-	err := row.Scan(&i.Score, &i.UserVote)
-	return i, err
-}
-
-const listPostThread = `-- name: ListPostThread :many
-WITH RECURSIVE thread AS (
-  SELECT p.id, p.parent_id, p.author_id, p.title, p.body, p.city, p.post_date, p.post_state, p.created_at, p.updated_at
-  FROM posts p
-  WHERE p.id = $1 AND p.parent_id IS NULL
-
-  UNION ALL
-
-  SELECT child.id, child.parent_id, child.author_id, child.title, child.body, child.city, child.post_date, child.post_state, child.created_at, child.updated_at
-  FROM posts child
-  JOIN thread parent ON child.parent_id = parent.id
-)
-SELECT
-  thread.id, thread.parent_id, thread.author_id,
-  u.name AS author_name, u.role AS author_role,
-  thread.title, thread.body, thread.city, thread.post_date,
-  thread.post_state, thread.created_at, thread.updated_at
-FROM thread
-JOIN users u ON u.id = thread.author_id
-ORDER BY thread.created_at, thread.id
-`
-
-type ListPostThreadRow struct {
-	ID         string
-	ParentID   sql.NullString
-	AuthorID   string
-	AuthorName string
-	AuthorRole string
-	Title      string
-	Body       string
-	City       string
-	PostDate   string
-	PostState  string
-	CreatedAt  string
-	UpdatedAt  string
-}
-
-func (q *Queries) ListPostThread(ctx context.Context, rootID string) ([]ListPostThreadRow, error) {
-	rows, err := q.db.QueryContext(ctx, listPostThread, rootID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []ListPostThreadRow{}
-	for rows.Next() {
-		var i ListPostThreadRow
-		if err := rows.Scan(
-			&i.ID,
-			&i.ParentID,
-			&i.AuthorID,
-			&i.AuthorName,
-			&i.AuthorRole,
-			&i.Title,
-			&i.Body,
-			&i.City,
-			&i.PostDate,
-			&i.PostState,
-			&i.CreatedAt,
-			&i.UpdatedAt,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Close(); err != nil {
-		return nil, err
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const listRootPosts = `-- name: ListRootPosts :many
-WITH RECURSIVE roots AS (
-  SELECT p.id, p.parent_id, p.author_id, p.title, p.body, p.city, p.post_date, p.post_state, p.created_at, p.updated_at
-  FROM posts p
-  WHERE p.parent_id IS NULL
-    AND p.post_date = $3
-    AND p.post_state <> $4
-),
-thread AS (
-  SELECT roots.id AS root_id, child.id AS post_id, child.author_id
-  FROM roots
-  JOIN posts child ON child.parent_id = roots.id
-
-  UNION ALL
-
-  SELECT thread.root_id, child.id, child.author_id
-  FROM thread
-  JOIN posts child ON child.parent_id = thread.post_id
-),
-answered AS (
-  SELECT DISTINCT thread.root_id
-  FROM thread
-  JOIN users u ON u.id = thread.author_id
-  WHERE u.role = 'admin'
-),
-scores AS (
-  SELECT votes.post_id, SUM(votes.value)::bigint AS score
-  FROM roots
-  JOIN post_votes votes ON votes.post_id = roots.id
-  GROUP BY votes.post_id
-)
-SELECT
-  roots.id, roots.parent_id, roots.author_id,
-  u.name AS author_name, u.role AS author_role,
-  roots.title, roots.body, roots.city, roots.post_date,
-  roots.post_state, roots.created_at, roots.updated_at,
-  COALESCE(scores.score, 0)::bigint AS score,
-  (answered.root_id IS NOT NULL)::bool AS answered,
-  COALESCE(viewer_vote.value, 0)::bigint AS user_vote
-FROM roots
-JOIN users u ON u.id = roots.author_id
-LEFT JOIN scores ON scores.post_id = roots.id
-LEFT JOIN answered ON answered.root_id = roots.id
-LEFT JOIN post_votes viewer_vote
-  ON viewer_vote.user_id = $1
-  AND viewer_vote.post_id = roots.id
-ORDER BY score DESC, roots.created_at, roots.id
-LIMIT $2
-`
-
-type ListRootPostsParams struct {
-	ViewerID    string
-	RowLimit    int32
-	PostDate    string
-	HiddenState string
-}
-
-type ListRootPostsRow struct {
-	ID         string
-	ParentID   sql.NullString
-	AuthorID   string
-	AuthorName string
-	AuthorRole string
-	Title      string
-	Body       string
-	City       string
-	PostDate   string
-	PostState  string
-	CreatedAt  string
-	UpdatedAt  string
-	Score      int64
-	Answered   bool
-	UserVote   int64
-}
-
-func (q *Queries) ListRootPosts(ctx context.Context, arg ListRootPostsParams) ([]ListRootPostsRow, error) {
-	rows, err := q.db.QueryContext(ctx, listRootPosts,
-		arg.ViewerID,
-		arg.RowLimit,
-		arg.PostDate,
-		arg.HiddenState,
-	)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []ListRootPostsRow{}
-	for rows.Next() {
-		var i ListRootPostsRow
-		if err := rows.Scan(
-			&i.ID,
-			&i.ParentID,
-			&i.AuthorID,
-			&i.AuthorName,
-			&i.AuthorRole,
-			&i.Title,
-			&i.Body,
-			&i.City,
-			&i.PostDate,
-			&i.PostState,
-			&i.CreatedAt,
-			&i.UpdatedAt,
-			&i.Score,
-			&i.Answered,
-			&i.UserVote,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Close(); err != nil {
-		return nil, err
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const listRootPostsAnsweredBy = `-- name: ListRootPostsAnsweredBy :many
-WITH RECURSIVE ancestors AS (
-  SELECT p.id, p.parent_id
-  FROM posts p
-  WHERE p.author_id = $3
-    AND p.parent_id IS NOT NULL
-
-  UNION
-
-  SELECT parent.id, parent.parent_id
-  FROM posts parent
-  JOIN ancestors child ON child.parent_id = parent.id
-)
-SELECT DISTINCT
-  root.id, root.parent_id, root.author_id,
-  u.name AS author_name, u.role AS author_role,
-  root.title, root.body, root.city, root.post_date,
-  root.post_state, root.created_at, root.updated_at
-FROM posts root
-JOIN ancestors ON ancestors.id = root.id
-JOIN users u ON u.id = root.author_id
-WHERE root.parent_id IS NULL
-  AND root.post_state <> $1
-ORDER BY root.created_at DESC, root.id DESC
-LIMIT $2
-`
-
-type ListRootPostsAnsweredByParams struct {
-	HiddenState string
-	RowLimit    int32
-	AdminID     string
-}
-
-type ListRootPostsAnsweredByRow struct {
-	ID         string
-	ParentID   sql.NullString
-	AuthorID   string
-	AuthorName string
-	AuthorRole string
-	Title      string
-	Body       string
-	City       string
-	PostDate   string
-	PostState  string
-	CreatedAt  string
-	UpdatedAt  string
-}
-
-func (q *Queries) ListRootPostsAnsweredBy(ctx context.Context, arg ListRootPostsAnsweredByParams) ([]ListRootPostsAnsweredByRow, error) {
-	rows, err := q.db.QueryContext(ctx, listRootPostsAnsweredBy, arg.HiddenState, arg.RowLimit, arg.AdminID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []ListRootPostsAnsweredByRow{}
-	for rows.Next() {
-		var i ListRootPostsAnsweredByRow
-		if err := rows.Scan(
-			&i.ID,
-			&i.ParentID,
-			&i.AuthorID,
-			&i.AuthorName,
-			&i.AuthorRole,
-			&i.Title,
-			&i.Body,
-			&i.City,
-			&i.PostDate,
-			&i.PostState,
-			&i.CreatedAt,
-			&i.UpdatedAt,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Close(); err != nil {
-		return nil, err
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const listRootPostsByAuthor = `-- name: ListRootPostsByAuthor :many
-SELECT
-  p.id, p.parent_id, p.author_id,
-  u.name AS author_name, u.role AS author_role,
-  p.title, p.body, p.city, p.post_date,
-  p.post_state, p.created_at, p.updated_at
-FROM posts p
-JOIN users u ON u.id = p.author_id
-WHERE p.parent_id IS NULL
-  AND p.author_id = $1
-  AND p.post_state <> $2
-ORDER BY p.created_at DESC, p.id DESC
-LIMIT $3
-`
-
-type ListRootPostsByAuthorParams struct {
-	AuthorID    string
-	HiddenState string
-	RowLimit    int32
-}
-
-type ListRootPostsByAuthorRow struct {
-	ID         string
-	ParentID   sql.NullString
-	AuthorID   string
-	AuthorName string
-	AuthorRole string
-	Title      string
-	Body       string
-	City       string
-	PostDate   string
-	PostState  string
-	CreatedAt  string
-	UpdatedAt  string
-}
-
-func (q *Queries) ListRootPostsByAuthor(ctx context.Context, arg ListRootPostsByAuthorParams) ([]ListRootPostsByAuthorRow, error) {
-	rows, err := q.db.QueryContext(ctx, listRootPostsByAuthor, arg.AuthorID, arg.HiddenState, arg.RowLimit)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []ListRootPostsByAuthorRow{}
-	for rows.Next() {
-		var i ListRootPostsByAuthorRow
-		if err := rows.Scan(
-			&i.ID,
-			&i.ParentID,
-			&i.AuthorID,
-			&i.AuthorName,
-			&i.AuthorRole,
-			&i.Title,
-			&i.Body,
-			&i.City,
-			&i.PostDate,
-			&i.PostState,
-			&i.CreatedAt,
-			&i.UpdatedAt,
-		); err != nil {
-			return nil, err
-		}
-		items = append(items, i)
-	}
-	if err := rows.Close(); err != nil {
-		return nil, err
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const postIsVisibleRoot = `-- name: PostIsVisibleRoot :one
-SELECT EXISTS(
-  SELECT 1
-  FROM posts
-  WHERE id = $1
-    AND parent_id IS NULL
-    AND post_state <> $2
-)::bool
-`
-
-type PostIsVisibleRootParams struct {
-	ID          string
-	HiddenState string
-}
-
-func (q *Queries) PostIsVisibleRoot(ctx context.Context, arg PostIsVisibleRootParams) (bool, error) {
-	row := q.db.QueryRowContext(ctx, postIsVisibleRoot, arg.ID, arg.HiddenState)
-	var column_1 bool
-	err := row.Scan(&column_1)
-	return column_1, err
-}
-
-const updatePost = `-- name: UpdatePost :execrows
-UPDATE posts
-SET
-  body = $1,
-  updated_at = $2
-WHERE id = $3
-`
-
-type UpdatePostParams struct {
-	Body      string
-	UpdatedAt string
-	ID        string
-}
-
-func (q *Queries) UpdatePost(ctx context.Context, arg UpdatePostParams) (int64, error) {
-	result, err := q.db.ExecContext(ctx, updatePost, arg.Body, arg.UpdatedAt, arg.ID)
-	if err != nil {
-		return 0, err
-	}
-	return result.RowsAffected()
-}
-
-const updateRootPostState = `-- name: UpdateRootPostState :execrows
-UPDATE posts
-SET
-  post_state = $1,
-  updated_at = $2
-WHERE id = $3
-  AND parent_id IS NULL
-`
-
-type UpdateRootPostStateParams struct {
-	PostState string
-	UpdatedAt string
-	ID        string
-}
-
-func (q *Queries) UpdateRootPostState(ctx context.Context, arg UpdateRootPostStateParams) (int64, error) {
-	result, err := q.db.ExecContext(ctx, updateRootPostState, arg.PostState, arg.UpdatedAt, arg.ID)
-	if err != nil {
-		return 0, err
-	}
-	return result.RowsAffected()
-}
-
-const upsertPostVoteOnVisibleRoot = `-- name: UpsertPostVoteOnVisibleRoot :execrows
-INSERT INTO post_votes (user_id, post_id, value)
-SELECT $1, $2, $3
-FROM posts p
-WHERE p.id = $2
-  AND p.parent_id IS NULL
-  AND p.post_state <> $4
-ON CONFLICT (user_id, post_id) DO UPDATE
-SET value = excluded.value
-`
-
-type UpsertPostVoteOnVisibleRootParams struct {
-	UserID      string
-	PostID      string
-	Value       int32
-	HiddenState string
-}
-
-func (q *Queries) UpsertPostVoteOnVisibleRoot(ctx context.Context, arg UpsertPostVoteOnVisibleRootParams) (int64, error) {
-	result, err := q.db.ExecContext(ctx, upsertPostVoteOnVisibleRoot,
-		arg.UserID,
-		arg.PostID,
-		arg.Value,
-		arg.HiddenState,
-	)
-	if err != nil {
-		return 0, err
-	}
-	return result.RowsAffected()
-}

internal/store/sqlc/questions.sql.go

@@ -0,0 +1,316 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.31.1
+// source: questions.sql
+
+package sqlc
+
+import (
+	"context"
+)
+
+const createQuestion = `-- name: CreateQuestion :exec
+INSERT INTO questions (id, author_id, title, body, city, hunt_date, hidden, created_at)
+VALUES ($1, $2, $3, $4, $5, $6, 0, $7)
+`
+
+type CreateQuestionParams struct {
+	ID        string
+	AuthorID  string
+	Title     string
+	Body      string
+	City      string
+	HuntDate  string
+	CreatedAt string
+}
+
+func (q *Queries) CreateQuestion(ctx context.Context, arg CreateQuestionParams) error {
+	_, err := q.db.ExecContext(ctx, createQuestion,
+		arg.ID,
+		arg.AuthorID,
+		arg.Title,
+		arg.Body,
+		arg.City,
+		arg.HuntDate,
+		arg.CreatedAt,
+	)
+	return err
+}
+
+const getQuestion = `-- name: GetQuestion :one
+SELECT q.id, q.author_id, u.name AS author_name, q.title, q.body, q.city, q.hunt_date, q.hidden, q.created_at,
+       COALESCE((SELECT SUM(votes.value) FROM votes WHERE votes.question_id = q.id), 0)::bigint AS score,
+       CASE WHEN a.question_id IS NULL THEN 0 ELSE 1 END::bigint AS answered,
+       COALESCE((
+         SELECT votes.value FROM votes
+         WHERE votes.user_id = $1 AND votes.question_id = q.id
+       ), 0)::bigint AS user_vote
+FROM questions q
+JOIN users u ON u.id = q.author_id
+LEFT JOIN answers a ON a.question_id = q.id
+WHERE q.id = $2
+`
+
+type GetQuestionParams struct {
+	ViewerID string
+	ID       string
+}
+
+type GetQuestionRow struct {
+	ID         string
+	AuthorID   string
+	AuthorName string
+	Title      string
+	Body       string
+	City       string
+	HuntDate   string
+	Hidden     int32
+	CreatedAt  string
+	Score      int64
+	Answered   int64
+	UserVote   int64
+}
+
+func (q *Queries) GetQuestion(ctx context.Context, arg GetQuestionParams) (GetQuestionRow, error) {
+	row := q.db.QueryRowContext(ctx, getQuestion, arg.ViewerID, arg.ID)
+	var i GetQuestionRow
+	err := row.Scan(
+		&i.ID,
+		&i.AuthorID,
+		&i.AuthorName,
+		&i.Title,
+		&i.Body,
+		&i.City,
+		&i.HuntDate,
+		&i.Hidden,
+		&i.CreatedAt,
+		&i.Score,
+		&i.Answered,
+		&i.UserVote,
+	)
+	return i, err
+}
+
+const hideQuestion = `-- name: HideQuestion :exec
+UPDATE questions
+SET hidden = 1
+WHERE id = $1
+`
+
+func (q *Queries) HideQuestion(ctx context.Context, id string) error {
+	_, err := q.db.ExecContext(ctx, hideQuestion, id)
+	return err
+}
+
+const listHunt = `-- name: ListHunt :many
+SELECT q.id, q.author_id, u.name AS author_name, q.title, q.body, q.city, q.hunt_date, q.hidden, q.created_at,
+       COALESCE(SUM(v.value), 0)::bigint AS score,
+       CASE WHEN a.question_id IS NULL THEN 0 ELSE 1 END::bigint AS answered,
+       COALESCE((
+         SELECT votes.value FROM votes
+         WHERE votes.user_id = $1 AND votes.question_id = q.id
+       ), 0)::bigint AS user_vote
+FROM questions q
+JOIN users u ON u.id = q.author_id
+LEFT JOIN votes v ON v.question_id = q.id
+LEFT JOIN answers a ON a.question_id = q.id
+WHERE q.hunt_date = $2 AND q.hidden = 0
+GROUP BY q.id, q.author_id, u.name, q.title, q.body, q.city, q.hunt_date, q.hidden, q.created_at, a.question_id
+ORDER BY score DESC, q.created_at ASC
+LIMIT $3
+`
+
+type ListHuntParams struct {
+	ViewerID string
+	HuntDate string
+	RowLimit int32
+}
+
+type ListHuntRow struct {
+	ID         string
+	AuthorID   string
+	AuthorName string
+	Title      string
+	Body       string
+	City       string
+	HuntDate   string
+	Hidden     int32
+	CreatedAt  string
+	Score      int64
+	Answered   int64
+	UserVote   int64
+}
+
+func (q *Queries) ListHunt(ctx context.Context, arg ListHuntParams) ([]ListHuntRow, error) {
+	rows, err := q.db.QueryContext(ctx, listHunt, arg.ViewerID, arg.HuntDate, arg.RowLimit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListHuntRow{}
+	for rows.Next() {
+		var i ListHuntRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.AuthorID,
+			&i.AuthorName,
+			&i.Title,
+			&i.Body,
+			&i.City,
+			&i.HuntDate,
+			&i.Hidden,
+			&i.CreatedAt,
+			&i.Score,
+			&i.Answered,
+			&i.UserVote,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listQuestionsAnsweredBy = `-- name: ListQuestionsAnsweredBy :many
+SELECT q.id, q.author_id, u.name AS author_name, q.title, q.body, q.city, q.hunt_date, q.hidden, q.created_at,
+       COALESCE((SELECT SUM(votes.value) FROM votes WHERE votes.question_id = q.id), 0)::bigint AS score,
+       1::bigint AS answered,
+       0::bigint AS user_vote
+FROM answers ans
+JOIN questions q ON q.id = ans.question_id
+JOIN users u ON u.id = q.author_id
+WHERE ans.author_id = $1 AND q.hidden = 0
+ORDER BY ans.updated_at DESC
+LIMIT $2
+`
+
+type ListQuestionsAnsweredByParams struct {
+	AdminID  string
+	RowLimit int32
+}
+
+type ListQuestionsAnsweredByRow struct {
+	ID         string
+	AuthorID   string
+	AuthorName string
+	Title      string
+	Body       string
+	City       string
+	HuntDate   string
+	Hidden     int32
+	CreatedAt  string
+	Score      int64
+	Answered   int64
+	UserVote   int64
+}
+
+func (q *Queries) ListQuestionsAnsweredBy(ctx context.Context, arg ListQuestionsAnsweredByParams) ([]ListQuestionsAnsweredByRow, error) {
+	rows, err := q.db.QueryContext(ctx, listQuestionsAnsweredBy, arg.AdminID, arg.RowLimit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListQuestionsAnsweredByRow{}
+	for rows.Next() {
+		var i ListQuestionsAnsweredByRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.AuthorID,
+			&i.AuthorName,
+			&i.Title,
+			&i.Body,
+			&i.City,
+			&i.HuntDate,
+			&i.Hidden,
+			&i.CreatedAt,
+			&i.Score,
+			&i.Answered,
+			&i.UserVote,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listQuestionsByAuthor = `-- name: ListQuestionsByAuthor :many
+SELECT q.id, q.author_id, u.name AS author_name, q.title, q.body, q.city, q.hunt_date, q.hidden, q.created_at,
+       COALESCE((SELECT SUM(votes.value) FROM votes WHERE votes.question_id = q.id), 0)::bigint AS score,
+       CASE WHEN a.question_id IS NULL THEN 0 ELSE 1 END::bigint AS answered,
+       0::bigint AS user_vote
+FROM questions q
+JOIN users u ON u.id = q.author_id
+LEFT JOIN answers a ON a.question_id = q.id
+WHERE q.author_id = $1 AND q.hidden = 0
+ORDER BY q.created_at DESC
+LIMIT $2
+`
+
+type ListQuestionsByAuthorParams struct {
+	AuthorID string
+	RowLimit int32
+}
+
+type ListQuestionsByAuthorRow struct {
+	ID         string
+	AuthorID   string
+	AuthorName string
+	Title      string
+	Body       string
+	City       string
+	HuntDate   string
+	Hidden     int32
+	CreatedAt  string
+	Score      int64
+	Answered   int64
+	UserVote   int64
+}
+
+func (q *Queries) ListQuestionsByAuthor(ctx context.Context, arg ListQuestionsByAuthorParams) ([]ListQuestionsByAuthorRow, error) {
+	rows, err := q.db.QueryContext(ctx, listQuestionsByAuthor, arg.AuthorID, arg.RowLimit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListQuestionsByAuthorRow{}
+	for rows.Next() {
+		var i ListQuestionsByAuthorRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.AuthorID,
+			&i.AuthorName,
+			&i.Title,
+			&i.Body,
+			&i.City,
+			&i.HuntDate,
+			&i.Hidden,
+			&i.CreatedAt,
+			&i.Score,
+			&i.Answered,
+			&i.UserVote,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}

internal/store/sqlc/users.sql.go

@@ -24,8 +24,8 @@ func (q *Queries) CountAdmins(ctx context.Context, role string) (int64, error) {
 }
 
 const createUser = `-- name: CreateUser :exec
-INSERT INTO users (id, username, name, password_hash, role, email, avatar_url, state, created_at)
-VALUES ($1, $2, $3, $4, $5, $6, '', '', $7)
+INSERT INTO users (id, username, name, password_hash, role, avatar_url, state, created_at)
+VALUES ($1, $2, $3, $4, $5, '', '', $6)
 `
 
 type CreateUserParams struct {
@@ -34,7 +34,6 @@ type CreateUserParams struct {
 	Name         string
 	PasswordHash string
 	Role         string
-	Email        string
 	CreatedAt    string
 }
 
@@ -45,14 +44,13 @@ func (q *Queries) CreateUser(ctx context.Context, arg CreateUserParams) error {
 		arg.Name,
 		arg.PasswordHash,
 		arg.Role,
-		arg.Email,
 		arg.CreatedAt,
 	)
 	return err
 }
 
 const getUserByID = `-- name: GetUserByID :one
-SELECT id, username, name, role, email, avatar_url, state, created_at
+SELECT id, username, name, role, avatar_url, state, created_at
 FROM users
 WHERE id = $1
 `
@@ -62,7 +60,6 @@ type GetUserByIDRow struct {
 	Username  string
 	Name      string
 	Role      string
-	Email     string
 	AvatarUrl string
 	State     string
 	CreatedAt string
@@ -76,7 +73,6 @@ func (q *Queries) GetUserByID(ctx context.Context, id string) (GetUserByIDRow, e
 		&i.Username,
 		&i.Name,
 		&i.Role,
-		&i.Email,
 		&i.AvatarUrl,
 		&i.State,
 		&i.CreatedAt,
@@ -85,7 +81,7 @@ func (q *Queries) GetUserByID(ctx context.Context, id string) (GetUserByIDRow, e
 }
 
 const getUserByUsername = `-- name: GetUserByUsername :one
-SELECT id, username, name, role, email, avatar_url, state, created_at, password_hash
+SELECT id, username, name, role, avatar_url, state, created_at, password_hash
 FROM users
 WHERE username = $1
 `
@@ -95,7 +91,6 @@ type GetUserByUsernameRow struct {
 	Username     string
 	Name         string
 	Role         string
-	Email        string
 	AvatarUrl    string
 	State        string
 	CreatedAt    string
@@ -110,7 +105,6 @@ func (q *Queries) GetUserByUsername(ctx context.Context, username string) (GetUs
 		&i.Username,
 		&i.Name,
 		&i.Role,
-		&i.Email,
 		&i.AvatarUrl,
 		&i.State,
 		&i.CreatedAt,
@@ -133,13 +127,12 @@ func (q *Queries) GetUserRole(ctx context.Context, id string) (string, error) {
 }
 
 const listUsers = `-- name: ListUsers :many
-SELECT id, username, name, role, email, avatar_url, state, created_at
+SELECT id, username, name, role, avatar_url, state, created_at
 FROM users
 WHERE (
   $1 = ''
   OR username ILIKE '%' || $1 || '%'
   OR name ILIKE '%' || $1 || '%'
-  OR email ILIKE '%' || $1 || '%'
 )
 AND (
   $2 = ''
@@ -162,7 +155,6 @@ type ListUsersRow struct {
 	Username  string
 	Name      string
 	Role      string
-	Email     string
 	AvatarUrl string
 	State     string
 	CreatedAt string
@@ -187,7 +179,6 @@ func (q *Queries) ListUsers(ctx context.Context, arg ListUsersParams) ([]ListUse
 			&i.Username,
 			&i.Name,
 			&i.Role,
-			&i.Email,
 			&i.AvatarUrl,
 			&i.State,
 			&i.CreatedAt,
@@ -205,46 +196,6 @@ func (q *Queries) ListUsers(ctx context.Context, arg ListUsersParams) ([]ListUse
 	return items, nil
 }
 
-const updateUserProfile = `-- name: UpdateUserProfile :exec
-UPDATE users
-SET state = $1, email = $2
-WHERE id = $3
-`
-
-type UpdateUserProfileParams struct {
-	State string
-	Email string
-	ID    string
-}
-
-func (q *Queries) UpdateUserProfile(ctx context.Context, arg UpdateUserProfileParams) error {
-	_, err := q.db.ExecContext(ctx, updateUserProfile, arg.State, arg.Email, arg.ID)
-	return err
-}
-
-const updateUserProfileAndAvatar = `-- name: UpdateUserProfileAndAvatar :exec
-UPDATE users
-SET state = $1, email = $2, avatar_url = $3
-WHERE id = $4
-`
-
-type UpdateUserProfileAndAvatarParams struct {
-	State     string
-	Email     string
-	AvatarUrl string
-	ID        string
-}
-
-func (q *Queries) UpdateUserProfileAndAvatar(ctx context.Context, arg UpdateUserProfileAndAvatarParams) error {
-	_, err := q.db.ExecContext(ctx, updateUserProfileAndAvatar,
-		arg.State,
-		arg.Email,
-		arg.AvatarUrl,
-		arg.ID,
-	)
-	return err
-}
-
 const updateUserRole = `-- name: UpdateUserRole :execresult
 UPDATE users
 SET role = $1
@@ -259,3 +210,36 @@ type UpdateUserRoleParams struct {
 func (q *Queries) UpdateUserRole(ctx context.Context, arg UpdateUserRoleParams) (sql.Result, error) {
 	return q.db.ExecContext(ctx, updateUserRole, arg.Role, arg.ID)
 }
+
+const updateUserState = `-- name: UpdateUserState :exec
+UPDATE users
+SET state = $1
+WHERE id = $2
+`
+
+type UpdateUserStateParams struct {
+	State string
+	ID    string
+}
+
+func (q *Queries) UpdateUserState(ctx context.Context, arg UpdateUserStateParams) error {
+	_, err := q.db.ExecContext(ctx, updateUserState, arg.State, arg.ID)
+	return err
+}
+
+const updateUserStateAndAvatar = `-- name: UpdateUserStateAndAvatar :exec
+UPDATE users
+SET state = $1, avatar_url = $2
+WHERE id = $3
+`
+
+type UpdateUserStateAndAvatarParams struct {
+	State     string
+	AvatarUrl string
+	ID        string
+}
+
+func (q *Queries) UpdateUserStateAndAvatar(ctx context.Context, arg UpdateUserStateAndAvatarParams) error {
+	_, err := q.db.ExecContext(ctx, updateUserStateAndAvatar, arg.State, arg.AvatarUrl, arg.ID)
+	return err
+}

internal/store/sqlc/votes.sql.go

@@ -0,0 +1,82 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.31.1
+// source: votes.sql
+
+package sqlc
+
+import (
+	"context"
+)
+
+const deleteVote = `-- name: DeleteVote :exec
+DELETE FROM votes
+WHERE user_id = $1 AND question_id = $2
+`
+
+type DeleteVoteParams struct {
+	UserID     string
+	QuestionID string
+}
+
+func (q *Queries) DeleteVote(ctx context.Context, arg DeleteVoteParams) error {
+	_, err := q.db.ExecContext(ctx, deleteVote, arg.UserID, arg.QuestionID)
+	return err
+}
+
+const getVote = `-- name: GetVote :one
+SELECT value
+FROM votes
+WHERE user_id = $1 AND question_id = $2
+`
+
+type GetVoteParams struct {
+	UserID     string
+	QuestionID string
+}
+
+func (q *Queries) GetVote(ctx context.Context, arg GetVoteParams) (int32, error) {
+	row := q.db.QueryRowContext(ctx, getVote, arg.UserID, arg.QuestionID)
+	var value int32
+	err := row.Scan(&value)
+	return value, err
+}
+
+const questionIsVisible = `-- name: QuestionIsVisible :one
+SELECT EXISTS(
+  SELECT 1 FROM questions WHERE id = $1 AND hidden = 0
+)::bool
+`
+
+func (q *Queries) QuestionIsVisible(ctx context.Context, id string) (bool, error) {
+	row := q.db.QueryRowContext(ctx, questionIsVisible, id)
+	var column_1 bool
+	err := row.Scan(&column_1)
+	return column_1, err
+}
+
+const upsertVoteOnVisible = `-- name: UpsertVoteOnVisible :execrows
+INSERT INTO votes (user_id, question_id, value)
+SELECT $1, $2, $3
+FROM questions q
+WHERE q.id = $2 AND q.hidden = 0
+ON CONFLICT (user_id, question_id) DO UPDATE
+SET value = excluded.value
+WHERE EXISTS (
+  SELECT 1 FROM questions q2 WHERE q2.id = excluded.question_id AND q2.hidden = 0
+)
+`
+
+type UpsertVoteOnVisibleParams struct {
+	UserID     string
+	QuestionID string
+	Value      int32
+}
+
+func (q *Queries) UpsertVoteOnVisible(ctx context.Context, arg UpsertVoteOnVisibleParams) (int64, error) {
+	result, err := q.db.ExecContext(ctx, upsertVoteOnVisible, arg.UserID, arg.QuestionID, arg.Value)
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected()
+}

internal/store/store.go

@@ -27,14 +27,16 @@ type Store interface {
 	SetUserRole(ctx context.Context, id string, role Role) error
 	SaveUserProfile(ctx context.Context, u *User) error
 
-	CreatePost(ctx context.Context, post *Post) error
-	GetPost(ctx context.Context, id string) (*Post, error)
-	GetPostThread(ctx context.Context, rootID string) (*Post, error)
-	GetPostThreadForViewer(ctx context.Context, rootID, viewerID string) (*Post, error)
-	UpdatePost(ctx context.Context, post *Post) error
-	ListRootPosts(ctx context.Context, postDate, viewerID string) ([]Post, error)
-	ListRootPostsByAuthor(ctx context.Context, authorID string) ([]Post, error)
-	ListRootPostsAnsweredBy(ctx context.Context, adminID string) ([]Post, error)
-	SetRootPostState(ctx context.Context, id string, state PostState) error
-	VotePost(ctx context.Context, userID, postID string, value int) error
+	CreateQuestion(ctx context.Context, q *RankedQuestion) error
+	GetQuestion(ctx context.Context, id, viewerID string) (*RankedQuestion, error)
+	ListHunt(ctx context.Context, huntDate, viewerID string) ([]RankedQuestion, error)
+	ListQuestionsByAuthor(ctx context.Context, authorID string) ([]RankedQuestion, error)
+	ListQuestionsAnsweredBy(ctx context.Context, adminID string) ([]RankedQuestion, error)
+	HideQuestion(ctx context.Context, id string) error
+
+	GetAnswer(ctx context.Context, questionID string) (*Answer, error)
+	UpsertAnswer(ctx context.Context, a *Answer) error
+
+	// Vote sets the vote to 1, -1, or 0 (clear) on a visible question.
+	Vote(ctx context.Context, userID, questionID string, value int) error
 }

internal/store/user.go

@@ -9,19 +9,12 @@ import (
 	"time"
 
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgconn"
 
 	"plumber/internal/store/sqlc"
 )
 
-var (
-	// ErrLastAdmin is returned when demoting the only remaining admin.
-	ErrLastAdmin = errors.New("cannot demote the last admin")
-	// ErrDuplicateUsername is returned when inserting an existing username.
-	ErrDuplicateUsername = errors.New("username taken")
-	// ErrDuplicateEmail is returned when inserting or updating an existing email.
-	ErrDuplicateEmail = errors.New("email taken")
-)
+// ErrLastAdmin is returned when demoting the only remaining admin.
+var ErrLastAdmin = errors.New("cannot demote the last admin")
 
 // Role is a user privilege level stored in users.role.
 type Role string
@@ -37,7 +30,6 @@ type User struct {
 	Username     string
 	Name         string
 	Role         Role
-	Email        string
 	AvatarURL    string
 	State        string
 	CreatedAt    string
@@ -58,24 +50,12 @@ func NormalizeUsername(s string) string {
 	return strings.ToLower(strings.TrimSpace(s))
 }
 
-func mapUniqueViolation(err error) error {
-	var pgErr *pgconn.PgError
-	if errors.As(err, &pgErr) && pgErr.Code == "23505" {
-		if strings.Contains(strings.ToLower(pgErr.ConstraintName), "email") {
-			return ErrDuplicateEmail
-		}
-		return ErrDuplicateUsername
-	}
-	return err
-}
-
-func toUser(db *sql.DB, id, username, name, role, email, avatarURL, state, createdAt, passwordHash string) *User {
+func toUser(db *sql.DB, id, username, name, role, avatarURL, state, createdAt, passwordHash string) *User {
 	return &User{
 		ID:           id,
 		Username:     username,
 		Name:         name,
 		Role:         Role(role),
-		Email:        email,
 		AvatarURL:    avatarURL,
 		State:        state,
 		CreatedAt:    createdAt,
@@ -93,7 +73,6 @@ func (u *User) Create(ctx context.Context) error {
 		return fmt.Errorf("invalid role")
 	}
 	u.Username = NormalizeUsername(u.Username)
-	u.Email = NormalizeEmail(u.Email)
 	if u.ID == "" {
 		u.ID = uuid.NewString()
 	}
@@ -109,7 +88,6 @@ func (u *User) Create(ctx context.Context) error {
 		Name:         u.Name,
 		PasswordHash: u.PasswordHash,
 		Role:         string(u.Role),
-		Email:        u.Email,
 		CreatedAt:    u.CreatedAt,
 	}))
 }
@@ -171,27 +149,21 @@ func (u *User) SetRole(ctx context.Context, role Role) error {
 	return nil
 }
 
-// SaveProfile writes Email, State, and optionally AvatarURL.
+// SaveProfile writes State and optionally AvatarURL.
 func (u *User) SaveProfile(ctx context.Context) error {
 	if u == nil || u.db == nil {
 		return fmt.Errorf("user: no database")
 	}
 	u.State = strings.TrimSpace(u.State)
-	u.Email = NormalizeEmail(u.Email)
 	q := sqlc.New(u.db)
 	if u.AvatarURL == "" {
-		return mapUniqueViolation(q.UpdateUserProfile(ctx, sqlc.UpdateUserProfileParams{
-			State: u.State,
-			Email: u.Email,
-			ID:    u.ID,
-		}))
+		return q.UpdateUserState(ctx, sqlc.UpdateUserStateParams{State: u.State, ID: u.ID})
 	}
-	return mapUniqueViolation(q.UpdateUserProfileAndAvatar(ctx, sqlc.UpdateUserProfileAndAvatarParams{
+	return q.UpdateUserStateAndAvatar(ctx, sqlc.UpdateUserStateAndAvatarParams{
 		State:     u.State,
-		Email:     u.Email,
 		AvatarUrl: u.AvatarURL,
 		ID:        u.ID,
-	}))
+	})
 }
 
 func CountAdmins(ctx context.Context, db *sql.DB) (int, error) {
@@ -215,7 +187,7 @@ func ListUsers(ctx context.Context, db *sql.DB, q ListUsersQuery) ([]User, strin
 	}
 	out := make([]User, 0, len(rows))
 	for _, r := range rows {
-		u := toUser(db, r.ID, r.Username, r.Name, r.Role, r.Email, r.AvatarUrl, r.State, r.CreatedAt, "")
+		u := toUser(db, r.ID, r.Username, r.Name, r.Role, r.AvatarUrl, r.State, r.CreatedAt, "")
 		out = append(out, *u)
 	}
 	var nextCreated, nextID string
@@ -232,7 +204,7 @@ func UserByID(ctx context.Context, db *sql.DB, id string) (*User, error) {
 	if err != nil {
 		return nil, err
 	}
-	return toUser(db, r.ID, r.Username, r.Name, r.Role, r.Email, r.AvatarUrl, r.State, r.CreatedAt, ""), nil
+	return toUser(db, r.ID, r.Username, r.Name, r.Role, r.AvatarUrl, r.State, r.CreatedAt, ""), nil
 }
 
 func UserByUsername(ctx context.Context, db *sql.DB, username string) (*User, error) {
@@ -240,5 +212,5 @@ func UserByUsername(ctx context.Context, db *sql.DB, username string) (*User, er
 	if err != nil {
 		return nil, err
 	}
-	return toUser(db, r.ID, r.Username, r.Name, r.Role, r.Email, r.AvatarUrl, r.State, r.CreatedAt, r.PasswordHash), nil
+	return toUser(db, r.ID, r.Username, r.Name, r.Role, r.AvatarUrl, r.State, r.CreatedAt, r.PasswordHash), nil
 }

internal/store/vote.go

@@ -0,0 +1,64 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgconn"
+
+	"plumber/internal/store/sqlc"
+)
+
+// ErrDuplicateUsername is returned when inserting a username that already exists.
+var ErrDuplicateUsername = errors.New("username taken")
+
+// ErrHiddenOrMissing is returned when voting on a hidden or unknown question.
+var ErrHiddenOrMissing = errors.New("question not votable")
+
+// SetVote sets the user's vote to value (1, -1, or 0 to clear) on a visible question.
+func SetVote(ctx context.Context, db *sql.DB, userID, questionID string, value int) error {
+	if value != 1 && value != -1 && value != 0 {
+		return fmt.Errorf("invalid vote")
+	}
+	q := sqlc.New(db)
+	if value == 0 {
+		visible, err := q.QuestionIsVisible(ctx, questionID)
+		if err != nil {
+			return err
+		}
+		if !visible {
+			return ErrHiddenOrMissing
+		}
+		return q.DeleteVote(ctx, sqlc.DeleteVoteParams{
+			UserID:     userID,
+			QuestionID: questionID,
+		})
+	}
+	n, err := q.UpsertVoteOnVisible(ctx, sqlc.UpsertVoteOnVisibleParams{
+		UserID:     userID,
+		QuestionID: questionID,
+		Value:      int32(value),
+	})
+	if err != nil {
+		return mapUniqueViolation(err)
+	}
+	if n == 0 {
+		return ErrHiddenOrMissing
+	}
+	return nil
+}
+
+// Vote is kept as an alias for SetVote for callers that still use the old name.
+func Vote(ctx context.Context, db *sql.DB, userID, questionID string, value int) error {
+	return SetVote(ctx, db, userID, questionID, value)
+}
+
+func mapUniqueViolation(err error) error {
+	var pgErr *pgconn.PgError
+	if errors.As(err, &pgErr) && pgErr.Code == "23505" {
+		return ErrDuplicateUsername
+	}
+	return err
+}

internal/web/auth.go

@@ -129,21 +129,14 @@ func (s *Server) handleRegister(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	username := strings.TrimSpace(r.PostFormValue("username"))
-	emailRaw := r.PostFormValue("email")
 	password := r.PostFormValue("password")
 	setupSecret := r.PostFormValue("setup_secret")
-	p := authPage{page: s.basePage(r, "Create account"), Username: username, Email: strings.TrimSpace(emailRaw)}
+	p := authPage{page: s.basePage(r, "Create account"), Username: username}
 	if !usernameRe.MatchString(username) {
 		p.Error = "Username must be 3–20 letters, numbers, or underscores."
 		s.exec(w, "register", p)
 		return
 	}
-	email, emailErr := store.ValidateEmail(emailRaw)
-	if emailErr != "" {
-		p.Error = emailErr
-		s.exec(w, "register", p)
-		return
-	}
 	if ok, msg := passwordValid(password); !ok {
 		p.Error = msg
 		s.exec(w, "register", p)
@@ -160,7 +153,6 @@ func (s *Server) handleRegister(w http.ResponseWriter, r *http.Request) {
 	}
 	u := &store.User{
 		Username:     username,
-		Email:        email,
 		PasswordHash: string(hash),
 		Role:         role,
 	}
@@ -170,11 +162,6 @@ func (s *Server) handleRegister(w http.ResponseWriter, r *http.Request) {
 			s.exec(w, "register", p)
 			return
 		}
-		if errors.Is(err, store.ErrDuplicateEmail) {
-			p.Error = "That email is already registered."
-			s.exec(w, "register", p)
-			return
-		}
 		log.Printf("register create: %v", err)
 		http.Error(w, "could not create account", http.StatusInternalServerError)
 		return

internal/web/posts.go

@@ -1,276 +0,0 @@
-package web
-
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"fmt"
-	"log"
-	"net/http"
-	"net/url"
-	"strings"
-	"time"
-
-	"github.com/go-chi/chi/v5"
-
-	"plumber/internal/mail"
-	"plumber/internal/store"
-)
-
-// handleCreatePost creates either a root question or a reply. Replies are
-// limited to the root author and admins, and cannot be added to hidden threads.
-func (s *Server) handleCreatePost(w http.ResponseWriter, r *http.Request) {
-	if !s.requireCSRF(w, r) {
-		return
-	}
-	user := currentUser(r)
-	if user == nil {
-		http.Error(w, "authentication required", http.StatusUnauthorized)
-		return
-	}
-
-	parentID := strings.TrimSpace(r.PostFormValue("parent_id"))
-	body := strings.TrimSpace(r.PostFormValue("body"))
-	if body == "" {
-		http.Error(w, "post body required", http.StatusBadRequest)
-		return
-	}
-
-	post := &store.Post{
-		AuthorID: user.ID,
-		Body:     truncateRunes(body, 12000),
-	}
-	var parent, root *store.Post
-	if parentID == "" {
-		post.Title = truncateRunes(strings.TrimSpace(r.PostFormValue("title")), 120)
-		post.City = truncateRunes(strings.TrimSpace(r.PostFormValue("city")), 80)
-		if post.Title == "" {
-			http.Error(w, "post title required", http.StatusBadRequest)
-			return
-		}
-	} else {
-		loadedParent, threadRoot, err := s.postAndRoot(r.Context(), parentID)
-		if err != nil {
-			if errors.Is(err, sql.ErrNoRows) {
-				http.NotFound(w, r)
-				return
-			}
-			http.Error(w, "could not load thread", http.StatusInternalServerError)
-			return
-		}
-		if threadRoot.PostState == store.PostStateHidden {
-			http.NotFound(w, r)
-			return
-		}
-		if !canReplyToThread(user, threadRoot) {
-			http.Error(w, "forbidden", http.StatusForbidden)
-			return
-		}
-		parent = loadedParent
-		post.ParentID = &parent.ID
-		root = threadRoot
-	}
-
-	if err := s.store.CreatePost(r.Context(), post); err != nil {
-		if errors.Is(err, store.ErrInvalidPost) {
-			http.Error(w, "invalid post", http.StatusBadRequest)
-			return
-		}
-		http.Error(w, "could not save post", http.StatusInternalServerError)
-		return
-	}
-	if root == nil {
-		root = post
-	}
-	if parent != nil {
-		s.notifyPostReply(parent, root, post, user)
-	}
-	http.Redirect(
-		w,
-		r,
-		"/questions/"+url.PathEscape(root.ID)+"#post-"+url.PathEscape(post.ID),
-		http.StatusSeeOther,
-	)
-}
-
-// 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) {
-	if !s.requireCSRF(w, r) {
-		return
-	}
-	user := currentUser(r)
-	if user == nil {
-		http.Error(w, "authentication required", http.StatusUnauthorized)
-		return
-	}
-
-	post, root, err := s.postAndRoot(r.Context(), chi.URLParam(r, "id"))
-	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			http.NotFound(w, r)
-			return
-		}
-		http.Error(w, "could not load post", http.StatusInternalServerError)
-		return
-	}
-	if !canEditPost(user, post) {
-		http.Error(w, "forbidden", http.StatusForbidden)
-		return
-	}
-
-	body := strings.TrimSpace(r.PostFormValue("body"))
-	if body == "" {
-		http.Error(w, "post body required", http.StatusBadRequest)
-		return
-	}
-	post.Body = truncateRunes(body, 12000)
-	if err := s.store.UpdatePost(r.Context(), post); err != nil {
-		if errors.Is(err, store.ErrInvalidPost) {
-			http.Error(w, "invalid post", http.StatusBadRequest)
-			return
-		}
-		if errors.Is(err, sql.ErrNoRows) {
-			http.NotFound(w, r)
-			return
-		}
-		http.Error(w, "could not save post", http.StatusInternalServerError)
-		return
-	}
-	http.Redirect(
-		w,
-		r,
-		"/questions/"+url.PathEscape(root.ID)+"#post-"+url.PathEscape(post.ID),
-		http.StatusSeeOther,
-	)
-}
-
-// postAndRoot loads a post and follows its immutable parent chain to the root.
-// It returns both so callers can authorize against the thread and redirect to it.
-func (s *Server) postAndRoot(ctx context.Context, postID string) (*store.Post, *store.Post, error) {
-	postID = strings.TrimSpace(postID)
-	if postID == "" {
-		return nil, nil, sql.ErrNoRows
-	}
-	post, err := s.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 = s.store.GetPost(ctx, *current.ParentID)
-		if err != nil {
-			return nil, nil, err
-		}
-	}
-	return post, current, nil
-}
-
-// canEditPost keeps homeowner posts owner-only while allowing admins to edit
-// posts authored by an admin.
-func canEditPost(user *store.User, post *store.Post) bool {
-	if user == nil || post == nil {
-		return false
-	}
-	if post.AuthorRole == store.RoleAdmin {
-		return user.Admin()
-	}
-	return user.ID == post.AuthorID
-}
-
-func canReplyToThread(user *store.User, root *store.Post) bool {
-	return user != nil &&
-		root != nil &&
-		root.PostState != store.PostStateHidden &&
-		(user.Admin() || user.ID == root.AuthorID)
-}
-
-func postLabel(post *store.Post) string {
-	if post == nil {
-		return ""
-	}
-	if post.ParentID == nil {
-		return "Question"
-	}
-	if post.AuthorRole == store.RoleAdmin {
-		return "Shop response"
-	}
-	return "Homeowner"
-}
-
-func postDepthClass(depth int) string {
-	switch depth {
-	case 0:
-		return "root"
-	case 1:
-		return "branch"
-	default:
-		return "deep"
-	}
-}
-
-func postPointers(posts []store.Post) []*store.Post {
-	out := make([]*store.Post, len(posts))
-	for i := range posts {
-		out[i] = &posts[i]
-	}
-	return out
-}

internal/web/posts_test.go

@@ -1,540 +0,0 @@
-package web
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"strings"
-	"testing"
-	"time"
-
-	"plumber/internal/mail"
-	"plumber/internal/pacific"
-	"plumber/internal/store"
-)
-
-func TestCreatePostRoutePermissions(t *testing.T) {
-	t.Parallel()
-
-	srv, mem := newTestServer(t, Config{})
-	handler := srv.Handler()
-	homeowner := seedUser(t, mem, uniq("homeowner"), "hunter22", store.RoleUser)
-	other := seedUser(t, mem, uniq("other"), "hunter22", store.RoleUser)
-	admin := seedUser(t, mem, uniq("admin"), "hunter22", store.RoleAdmin)
-	homeownerCookies := loginUser(t, handler, homeowner.Username, "hunter22")
-	otherCookies := loginUser(t, handler, other.Username, "hunter22")
-	adminCookies := loginUser(t, handler, admin.Username, "hunter22")
-	homeownerCSRF := csrfForCookies(t, handler, homeownerCookies)
-	otherCSRF := csrfForCookies(t, handler, otherCookies)
-	adminCSRF := csrfForCookies(t, handler, adminCookies)
-
-	rec := postForm(handler, "/posts", url.Values{
-		"title": {"No CSRF"},
-		"body":  {"Body"},
-	}, homeownerCookies)
-	if rec.Code != http.StatusForbidden {
-		t.Fatalf("missing CSRF status = %d, want 403", rec.Code)
-	}
-
-	anonRec := httptest.NewRecorder()
-	handler.ServeHTTP(anonRec, httptest.NewRequest(http.MethodGet, "/login", nil))
-	anonCookies := anonRec.Result().Cookies()
-	anonCSRF := csrfFrom(anonRec.Body.String())
-	rec = postForm(handler, "/posts", url.Values{
-		"_csrf": {anonCSRF},
-		"title": {"Anonymous"},
-		"body":  {"Body"},
-	}, anonCookies)
-	if rec.Code != http.StatusUnauthorized {
-		t.Fatalf("anonymous create status = %d, want 401", rec.Code)
-	}
-
-	rec = postForm(handler, "/posts", url.Values{
-		"_csrf": {homeownerCSRF},
-		"title": {"Leaky sink"},
-		"body":  {"It drips."},
-		"city":  {"Oakland"},
-	}, homeownerCookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("root create status = %d: %s", rec.Code, rec.Body.String())
-	}
-	roots, err := mem.ListRootPosts(context.Background(), pacific.Today(), homeowner.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(roots) != 1 ||
-		roots[0].AuthorID != homeowner.ID ||
-		roots[0].Title != "Leaky sink" ||
-		roots[0].PostState != store.PostStateVisible {
-		t.Fatalf("created root = %+v", roots)
-	}
-	root := roots[0]
-	if got := rec.Header().Get("Location"); got != "/questions/"+root.ID+"#post-"+root.ID {
-		t.Fatalf("root redirect = %q", got)
-	}
-
-	rec = postForm(handler, "/posts", url.Values{
-		"_csrf":     {homeownerCSRF},
-		"parent_id": {root.ID},
-		"body":      {"The model is 123."},
-	}, homeownerCookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("homeowner reply status = %d: %s", rec.Code, rec.Body.String())
-	}
-	thread, err := mem.GetPostThread(context.Background(), root.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(thread.Replies) != 1 || thread.Replies[0].AuthorID != homeowner.ID {
-		t.Fatalf("homeowner reply missing: %+v", thread)
-	}
-	homeownerReply := thread.Replies[0]
-
-	rec = postForm(handler, "/posts", url.Values{
-		"_csrf":     {adminCSRF},
-		"parent_id": {homeownerReply.ID},
-		"body":      {"Replace the cartridge."},
-	}, adminCookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("admin nested reply status = %d: %s", rec.Code, rec.Body.String())
-	}
-	thread, err = mem.GetPostThread(context.Background(), root.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(thread.Replies[0].Replies) != 1 ||
-		thread.Replies[0].Replies[0].AuthorID != admin.ID {
-		t.Fatalf("admin nested reply missing: %+v", thread)
-	}
-
-	rec = postForm(handler, "/posts", url.Values{
-		"_csrf":     {otherCSRF},
-		"parent_id": {homeownerReply.ID},
-		"body":      {"I should not be here."},
-	}, otherCookies)
-	if rec.Code != http.StatusForbidden {
-		t.Fatalf("unrelated reply status = %d, want 403", rec.Code)
-	}
-
-	rec = postForm(handler, "/posts", url.Values{
-		"_csrf":     {homeownerCSRF},
-		"parent_id": {"missing"},
-		"body":      {"Missing parent"},
-	}, homeownerCookies)
-	if rec.Code != http.StatusNotFound {
-		t.Fatalf("missing-parent reply status = %d, want 404", rec.Code)
-	}
-
-	hidden := &store.Post{
-		AuthorID:  homeowner.ID,
-		Title:     "Hidden thread",
-		Body:      "Body",
-		PostDate:  pacific.Today(),
-		PostState: store.PostStateHidden,
-	}
-	if err := mem.CreatePost(context.Background(), hidden); err != nil {
-		t.Fatal(err)
-	}
-	rec = postForm(handler, "/posts", url.Values{
-		"_csrf":     {homeownerCSRF},
-		"parent_id": {hidden.ID},
-		"body":      {"Hidden reply"},
-	}, homeownerCookies)
-	if rec.Code != http.StatusNotFound {
-		t.Fatalf("hidden-thread reply status = %d, want 404", rec.Code)
-	}
-}
-
-func TestEditPostRoutePermissions(t *testing.T) {
-	t.Parallel()
-
-	srv, mem := newTestServer(t, Config{})
-	handler := srv.Handler()
-	homeowner := seedUser(t, mem, uniq("homeowner"), "hunter22", store.RoleUser)
-	other := seedUser(t, mem, uniq("other"), "hunter22", store.RoleUser)
-	admin := seedUser(t, mem, uniq("admin"), "hunter22", store.RoleAdmin)
-	secondAdmin := seedUser(t, mem, uniq("admin"), "hunter22", store.RoleAdmin)
-	if err := mem.SetUserRole(context.Background(), secondAdmin.ID, store.RoleAdmin); err != nil {
-		t.Fatal(err)
-	}
-	homeownerCookies := loginUser(t, handler, homeowner.Username, "hunter22")
-	otherCookies := loginUser(t, handler, other.Username, "hunter22")
-	adminCookies := loginUser(t, handler, admin.Username, "hunter22")
-	secondAdminCookies := loginUser(t, handler, secondAdmin.Username, "hunter22")
-	homeownerCSRF := csrfForCookies(t, handler, homeownerCookies)
-	otherCSRF := csrfForCookies(t, handler, otherCookies)
-	adminCSRF := csrfForCookies(t, handler, adminCookies)
-	secondAdminCSRF := csrfForCookies(t, handler, secondAdminCookies)
-
-	root := &store.Post{
-		AuthorID: homeowner.ID,
-		Title:    "Leaky sink",
-		Body:     "Original body",
-		PostDate: pacific.Today(),
-	}
-	if err := mem.CreatePost(context.Background(), root); err != nil {
-		t.Fatal(err)
-	}
-	rootID := root.ID
-	adminReply := &store.Post{
-		ParentID: &rootID,
-		AuthorID: admin.ID,
-		Body:     "Original answer",
-	}
-	if err := mem.CreatePost(context.Background(), adminReply); err != nil {
-		t.Fatal(err)
-	}
-
-	anonRec := httptest.NewRecorder()
-	handler.ServeHTTP(anonRec, httptest.NewRequest(http.MethodGet, "/login", nil))
-	rec := postForm(handler, "/posts/"+root.ID+"/edit", url.Values{
-		"_csrf": {csrfFrom(anonRec.Body.String())},
-		"body":  {"Anonymous edit"},
-	}, anonRec.Result().Cookies())
-	if rec.Code != http.StatusUnauthorized {
-		t.Fatalf("anonymous edit status = %d, want 401", rec.Code)
-	}
-
-	rec = postForm(handler, "/posts/"+root.ID+"/edit", url.Values{
-		"_csrf":     {homeownerCSRF},
-		"body":      {"Updated homeowner body"},
-		"parent_id": {adminReply.ID},
-		"author_id": {other.ID},
-	}, homeownerCookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("homeowner edit status = %d: %s", rec.Code, rec.Body.String())
-	}
-	saved, err := mem.GetPost(context.Background(), root.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if saved.Body != "Updated homeowner body" ||
-		saved.ParentID != nil ||
-		saved.AuthorID != homeowner.ID {
-		t.Fatalf("homeowner edit changed immutable fields: %+v", saved)
-	}
-
-	for name, session := range map[string]struct {
-		cookies []*http.Cookie
-		csrf    string
-	}{
-		"other homeowner": {otherCookies, otherCSRF},
-		"admin":           {adminCookies, adminCSRF},
-	} {
-		t.Run(name+" cannot edit homeowner post", func(t *testing.T) {
-			rec := postForm(handler, "/posts/"+root.ID+"/edit", url.Values{
-				"_csrf": {session.csrf},
-				"body":  {"Unauthorized edit"},
-			}, session.cookies)
-			if rec.Code != http.StatusForbidden {
-				t.Fatalf("status = %d, want 403", rec.Code)
-			}
-		})
-	}
-
-	rec = postForm(handler, "/posts/"+adminReply.ID+"/edit", url.Values{
-		"_csrf": {homeownerCSRF},
-		"body":  {"Homeowner edit"},
-	}, homeownerCookies)
-	if rec.Code != http.StatusForbidden {
-		t.Fatalf("homeowner editing admin post status = %d, want 403", rec.Code)
-	}
-
-	rec = postForm(handler, "/posts/"+adminReply.ID+"/edit", url.Values{
-		"_csrf": {secondAdminCSRF},
-		"body":  {"Updated admin answer"},
-	}, secondAdminCookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("admin edit status = %d: %s", rec.Code, rec.Body.String())
-	}
-	saved, err = mem.GetPost(context.Background(), adminReply.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if saved.Body != "Updated admin answer" ||
-		saved.ParentID == nil ||
-		*saved.ParentID != root.ID ||
-		saved.AuthorID != admin.ID {
-		t.Fatalf("admin edit changed immutable fields: %+v", saved)
-	}
-}
-
-func TestPostReplyNotifications(t *testing.T) {
-	t.Parallel()
-
-	recording := &mail.Recording{}
-	srv, mem := newTestServer(t, Config{Mail: recording})
-	handler := srv.Handler()
-	homeowner := seedUser(t, mem, uniq("homeowner"), "hunter22", store.RoleUser)
-	admin := seedUser(t, mem, uniq("admin"), "hunter22", store.RoleAdmin)
-	homeownerCookies := loginUser(t, handler, homeowner.Username, "hunter22")
-	adminCookies := loginUser(t, handler, admin.Username, "hunter22")
-	homeownerCSRF := csrfForCookies(t, handler, homeownerCookies)
-	adminCSRF := csrfForCookies(t, handler, adminCookies)
-
-	rec := postForm(handler, "/posts", url.Values{
-		"_csrf": {homeownerCSRF},
-		"title": {"Leaky sink"},
-		"body":  {"Water under the cabinet."},
-	}, homeownerCookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("root create status = %d: %s", rec.Code, rec.Body.String())
-	}
-	if recording.Len() != 0 {
-		t.Fatalf("root create sent %d notifications", recording.Len())
-	}
-	roots, err := mem.ListRootPosts(context.Background(), pacific.Today(), homeowner.ID)
-	if err != nil || len(roots) != 1 {
-		t.Fatalf("created roots = %+v, %v", roots, err)
-	}
-	root := roots[0]
-
-	rec = postForm(handler, "/posts", url.Values{
-		"_csrf":     {adminCSRF},
-		"parent_id": {root.ID},
-		"body":      {"Replace the cartridge."},
-	}, adminCookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("admin reply status = %d: %s", rec.Code, rec.Body.String())
-	}
-	thread, err := mem.GetPostThread(context.Background(), root.ID)
-	if err != nil || len(thread.Replies) != 1 {
-		t.Fatalf("admin reply thread = %+v, %v", thread, err)
-	}
-	adminReply := thread.Replies[0]
-	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 notification = %+v", msg)
-	}
-
-	rec = postForm(handler, "/posts", url.Values{
-		"_csrf":     {homeownerCSRF},
-		"parent_id": {adminReply.ID},
-		"body":      {"That fixed the drip."},
-	}, homeownerCookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("homeowner reply status = %d: %s", rec.Code, rec.Body.String())
-	}
-	thread, err = mem.GetPostThread(context.Background(), root.ID)
-	if err != nil || len(thread.Replies[0].Replies) != 1 {
-		t.Fatalf("homeowner nested reply thread = %+v, %v", thread, err)
-	}
-	homeownerReply := thread.Replies[0].Replies[0]
-	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 notification = %+v", msg)
-	}
-
-	rec = postForm(handler, "/posts", url.Values{
-		"_csrf":     {adminCSRF},
-		"parent_id": {adminReply.ID},
-		"body":      {"One more plumber detail."},
-	}, adminCookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("nested admin reply status = %d: %s", rec.Code, rec.Body.String())
-	}
-	msgs = waitForMail(t, recording, 3)
-	if msg := msgs[2]; msg.ToEmail != homeowner.Email ||
-		msg.RootID != root.ID ||
-		msg.ReplyBody != "One more plumber detail." ||
-		msg.ReplyAuthorName != admin.Name {
-		t.Fatalf("nested admin reply notification = %+v", msg)
-	}
-
-	rec = postForm(handler, "/posts", url.Values{
-		"_csrf":     {homeownerCSRF},
-		"parent_id": {root.ID},
-		"body":      {"A note to myself."},
-	}, homeownerCookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("self reply status = %d: %s", rec.Code, rec.Body.String())
-	}
-	rec = postForm(handler, "/posts/"+adminReply.ID+"/edit", url.Values{
-		"_csrf": {adminCSRF},
-		"body":  {"Replace the ceramic cartridge."},
-	}, adminCookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("edit status = %d: %s", rec.Code, rec.Body.String())
-	}
-
-	noEmail := &store.User{
-		Username:     uniq("no-email"),
-		PasswordHash: homeowner.PasswordHash,
-		Role:         store.RoleUser,
-	}
-	if err := mem.CreateUser(context.Background(), noEmail); err != nil {
-		t.Fatal(err)
-	}
-	noEmailRoot := &store.Post{
-		AuthorID: noEmail.ID,
-		Title:    "Quiet thread",
-		Body:     "No email configured.",
-		PostDate: pacific.Today(),
-	}
-	if err := mem.CreatePost(context.Background(), noEmailRoot); err != nil {
-		t.Fatal(err)
-	}
-	rec = postForm(handler, "/posts", url.Values{
-		"_csrf":     {adminCSRF},
-		"parent_id": {noEmailRoot.ID},
-		"body":      {"This should not send."},
-	}, adminCookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("no-email reply status = %d: %s", rec.Code, rec.Body.String())
-	}
-	time.Sleep(50 * time.Millisecond)
-	if recording.Len() != 3 {
-		t.Fatalf("self, edit, or no-email action sent a notification: %+v", recording.Snapshot())
-	}
-}
-
-func TestQuestionPageRendersNestedPostControls(t *testing.T) {
-	t.Parallel()
-
-	srv, mem := newTestServer(t, Config{})
-	handler := srv.Handler()
-	homeowner := seedUser(t, mem, uniq("homeowner"), "hunter22", store.RoleUser)
-	admin := seedUser(t, mem, uniq("admin"), "hunter22", store.RoleAdmin)
-	homeownerCookies := loginUser(t, handler, homeowner.Username, "hunter22")
-	adminCookies := loginUser(t, handler, admin.Username, "hunter22")
-
-	root := &store.Post{
-		AuthorID: homeowner.ID,
-		Title:    "Leaky sink",
-		Body:     "Water under the cabinet.",
-		City:     "Oakland",
-		PostDate: pacific.Today(),
-	}
-	if err := mem.CreatePost(context.Background(), root); err != nil {
-		t.Fatal(err)
-	}
-	homeownerReply := &store.Post{
-		ParentID: &root.ID,
-		AuthorID: homeowner.ID,
-		Body:     "The model number is 123.",
-	}
-	if err := mem.CreatePost(context.Background(), homeownerReply); err != nil {
-		t.Fatal(err)
-	}
-	adminReply := &store.Post{
-		ParentID: &homeownerReply.ID,
-		AuthorID: admin.ID,
-		Body:     "Replace the cartridge.",
-	}
-	if err := mem.CreatePost(context.Background(), adminReply); err != nil {
-		t.Fatal(err)
-	}
-	homeownerReply.Body = "The model number is 123A."
-	if err := mem.UpdatePost(context.Background(), homeownerReply); err != nil {
-		t.Fatal(err)
-	}
-
-	rec := httptest.NewRecorder()
-	req := httptest.NewRequest(http.MethodGet, "/questions/"+root.ID, nil)
-	for _, cookie := range homeownerCookies {
-		req.AddCookie(cookie)
-	}
-	handler.ServeHTTP(rec, req)
-	if rec.Code != http.StatusOK {
-		t.Fatalf("question page status = %d: %s", rec.Code, rec.Body.String())
-	}
-	body := rec.Body.String()
-	for _, want := range []string{
-		`id="post-` + root.ID + `"`,
-		`id="post-` + homeownerReply.ID + `"`,
-		`id="post-` + adminReply.ID + `"`,
-		`class="thread-post thread-post-branch`,
-		`class="thread-post thread-post-deep is-shop"`,
-		"Homeowner",
-		"Shop response",
-		"Edited",
-		`action="/posts"`,
-		`data-submit-once`,
-		`data-submit-button`,
-		`action="/posts/` + root.ID + `/edit"`,
-		`action="/posts/` + homeownerReply.ID + `/edit"`,
-		`href="/questions/` + root.ID + `#post-` + root.ID + `"`,
-		`href="/questions/` + root.ID + `#post-` + homeownerReply.ID + `"`,
-		`href="/questions/` + root.ID + `#post-` + adminReply.ID + `"`,
-		`>The model number is 123A.</textarea>`,
-		`removeAttribute('open')`,
-	} {
-		if !strings.Contains(body, want) {
-			t.Fatalf("question page missing %q: %s", want, body)
-		}
-	}
-	if got := strings.Count(body, ">Permalink</a>"); got != 3 {
-		t.Fatalf("question page rendered %d permalinks, want 3: %s", got, body)
-	}
-	if strings.Contains(body, `action="/posts/`+adminReply.ID+`/edit"`) {
-		t.Fatalf("homeowner can edit admin reply: %s", body)
-	}
-
-	rec = httptest.NewRecorder()
-	req = httptest.NewRequest(http.MethodGet, "/questions/"+root.ID, nil)
-	for _, cookie := range adminCookies {
-		req.AddCookie(cookie)
-	}
-	handler.ServeHTTP(rec, req)
-	if rec.Code != http.StatusOK ||
-		!strings.Contains(rec.Body.String(), `action="/posts/`+adminReply.ID+`/edit"`) ||
-		strings.Contains(rec.Body.String(), `action="/posts/`+root.ID+`/edit"`) {
-		t.Fatalf("admin edit controls are incorrect: %d %s", rec.Code, rec.Body.String())
-	}
-}
-
-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
-}
-
-func csrfForCookies(t *testing.T, handler http.Handler, cookies []*http.Cookie) string {
-	t.Helper()
-	req := httptest.NewRequest(http.MethodGet, "/submit", nil)
-	for _, cookie := range cookies {
-		req.AddCookie(cookie)
-	}
-	rec := httptest.NewRecorder()
-	handler.ServeHTTP(rec, req)
-	if rec.Code != http.StatusOK {
-		t.Fatalf("load CSRF form status = %d", rec.Code)
-	}
-	csrf := csrfFrom(rec.Body.String())
-	if csrf == "" {
-		t.Fatal("CSRF token missing")
-	}
-	return csrf
-}
-
-func postForm(
-	handler http.Handler,
-	path string,
-	values url.Values,
-	cookies []*http.Cookie,
-) *httptest.ResponseRecorder {
-	req := httptest.NewRequest(http.MethodPost, path, strings.NewReader(values.Encode()))
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	for _, cookie := range cookies {
-		req.AddCookie(cookie)
-	}
-	rec := httptest.NewRecorder()
-	handler.ServeHTTP(rec, req)
-	return rec
-}

internal/web/profile.go

@@ -2,7 +2,6 @@ package web
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"image"
 	"image/jpeg"
@@ -23,12 +22,11 @@ import (
 type profilePage struct {
 	page
 	States         []struct{ Code, Name string }
-	Posts          []store.Post
+	Questions      []store.RankedQuestion
 	QuestionsLabel string
 	UploadsEnabled bool
 	Error          string
 	StateVal       string
-	EmailVal       string
 }
 
 func (s *Server) handleProfileForm(w http.ResponseWriter, r *http.Request) {
@@ -37,7 +35,7 @@ func (s *Server) handleProfileForm(w http.ResponseWriter, r *http.Request) {
 		http.Redirect(w, r, "/login?next=/profile", http.StatusSeeOther)
 		return
 	}
-	s.renderProfile(w, r, u, "", u.State, u.Email)
+	s.renderProfile(w, r, u, "", u.State)
 }
 
 func (s *Server) handleProfile(w http.ResponseWriter, r *http.Request) {
@@ -47,7 +45,7 @@ func (s *Server) handleProfile(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	if err := r.ParseMultipartForm(3 << 20); err != nil {
-		s.renderProfile(w, r, u, "Could not read form (max 2MB for images).", u.State, u.Email)
+		s.renderProfile(w, r, u, "Could not read form (max 2MB for images).", u.State)
 		return
 	}
 	want := s.sessions.GetString(r.Context(), "csrf")
@@ -59,12 +57,7 @@ func (s *Server) handleProfile(w http.ResponseWriter, r *http.Request) {
 
 	state := geo.NormalizeState(r.FormValue("state"))
 	if !geo.ValidState(state) {
-		s.renderProfile(w, r, u, "Choose a valid US state or leave it blank.", state, r.FormValue("email"))
-		return
-	}
-	email, emailErr := store.ValidateEmail(r.FormValue("email"))
-	if emailErr != "" {
-		s.renderProfile(w, r, u, emailErr, state, r.FormValue("email"))
+		s.renderProfile(w, r, u, "Choose a valid US state or leave it blank.", state)
 		return
 	}
 
@@ -74,16 +67,16 @@ func (s *Server) handleProfile(w http.ResponseWriter, r *http.Request) {
 	if err == nil {
 		defer file.Close()
 		if !s.cfg.Blob.Enabled() {
-			s.renderProfile(w, r, u, "Avatar uploads are not configured on this server.", state, email)
+			s.renderProfile(w, r, u, "Avatar uploads are not configured on this server.", state)
 			return
 		}
 		if hdr.Size > 2<<20 {
-			s.renderProfile(w, r, u, "Avatar must be 2MB or smaller.", state, email)
+			s.renderProfile(w, r, u, "Avatar must be 2MB or smaller.", state)
 			return
 		}
 		body, ext, contentType, prepErr := prepareAvatar(file, 2<<20)
 		if prepErr != nil {
-			s.renderProfile(w, r, u, "Avatar must be a JPEG, PNG, or WebP image.", state, email)
+			s.renderProfile(w, r, u, "Avatar must be a JPEG, PNG, or WebP image.", state)
 			return
 		}
 		prevURL := u.AvatarURL
@@ -95,19 +88,14 @@ func (s *Server) handleProfile(w http.ResponseWriter, r *http.Request) {
 			Size:        int64(len(body)),
 		})
 		if upErr != nil {
-			s.renderProfile(w, r, u, "Could not upload avatar. Try again later.", state, email)
+			s.renderProfile(w, r, u, "Could not upload avatar. Try again later.", state)
 			return
 		}
 		avatarURL = url
 		u.State = state
-		u.Email = email
 		u.AvatarURL = avatarURL
 		if err := s.store.SaveUserProfile(r.Context(), u); err != nil {
 			_ = s.cfg.Blob.Delete(r.Context(), avatarKey)
-			if errors.Is(err, store.ErrDuplicateEmail) {
-				s.renderProfile(w, r, u, "That email is already registered.", state, email)
-				return
-			}
 			http.Error(w, "could not save profile", http.StatusInternalServerError)
 			return
 		}
@@ -118,17 +106,12 @@ func (s *Server) handleProfile(w http.ResponseWriter, r *http.Request) {
 		http.Redirect(w, r, "/profile", http.StatusSeeOther)
 		return
 	} else if err != http.ErrMissingFile {
-		s.renderProfile(w, r, u, "Could not read avatar file.", state, email)
+		s.renderProfile(w, r, u, "Could not read avatar file.", state)
 		return
 	}
 
 	u.State = state
-	u.Email = email
 	if err := s.store.SaveUserProfile(r.Context(), u); err != nil {
-		if errors.Is(err, store.ErrDuplicateEmail) {
-			s.renderProfile(w, r, u, "That email is already registered.", state, email)
-			return
-		}
 		http.Error(w, "could not save profile", http.StatusInternalServerError)
 		return
 	}
@@ -253,18 +236,18 @@ func fitAvatar(img image.Image, maxDim int) image.Image {
 	return dst
 }
 
-func (s *Server) renderProfile(w http.ResponseWriter, r *http.Request, u *store.User, errMsg, stateVal, emailVal string) {
+func (s *Server) renderProfile(w http.ResponseWriter, r *http.Request, u *store.User, errMsg, stateVal string) {
 	var (
-		posts []store.Post
-		label string
-		err   error
+		questions []store.RankedQuestion
+		label     string
+		err       error
 	)
 	if u.Admin() {
 		label = "Questions you answered"
-		posts, err = s.store.ListRootPostsAnsweredBy(r.Context(), u.ID)
+		questions, err = s.store.ListQuestionsAnsweredBy(r.Context(), u.ID)
 	} else {
 		label = "Your questions"
-		posts, err = s.store.ListRootPostsByAuthor(r.Context(), u.ID)
+		questions, err = s.store.ListQuestionsByAuthor(r.Context(), u.ID)
 	}
 	if err != nil {
 		http.Error(w, "could not load questions", http.StatusInternalServerError)
@@ -275,11 +258,10 @@ func (s *Server) renderProfile(w http.ResponseWriter, r *http.Request, u *store.
 	s.exec(w, "profile", profilePage{
 		page:           p,
 		States:         geo.States,
-		Posts:          posts,
+		Questions:      questions,
 		QuestionsLabel: label,
 		UploadsEnabled: s.cfg.Blob.Enabled(),
 		Error:          errMsg,
 		StateVal:       stateVal,
-		EmailVal:       emailVal,
 	})
 }

internal/web/server.go

@@ -3,6 +3,7 @@ package web
 import (
 	"context"
 	"crypto/rand"
+	"database/sql"
 	"encoding/hex"
 	"errors"
 	"fmt"
@@ -21,7 +22,6 @@ import (
 
 	"plumber/internal/blob"
 	"plumber/internal/geo"
-	"plumber/internal/mail"
 	"plumber/internal/pacific"
 	"plumber/internal/store"
 )
@@ -34,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
 }
 
 type Server struct {
@@ -63,12 +62,13 @@ type huntPage struct {
 	Label       string
 	IsToday     bool
 	IsYesterday bool
-	Posts       []*store.Post
+	Questions   []store.RankedQuestion
 }
 
 type questionPage struct {
 	page
-	Question *store.Post
+	Question *store.RankedQuestion
+	Answer   *store.Answer
 }
 
 type submitPage struct {
@@ -82,56 +82,29 @@ type submitPage struct {
 type authPage struct {
 	page
 	Username string
-	Email    string
 	Error    string
 	Next     string
 }
 
 type voteCtx struct {
-	User *store.User
-	CSRF string
-	View string
-	Date string
-	Post *store.Post
-}
-
-type threadPostCtx struct {
-	User  *store.User
-	CSRF  string
-	Root  *store.Post
-	Post  *store.Post
-	Depth int
+	User     *store.User
+	CSRF     string
+	View     string
+	Date     string
+	Question store.RankedQuestion
 }
 
 func New(st store.Store, sessionStore scs.Store, templateFS fs.FS, staticFS fs.FS, cfg Config) (*Server, error) {
 	if cfg.Blob == nil {
 		cfg.Blob = blob.Disabled{}
 	}
-	if cfg.Mail == nil {
-		cfg.Mail = mail.Nop{}
-	}
 	funcMap := template.FuncMap{
-		"voteCtx": func(user *store.User, csrf, view, date string, post *store.Post) voteCtx {
-			return voteCtx{User: user, CSRF: csrf, View: view, Date: date, Post: post}
-		},
-		"postCtx": func(user *store.User, csrf string, root, post *store.Post, depth int) threadPostCtx {
-			return threadPostCtx{User: user, CSRF: csrf, Root: root, Post: post, Depth: depth}
-		},
-		"add":         func(a, b int) int { return a + b },
-		"rank":        func(i int) int { return i + 1 },
-		"isAdmin":     func(u *store.User) bool { return u.Admin() },
-		"canReply":    canReplyToThread,
-		"canEditPost": canEditPost,
-		"postLabel":   postLabel,
-		"postDepth":   postDepthClass,
-		"isEdited":    func(post *store.Post) bool { return post != nil && post.UpdatedAt != post.CreatedAt },
-		"postTime": func(value string) string {
-			t, err := time.Parse(time.RFC3339Nano, value)
-			if err != nil {
-				return value
-			}
-			return t.In(pacific.Loc).Format("Jan 2, 2006 · 3:04 PM")
+		"voteCtx": func(user *store.User, csrf, view, date string, q store.RankedQuestion) voteCtx {
+			return voteCtx{User: user, CSRF: csrf, View: view, Date: date, Question: q}
 		},
+		"add":          func(a, b int) int { return a + b },
+		"rank":         func(i int) int { return i + 1 },
+		"isAdmin":      func(u *store.User) bool { return u.Admin() },
 		"pacificLabel": pacific.Label,
 		"locationTag": func(u *store.User) string {
 			if u != nil {
@@ -196,9 +169,8 @@ func (s *Server) Handler() http.Handler {
 	r.Post("/submit", s.handleSubmit)
 	r.Get("/questions/{id}", s.handleQuestion)
 	r.Post("/questions/{id}/vote", s.handleVote)
+	r.Post("/questions/{id}/answer", s.handleAnswer)
 	r.Post("/questions/{id}/hide", s.handleHide)
-	r.Post("/posts", s.handleCreatePost)
-	r.Post("/posts/{id}/edit", s.handleEditPost)
 	r.Get("/login", s.handleLoginForm)
 	r.Post("/login", s.handleLogin)
 	r.Get("/register", s.handleRegisterForm)
@@ -301,7 +273,7 @@ func (s *Server) renderHunt(w http.ResponseWriter, r *http.Request, date string)
 	if u := currentUser(r); u != nil {
 		viewer = u.ID
 	}
-	posts, err := s.store.ListRootPosts(r.Context(), date, viewer)
+	questions, err := s.store.ListHunt(r.Context(), date, viewer)
 	if err != nil {
 		http.Error(w, "could not load questions", http.StatusInternalServerError)
 		return
@@ -317,7 +289,7 @@ func (s *Server) renderHunt(w http.ResponseWriter, r *http.Request, date string)
 		Label:       label,
 		IsToday:     pacific.IsToday(date),
 		IsYesterday: pacific.IsYesterday(date),
-		Posts:       postPointers(posts),
+		Questions:   questions,
 	})
 }
 
@@ -361,17 +333,17 @@ func (s *Server) handleSubmit(w http.ResponseWriter, r *http.Request) {
 	if len(city) > 80 {
 		city = truncateRunes(city, 80)
 	}
-	post := &store.Post{
+	q := &store.RankedQuestion{
 		AuthorID: u.ID,
 		Title:    title,
 		Body:     body,
 		City:     city,
 	}
-	if err := s.store.CreatePost(r.Context(), post); err != nil {
+	if err := s.store.CreateQuestion(r.Context(), q); err != nil {
 		http.Error(w, "could not save question", http.StatusInternalServerError)
 		return
 	}
-	http.Redirect(w, r, "/questions/"+url.PathEscape(post.ID), http.StatusSeeOther)
+	http.Redirect(w, r, "/questions/"+url.PathEscape(q.ID), http.StatusSeeOther)
 }
 
 func (s *Server) handleQuestion(w http.ResponseWriter, r *http.Request) {
@@ -380,14 +352,29 @@ func (s *Server) handleQuestion(w http.ResponseWriter, r *http.Request) {
 	if u := currentUser(r); u != nil {
 		viewer = u.ID
 	}
-	post, err := s.store.GetPostThreadForViewer(r.Context(), id, viewer)
-	if err != nil || (post.PostState == store.PostStateHidden && !currentUser(r).Admin()) {
+	q, err := s.store.GetQuestion(r.Context(), id, viewer)
+	if err != nil || (q.Hidden && !currentUser(r).Admin()) {
 		http.NotFound(w, r)
 		return
 	}
+	var ans *store.Answer
+	if q.Answered {
+		ans, err = s.store.GetAnswer(r.Context(), q.ID)
+		if err != nil {
+			if errors.Is(err, sql.ErrNoRows) {
+				log.Printf("question %s marked answered but answer missing", q.ID)
+				http.Error(w, "answer unavailable", http.StatusInternalServerError)
+				return
+			}
+			log.Printf("get answer %s: %v", q.ID, err)
+			http.Error(w, "could not load answer", http.StatusInternalServerError)
+			return
+		}
+	}
 	s.exec(w, "question", questionPage{
-		page:     s.basePage(r, post.Title),
-		Question: post,
+		page:     s.basePage(r, q.Title),
+		Question: q,
+		Answer:   ans,
 	})
 }
 
@@ -417,8 +404,8 @@ func (s *Server) handleVote(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "invalid vote", http.StatusBadRequest)
 		return
 	}
-	if err := s.store.VotePost(r.Context(), u.ID, id, value); err != nil {
-		if errors.Is(err, store.ErrPostNotVotable) {
+	if err := s.store.Vote(r.Context(), u.ID, id, value); err != nil {
+		if errors.Is(err, store.ErrHiddenOrMissing) {
 			http.Error(w, "not found", http.StatusNotFound)
 			return
 		}
@@ -432,17 +419,17 @@ func (s *Server) handleVote(w http.ResponseWriter, r *http.Request) {
 			s.renderLeaderboard(w, r, date)
 			return
 		}
-		post, err := s.store.GetPostThreadForViewer(r.Context(), id, u.ID)
+		q, err := s.store.GetQuestion(r.Context(), id, u.ID)
 		if err != nil {
 			http.Error(w, "not found", http.StatusNotFound)
 			return
 		}
 		s.exec(w, "vote", voteCtx{
-			User: u,
-			CSRF: s.sessions.GetString(r.Context(), "csrf"),
-			View: "question",
-			Date: post.PostDate,
-			Post: post,
+			User:     u,
+			CSRF:     s.sessions.GetString(r.Context(), "csrf"),
+			View:     "question",
+			Date:     q.HuntDate,
+			Question: *q,
 		})
 		return
 	}
@@ -465,18 +452,57 @@ func (s *Server) renderLeaderboard(w http.ResponseWriter, r *http.Request, date
 	if u := currentUser(r); u != nil {
 		viewer = u.ID
 	}
-	posts, err := s.store.ListRootPosts(r.Context(), date, viewer)
+	questions, err := s.store.ListHunt(r.Context(), date, viewer)
 	if err != nil {
 		http.Error(w, "could not load questions", http.StatusInternalServerError)
 		return
 	}
 	s.exec(w, "leaderboard", huntPage{
-		page:  s.basePage(r, ""),
-		Date:  date,
-		Posts: postPointers(posts),
+		page:      s.basePage(r, ""),
+		Date:      date,
+		Questions: questions,
 	})
 }
 
+func (s *Server) handleAnswer(w http.ResponseWriter, r *http.Request) {
+	if !s.requireCSRF(w, r) {
+		return
+	}
+	u := currentUser(r)
+	if !u.Admin() {
+		http.Error(w, "forbidden", http.StatusForbidden)
+		return
+	}
+	id := chi.URLParam(r, "id")
+	body := strings.TrimSpace(r.PostFormValue("body"))
+	if body == "" {
+		http.Error(w, "answer required", http.StatusBadRequest)
+		return
+	}
+	if len(body) > 12000 {
+		body = truncateRunes(body, 12000)
+	}
+	ans := &store.Answer{
+		QuestionID: id,
+		AuthorID:   u.ID,
+		Body:       body,
+	}
+	if err := s.store.UpsertAnswer(r.Context(), ans); err != nil {
+		http.Error(w, "could not save answer", http.StatusInternalServerError)
+		return
+	}
+	saved, err := s.store.GetAnswer(r.Context(), id)
+	if err != nil {
+		http.Error(w, "could not load answer", http.StatusInternalServerError)
+		return
+	}
+	if isHTMX(r) {
+		s.exec(w, "answer", questionPage{page: s.basePage(r, ""), Answer: saved})
+		return
+	}
+	http.Redirect(w, r, "/questions/"+url.PathEscape(id), http.StatusSeeOther)
+}
+
 func (s *Server) handleHide(w http.ResponseWriter, r *http.Request) {
 	if !s.requireCSRF(w, r) {
 		return
@@ -487,17 +513,17 @@ func (s *Server) handleHide(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	id := chi.URLParam(r, "id")
-	post, err := s.store.GetPost(r.Context(), id)
-	if err != nil || post.ParentID != nil {
+	q, err := s.store.GetQuestion(r.Context(), id, u.ID)
+	if err != nil {
 		http.NotFound(w, r)
 		return
 	}
-	if err := s.store.SetRootPostState(r.Context(), id, store.PostStateHidden); err != nil {
+	if err := s.store.HideQuestion(r.Context(), id); err != nil {
 		http.Error(w, "could not hide", http.StatusInternalServerError)
 		return
 	}
 	if isHTMX(r) && r.PostFormValue("view") == "list" {
-		s.renderLeaderboard(w, r, post.PostDate)
+		s.renderLeaderboard(w, r, q.HuntDate)
 		return
 	}
 	if isHTMX(r) {

internal/web/server_test.go

@@ -53,7 +53,6 @@ func seedUser(t *testing.T, st store.Store, username, password string, role stor
 	}
 	u := &store.User{
 		Username:     username,
-		Email:        username + "@example.com",
 		PasswordHash: string(hash),
 		Role:         role,
 	}
@@ -115,7 +114,7 @@ func registerUser(t *testing.T, h http.Handler, username, password string, setup
 	pre := rec.Result().Cookies()
 	preToken := sessionValue(pre)
 	csrf := csrfFrom(rec.Body.String())
-	form := "_csrf=" + csrf + "&username=" + username + "&email=" + username + "%40example.com&password=" + password
+	form := "_csrf=" + csrf + "&username=" + username + "&password=" + password
 	if len(setupSecret) > 0 && setupSecret[0] != "" {
 		form += "&setup_secret=" + setupSecret[0]
 	}
@@ -168,16 +167,6 @@ func TestRegisterLoginAsk(t *testing.T) {
 	if rec.Code != 200 {
 		t.Fatalf("submit form %d", rec.Code)
 	}
-	for _, want := range []string{
-		`src="/static/app.js"`,
-		`id="submit-progress"`,
-		`data-submit-once`,
-		`data-submit-button`,
-	} {
-		if !strings.Contains(rec.Body.String(), want) {
-			t.Fatalf("submit form missing %q: %s", want, rec.Body.String())
-		}
-	}
 	csrf := csrfFrom(rec.Body.String())
 	form := strings.NewReader("_csrf=" + csrf + "&title=Leaky+faucet&body=Drip+all+night.&city=Oakland")
 	req = httptest.NewRequest(http.MethodPost, "/submit", form)
@@ -373,7 +362,6 @@ func TestProfilePageAndState(t *testing.T) {
 	var buf bytes.Buffer
 	w := multipart.NewWriter(&buf)
 	_ = w.WriteField("_csrf", csrf)
-	_ = w.WriteField("email", name+"@example.com")
 	_ = w.WriteField("state", "CA")
 	_ = w.Close()
 	req = httptest.NewRequest(http.MethodPost, "/profile", &buf)
@@ -401,7 +389,6 @@ func TestProfilePageAndState(t *testing.T) {
 	buf.Reset()
 	w = multipart.NewWriter(&buf)
 	_ = w.WriteField("_csrf", csrf)
-	_ = w.WriteField("email", name+"@example.com")
 	_ = w.WriteField("state", "ZZ")
 	_ = w.Close()
 	req = httptest.NewRequest(http.MethodPost, "/profile", &buf)
@@ -426,21 +413,21 @@ func TestProfileAdminAnsweredListAndAvatarUpload(t *testing.T) {
 	alice := seedUser(t, mem, aliceName, "hunter22", store.RoleUser)
 	adminCookies := loginUser(t, h, hubName, "hunter22")
 
-	root := &store.Post{
+	q := &store.RankedQuestion{
 		AuthorID: alice.ID,
 		Title:    "Drip",
 		Body:     "Under sink",
 		City:     "Oakland",
 	}
-	if err := mem.CreatePost(context.Background(), root); err != nil {
+	if err := mem.CreateQuestion(context.Background(), q); err != nil {
 		t.Fatal(err)
 	}
-	reply := &store.Post{
-		ParentID: &root.ID,
-		AuthorID: hub.ID,
-		Body:     "Replace the cartridge.",
+	ans := &store.Answer{
+		QuestionID: q.ID,
+		AuthorID:   hub.ID,
+		Body:       "Replace the cartridge.",
 	}
-	if err := mem.CreatePost(context.Background(), reply); err != nil {
+	if err := mem.UpsertAnswer(context.Background(), ans); err != nil {
 		t.Fatal(err)
 	}
 
@@ -462,7 +449,6 @@ func TestProfileAdminAnsweredListAndAvatarUpload(t *testing.T) {
 	var buf bytes.Buffer
 	w := multipart.NewWriter(&buf)
 	_ = w.WriteField("_csrf", csrf)
-	_ = w.WriteField("email", hubName+"@example.com")
 	_ = w.WriteField("state", "OR")
 	part, err := w.CreateFormFile("avatar", "pic.png")
 	if err != nil {
@@ -492,24 +478,24 @@ func TestProfileAdminAnsweredListAndAvatarUpload(t *testing.T) {
 	}
 }
 
-func TestMutationsVoteHideAndCSRF(t *testing.T) {
+func TestMutationsVoteAnswerHideAndCSRF(t *testing.T) {
 	srv, mem := newTestServer(t, Config{})
 	h := srv.Handler()
 	adminName := uniq("admin")
 	userName := uniq("user")
-	seedUser(t, mem, adminName, "hunter22", store.RoleAdmin)
+	admin := seedUser(t, mem, adminName, "hunter22", store.RoleAdmin)
 	user := seedUser(t, mem, userName, "hunter22", store.RoleUser)
 	adminCookies := loginUser(t, h, adminName, "hunter22")
 	userCookies := loginUser(t, h, userName, "hunter22")
 
-	q := &store.Post{
+	q := &store.RankedQuestion{
 		AuthorID: user.ID,
 		Title:    "Pipe noise",
 		Body:     "Clanking",
 		City:     "SF",
-		PostDate: pacific.Today(),
+		HuntDate: pacific.Today(),
 	}
-	if err := mem.CreatePost(context.Background(), q); err != nil {
+	if err := mem.CreateQuestion(context.Background(), q); err != nil {
 		t.Fatal(err)
 	}
 
@@ -565,16 +551,53 @@ func TestMutationsVoteHideAndCSRF(t *testing.T) {
 	if rec.Code != 200 {
 		t.Fatalf("vote htmx %d %s", rec.Code, rec.Body.String())
 	}
-	got, err := mem.GetPostThreadForViewer(context.Background(), q.ID, user.ID)
+	got, err := mem.GetQuestion(context.Background(), q.ID, user.ID)
 	if err != nil || got.UserVote != 1 || got.Score != 1 {
 		t.Fatalf("vote not applied: %+v %v", got, err)
 	}
 
+	// Non-admin answer rejected
 	rec = httptest.NewRecorder()
-	req = httptest.NewRequest(http.MethodPost, "/questions/"+q.ID+"/answer", nil)
+	req = httptest.NewRequest(http.MethodGet, "/questions/"+q.ID, nil)
+	for _, c := range userCookies {
+		req.AddCookie(c)
+	}
 	h.ServeHTTP(rec, req)
-	if rec.Code != http.StatusNotFound {
-		t.Fatalf("removed answer endpoint want 404, got %d", rec.Code)
+	csrf = csrfFrom(rec.Body.String())
+	form = strings.NewReader("_csrf=" + csrf + "&body=Nope")
+	req = httptest.NewRequest(http.MethodPost, "/questions/"+q.ID+"/answer", form)
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	for _, c := range userCookies {
+		req.AddCookie(c)
+	}
+	rec = httptest.NewRecorder()
+	h.ServeHTTP(rec, req)
+	if rec.Code != http.StatusForbidden {
+		t.Fatalf("non-admin answer want 403, got %d", rec.Code)
+	}
+
+	// Admin answer success (HTMX)
+	rec = httptest.NewRecorder()
+	req = httptest.NewRequest(http.MethodGet, "/questions/"+q.ID, nil)
+	for _, c := range adminCookies {
+		req.AddCookie(c)
+	}
+	h.ServeHTTP(rec, req)
+	csrf = csrfFrom(rec.Body.String())
+	form = strings.NewReader("_csrf=" + csrf + "&body=Tighten+the+nuts.")
+	req = httptest.NewRequest(http.MethodPost, "/questions/"+q.ID+"/answer", form)
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("HX-Request", "true")
+	for _, c := range adminCookies {
+		req.AddCookie(c)
+	}
+	rec = httptest.NewRecorder()
+	h.ServeHTTP(rec, req)
+	if rec.Code != 200 || !strings.Contains(rec.Body.String(), "Tighten the nuts") {
+		t.Fatalf("admin answer: %d %s", rec.Code, rec.Body.String())
+	}
+	if _, err := mem.GetAnswer(context.Background(), q.ID); err != nil {
+		t.Fatal(err)
 	}
 
 	// Hide invalid id
@@ -609,8 +632,8 @@ func TestMutationsVoteHideAndCSRF(t *testing.T) {
 	if rec.Code != http.StatusSeeOther {
 		t.Fatalf("hide %d %s", rec.Code, rec.Body.String())
 	}
-	hidden, err := mem.GetPost(context.Background(), q.ID)
-	if err != nil || hidden.PostState != store.PostStateHidden {
+	hidden, err := mem.GetQuestion(context.Background(), q.ID, admin.ID)
+	if err != nil || !hidden.Hidden {
 		t.Fatalf("question not hidden: %+v %v", hidden, err)
 	}
 }
@@ -643,26 +666,6 @@ func csrfFrom(html string) string {
 	return html[:j]
 }
 
-func TestRegisterRequiresEmail(t *testing.T) {
-	srv, _ := newTestServer(t, Config{})
-	h := srv.Handler()
-	rec := httptest.NewRecorder()
-	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/register", nil))
-	csrf := csrfFrom(rec.Body.String())
-	cookies := rec.Result().Cookies()
-	form := strings.NewReader("_csrf=" + csrf + "&username=" + uniq("noem") + "&email=bad&password=hunter22")
-	req := httptest.NewRequest(http.MethodPost, "/register", form)
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	for _, c := range cookies {
-		req.AddCookie(c)
-	}
-	rec = httptest.NewRecorder()
-	h.ServeHTTP(rec, req)
-	if rec.Code != 200 || !strings.Contains(rec.Body.String(), "valid email") {
-		t.Fatalf("want email validation error, got %d %s", rec.Code, rec.Body.String())
-	}
-}
-
 // TestRegisterThrottleUsesTCPPeerThroughRouter ensures forged X-Forwarded-For
 // cannot bypass rate limits when the direct peer is outside TrustedProxies.
 // This must go through Handler() so middleware ordering bugs are caught.

schema.sql

@@ -4,53 +4,38 @@ CREATE TABLE IF NOT EXISTS users (
   name TEXT NOT NULL,
   password_hash TEXT NOT NULL,
   role TEXT NOT NULL DEFAULT 'user' CHECK (role IN ('user', 'admin')),
-  email TEXT NOT NULL DEFAULT '',
   avatar_url TEXT NOT NULL DEFAULT '',
   state TEXT NOT NULL DEFAULT '',
   created_at TEXT NOT NULL
 );
 
-CREATE UNIQUE INDEX IF NOT EXISTS users_email_lower_uidx
-  ON users (lower(email))
-  WHERE email <> '';
-
-CREATE TABLE IF NOT EXISTS posts (
+CREATE TABLE IF NOT EXISTS questions (
   id TEXT PRIMARY KEY,
-  parent_id TEXT REFERENCES posts(id) ON DELETE CASCADE,
   author_id TEXT NOT NULL REFERENCES users(id),
-  title TEXT NOT NULL DEFAULT '',
+  title TEXT NOT NULL,
   body TEXT NOT NULL,
   city TEXT NOT NULL DEFAULT '',
-  post_date TEXT NOT NULL DEFAULT '',
-  post_state TEXT NOT NULL,
-  created_at TEXT NOT NULL,
-  updated_at TEXT NOT NULL,
-  CONSTRAINT posts_shape_check CHECK (
-    (parent_id IS NULL AND title <> '' AND post_date <> '')
-    OR
-    (parent_id IS NOT NULL AND title = '' AND city = '' AND post_date = '')
-  )
+  hunt_date TEXT NOT NULL,
+  hidden INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL
 );
 
-CREATE INDEX IF NOT EXISTS idx_posts_parent_created
-  ON posts(parent_id, created_at, id);
+CREATE INDEX IF NOT EXISTS idx_questions_hunt_date ON questions(hunt_date, hidden);
 
-CREATE INDEX IF NOT EXISTS idx_posts_author_created
-  ON posts(author_id, created_at DESC, id DESC);
-
-CREATE INDEX IF NOT EXISTS idx_posts_root_date
-  ON posts(post_date, post_state)
-  WHERE parent_id IS NULL;
-
-CREATE TABLE IF NOT EXISTS post_votes (
+CREATE TABLE IF NOT EXISTS votes (
   user_id TEXT NOT NULL REFERENCES users(id),
-  post_id TEXT NOT NULL REFERENCES posts(id) ON DELETE CASCADE,
+  question_id TEXT NOT NULL REFERENCES questions(id) ON DELETE CASCADE,
   value INTEGER NOT NULL CHECK (value IN (-1, 1)),
-  PRIMARY KEY (user_id, post_id)
+  PRIMARY KEY (user_id, question_id)
 );
 
-CREATE INDEX IF NOT EXISTS idx_post_votes_post_id
-  ON post_votes(post_id);
+CREATE TABLE IF NOT EXISTS answers (
+  question_id TEXT PRIMARY KEY REFERENCES questions(id) ON DELETE CASCADE,
+  author_id TEXT NOT NULL REFERENCES users(id),
+  body TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
 
 CREATE TABLE IF NOT EXISTS sessions (
   token TEXT PRIMARY KEY,

static/app.css

@@ -41,31 +41,6 @@ body {
   background-size: 100% 100%, 48px 48px;
 }
 
-.submit-progress {
-  position: fixed;
-  inset: 0 0 auto;
-  z-index: 100;
-  height: 3px;
-  overflow: hidden;
-  pointer-events: none;
-}
-
-.submit-progress[hidden] { display: none; }
-
-.submit-progress-bar {
-  display: block;
-  width: 35%;
-  height: 100%;
-  background: var(--signal);
-  box-shadow: 0 0 12px var(--signal);
-  animation: submit-progress 900ms ease-in-out infinite;
-}
-
-@keyframes submit-progress {
-  from { transform: translateX(-100%); }
-  to { transform: translateX(300%); }
-}
-
 img, svg { display: block; }
 
 a {
@@ -278,12 +253,6 @@ a {
 
 .btn-primary:hover { filter: brightness(1.08); }
 
-.btn:disabled {
-  cursor: wait;
-  opacity: 0.65;
-  filter: none;
-}
-
 .btn-ghost {
   background: transparent;
   color: var(--ink);
@@ -583,14 +552,12 @@ input:focus, textarea:focus, .btn:focus-visible, .chip:focus-visible, .vote-btn:
   padding: 18px 14px;
 }
 
-.post-content { min-width: 0; }
-
 .question-page h1 {
   font-size: clamp(1.5rem, 3.5vw, 2.1rem);
   line-height: 1.15;
 }
 
-.post-body {
+.q-body, .answer-body {
   white-space: pre-wrap;
   margin: 14px 0 0;
   text-wrap: pretty;
@@ -607,7 +574,18 @@ input:focus, textarea:focus, .btn:focus-visible, .chip:focus-visible, .vote-btn:
 }
 .crumb a:hover { color: var(--signal); }
 
-.post-kicker {
+.answer {
+  margin-top: 16px;
+  padding: 20px 18px;
+  background: var(--panel);
+  border: 1px solid var(--line);
+}
+
+.answer.is-in {
+  border-color: var(--signal);
+}
+
+.answer-kicker {
   margin: 0 0 6px;
   font-family: var(--mono);
   text-transform: uppercase;
@@ -617,147 +595,21 @@ input:focus, textarea:focus, .btn:focus-visible, .chip:focus-visible, .vote-btn:
   color: var(--signal);
 }
 
-.conversation {
-  margin-top: 32px;
-}
-
-.conversation-head {
-  margin-bottom: 12px;
-  padding-bottom: 12px;
-  border-bottom: 1px solid var(--line);
-}
-
-.conversation h2 {
+.answer h2 {
   margin: 0;
-  font-size: 1.25rem;
+  font-size: 1.15rem;
   font-weight: 500;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
 }
 
-.conversation-head .eyebrow {
-  margin-bottom: 5px;
-}
-
-.thread {
-  display: grid;
-  gap: 12px;
-}
-
-.thread-post {
-  position: relative;
-  padding: 16px;
-  background: var(--panel);
-  border: 1px solid var(--line);
-  border-left: 2px solid var(--zinc);
-  overflow-wrap: anywhere;
-}
-
-.thread-post.is-shop {
-  border-left-color: var(--signal);
-}
-
-.thread-post:target,
-.q-detail:target {
-  outline: 2px solid var(--signal);
-  outline-offset: 3px;
-}
-
-.thread-post-branch,
-.thread-post-deep {
-  margin-left: clamp(12px, 4vw, 28px);
-}
-
-.thread-post-deep .thread-post-deep {
-  margin-left: 0;
-}
-
-.post-replies {
-  display: grid;
-  gap: 12px;
-  margin-top: 12px;
-}
-
-.post-meta {
+.byline {
   margin: 6px 0 0;
   color: var(--muted);
   font-family: var(--mono);
   font-size: 0.72rem;
 }
 
-.edited {
-  display: inline-block;
-  margin-left: 8px;
-  color: var(--zinc);
-  font-size: 0.65rem;
-  letter-spacing: 0.06em;
-  text-transform: uppercase;
-}
-
-.post-actions {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: flex-start;
-  gap: 0 16px;
-  margin-top: 10px;
-  border-top: 1px solid var(--line);
-}
-
-.post-composer {
-  min-width: 0;
-}
-
-.post-composer[open] {
-  flex: 1 0 100%;
-}
-
-.post-composer summary {
-  display: flex;
-  width: fit-content;
-  min-height: 44px;
-  align-items: center;
-  color: var(--muted);
-  font-family: var(--mono);
-  font-size: 0.72rem;
-  letter-spacing: 0.06em;
-  text-transform: uppercase;
-  text-decoration: underline;
-  cursor: pointer;
-  list-style: none;
-}
-
-.post-composer summary::-webkit-details-marker { display: none; }
-.post-composer summary::marker { content: ""; }
-.post-composer summary:hover,
-.post-composer[open] summary { color: var(--signal); }
-.post-composer summary:focus-visible {
-  outline: 2px solid var(--signal);
-  outline-offset: 2px;
-}
-
-.post-form {
-  display: flex;
-  flex-direction: column;
-  gap: 8px;
-  width: 100%;
-  margin: 0 0 14px;
-}
-
-.post-form-actions {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 8px;
-}
-
-.post-form-actions .btn { flex: 1 1 10rem; }
-
-.post-permalink {
-  display: inline-flex;
-  align-items: center;
-}
-
-.post-hide {
-  margin: 0;
-}
-
 .waiting { color: var(--muted); margin: 0; font-family: var(--mono); font-size: 0.8rem; }
 
 .auth-wrap {
@@ -799,10 +651,6 @@ input:focus, textarea:focus, .btn:focus-visible, .chip:focus-visible, .vote-btn:
 
 @media (prefers-reduced-motion: reduce) {
   .btn-primary:hover { filter: none; }
-  .submit-progress-bar {
-    width: 100%;
-    animation: none;
-  }
 }
 
 .admin-users { margin-top: 20px; overflow-x: auto; }

static/app.js

@@ -1,58 +0,0 @@
-(() => {
-  const formSelector = "form[data-submit-once]";
-
-  function progressIndicator() {
-    return document.getElementById("submit-progress");
-  }
-
-  function resetForm(form) {
-    form.removeAttribute("aria-busy");
-    delete form.dataset.submitting;
-
-    const button = form.querySelector("[data-submit-button]");
-    if (!button) {
-      return;
-    }
-    button.disabled = false;
-    button.removeAttribute("aria-disabled");
-    if (button.dataset.idleLabel) {
-      button.textContent = button.dataset.idleLabel;
-      delete button.dataset.idleLabel;
-    }
-  }
-
-  document.addEventListener("submit", (event) => {
-    const form = event.target.closest(formSelector);
-    if (!form) {
-      return;
-    }
-    if (form.dataset.submitting === "true") {
-      event.preventDefault();
-      return;
-    }
-
-    form.dataset.submitting = "true";
-    form.setAttribute("aria-busy", "true");
-
-    const button = event.submitter || form.querySelector("[data-submit-button]");
-    if (button) {
-      button.dataset.idleLabel = button.textContent;
-      button.textContent = form.dataset.submittingLabel || "Posting…";
-      button.disabled = true;
-      button.setAttribute("aria-disabled", "true");
-    }
-
-    const progress = progressIndicator();
-    if (progress) {
-      progress.hidden = false;
-    }
-  });
-
-  window.addEventListener("pageshow", () => {
-    document.querySelectorAll(formSelector).forEach(resetForm);
-    const progress = progressIndicator();
-    if (progress) {
-      progress.hidden = true;
-    }
-  });
-})();

templates/base.html

@@ -11,13 +11,8 @@
   <link href="https://fonts.googleapis.com/css2?family=Archivo:ital,wght@0,400;0,500;0,600;1,400&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
   <link rel="stylesheet" href="/static/app.css">
   <script src="/static/htmx.min.js" defer></script>
-  <script src="/static/app.js" defer></script>
 </head>
 <body>
-  <div id="submit-progress" class="submit-progress" role="progressbar"
-    aria-label="Posting" aria-valuetext="Posting" hidden>
-    <span class="submit-progress-bar"></span>
-  </div>
   <a class="skip" href="#main">Skip to content</a>
   <header class="top">
     <div class="top-inner">

templates/partials/_answer.html

@@ -0,0 +1,12 @@
+{{define "answer"}}
+<section id="answer-block" class="answer{{if .Answer}} is-in{{end}}">
+  {{if .Answer}}
+    <p class="answer-kicker">Shop response</p>
+    <h2>Answer</h2>
+    <p class="byline">{{.Answer.AuthorName}} · 22 years, Bay Area</p>
+    <p class="answer-body">{{.Answer.Body}}</p>
+  {{else}}
+    <p class="waiting">No answer yet. Check back after the hunt.</p>
+  {{end}}
+</section>
+{{end}}

templates/partials/_list.html

@@ -1,6 +1,6 @@
 {{define "leaderboard"}}
 <ol id="leaderboard" class="board" start="1">
-  {{if not .Posts}}
+  {{if not .Questions}}
     <li class="empty">
       {{if eq .Date .Today}}
         <p class="empty-kicker">Queue empty</p>
@@ -10,20 +10,20 @@
       {{end}}
     </li>
   {{else}}
-    {{range $i, $post := .Posts}}
+    {{range $i, $q := .Questions}}
       <li class="row">
         <span class="rank" aria-hidden="true">{{rank $i}}</span>
-        {{template "vote" (voteCtx $.User $.CSRF "list" $.Date $post)}}
+        {{template "vote" (voteCtx $.User $.CSRF "list" $.Date $q)}}
         <div class="row-body">
-          <a class="q-title" href="/questions/{{$post.ID}}">{{$post.Title}}</a>
+          <a class="q-title" href="/questions/{{$q.ID}}">{{$q.Title}}</a>
           <p class="meta">
-            <span>{{$post.AuthorName}}</span>
-            {{if $post.City}}<span class="dot" aria-hidden="true">·</span><span>{{$post.City}}</span>{{end}}
-            {{if $post.Answered}}<span class="badge">Answered</span>{{end}}
+            <span>{{$q.AuthorName}}</span>
+            {{if $q.City}}<span class="dot" aria-hidden="true">·</span><span>{{$q.City}}</span>{{end}}
+            {{if $q.Answered}}<span class="badge">Answered</span>{{end}}
           </p>
           {{if isAdmin $.User}}
-            <form class="inline-hide" method="post" action="/questions/{{$post.ID}}/hide"
-              hx-post="/questions/{{$post.ID}}/hide" hx-target="#leaderboard" hx-swap="outerHTML">
+            <form class="inline-hide" method="post" action="/questions/{{$q.ID}}/hide"
+              hx-post="/questions/{{$q.ID}}/hide" hx-target="#leaderboard" hx-swap="outerHTML">
               <input type="hidden" name="_csrf" value="{{$.CSRF}}">
               <input type="hidden" name="view" value="list">
               <button type="submit" class="linkish">Hide</button>

templates/partials/_post.html

@@ -1,71 +0,0 @@
-{{define "postActions"}}
-<div class="post-actions">
-  {{if canReply .User .Root}}
-    <details class="post-composer">
-      <summary>Reply</summary>
-      <form class="post-form" method="post" action="/posts"
-        data-submit-once data-submitting-label="Posting…">
-        <input type="hidden" name="_csrf" value="{{.CSRF}}">
-        <input type="hidden" name="parent_id" value="{{.Post.ID}}">
-        <label for="reply-{{.Post.ID}}">Reply to {{.Post.AuthorName}}</label>
-        <textarea id="reply-{{.Post.ID}}" name="body" rows="5" required maxlength="12000"></textarea>
-        <div class="post-form-actions">
-          <button type="submit" class="btn btn-primary" data-submit-button>Post reply</button>
-          <button type="reset" class="btn btn-ghost"
-            onclick="this.closest('details').removeAttribute('open')">Cancel</button>
-        </div>
-      </form>
-    </details>
-  {{end}}
-  {{if canEditPost .User .Post}}
-    <details class="post-composer">
-      <summary>Edit</summary>
-      <form class="post-form" method="post" action="/posts/{{.Post.ID}}/edit">
-        <input type="hidden" name="_csrf" value="{{.CSRF}}">
-        <label for="edit-{{.Post.ID}}">Edit post</label>
-        <textarea id="edit-{{.Post.ID}}" name="body" rows="5" required
-          maxlength="12000">{{.Post.Body}}</textarea>
-        <div class="post-form-actions">
-          <button type="submit" class="btn btn-primary">Save changes</button>
-          <button type="reset" class="btn btn-ghost"
-            onclick="this.closest('details').removeAttribute('open')">Cancel</button>
-        </div>
-      </form>
-    </details>
-  {{end}}
-  <a class="linkish post-permalink"
-    href="/questions/{{.Root.ID}}#post-{{.Post.ID}}"
-    aria-label="Permanent link to post by {{.Post.AuthorName}}">Permalink</a>
-  {{if and (not .Post.ParentID) (isAdmin .User)}}
-    <form class="post-hide" method="post" action="/questions/{{.Post.ID}}/hide">
-      <input type="hidden" name="_csrf" value="{{.CSRF}}">
-      <button type="submit" class="linkish">Hide</button>
-    </form>
-  {{end}}
-</div>
-{{end}}
-
-{{define "threadReply"}}
-{{$ctx := .}}
-<article id="post-{{.Post.ID}}"
-  class="thread-post thread-post-{{postDepth .Depth}}{{if eq .Post.AuthorRole "admin"}} is-shop{{end}}">
-  <header class="post-head">
-    <p class="post-kicker">{{postLabel .Post}}</p>
-    <p class="post-meta">
-      <span>{{.Post.AuthorName}}</span>
-      <span class="dot" aria-hidden="true">·</span>
-      <time datetime="{{.Post.CreatedAt}}">{{postTime .Post.CreatedAt}}</time>
-      {{if isEdited .Post}}<span class="edited">Edited</span>{{end}}
-    </p>
-  </header>
-  <p class="post-body">{{.Post.Body}}</p>
-  {{template "postActions" .}}
-  {{if .Post.Replies}}
-    <div class="post-replies">
-      {{range .Post.Replies}}
-        {{template "threadReply" (postCtx $ctx.User $ctx.CSRF $ctx.Root . (add $ctx.Depth 1))}}
-      {{end}}
-    </div>
-  {{end}}
-</article>
-{{end}}

templates/partials/_vote.html

@@ -1,26 +1,26 @@
 {{define "vote"}}
-<div id="vote-{{.Post.ID}}" class="vote">
+<div id="vote-{{.Question.ID}}" class="vote">
   {{if .User}}
-    <form method="post" action="/questions/{{.Post.ID}}/vote"
-      hx-post="/questions/{{.Post.ID}}/vote"
-      {{if eq .View "list"}}hx-target="#leaderboard" hx-swap="outerHTML"{{else}}hx-target="#vote-{{.Post.ID}}" hx-swap="outerHTML"{{end}}>
+    <form method="post" action="/questions/{{.Question.ID}}/vote"
+      hx-post="/questions/{{.Question.ID}}/vote"
+      {{if eq .View "list"}}hx-target="#leaderboard" hx-swap="outerHTML"{{else}}hx-target="#vote-{{.Question.ID}}" hx-swap="outerHTML"{{end}}>
       <input type="hidden" name="_csrf" value="{{.CSRF}}">
-      {{if eq .Post.UserVote 1}}<input type="hidden" name="value" value="0">{{else}}<input type="hidden" name="value" value="1">{{end}}
+      {{if eq .Question.UserVote 1}}<input type="hidden" name="value" value="0">{{else}}<input type="hidden" name="value" value="1">{{end}}
       <input type="hidden" name="view" value="{{.View}}">
       <input type="hidden" name="date" value="{{.Date}}">
-      <button type="submit" class="vote-btn{{if eq .Post.UserVote 1}} is-up{{end}}" aria-label="Upvote" aria-pressed="{{if eq .Post.UserVote 1}}true{{else}}false{{end}}">
+      <button type="submit" class="vote-btn{{if eq .Question.UserVote 1}} is-up{{end}}" aria-label="Upvote" aria-pressed="{{if eq .Question.UserVote 1}}true{{else}}false{{end}}">
         <svg width="18" height="18" viewBox="0 0 18 18" aria-hidden="true"><path d="M9 3.5 15 12H3z" fill="currentColor"/></svg>
       </button>
     </form>
-    <span class="score" aria-label="Net score {{.Post.Score}}">{{.Post.Score}}</span>
-    <form method="post" action="/questions/{{.Post.ID}}/vote"
-      hx-post="/questions/{{.Post.ID}}/vote"
-      {{if eq .View "list"}}hx-target="#leaderboard" hx-swap="outerHTML"{{else}}hx-target="#vote-{{.Post.ID}}" hx-swap="outerHTML"{{end}}>
+    <span class="score" aria-label="Net score {{.Question.Score}}">{{.Question.Score}}</span>
+    <form method="post" action="/questions/{{.Question.ID}}/vote"
+      hx-post="/questions/{{.Question.ID}}/vote"
+      {{if eq .View "list"}}hx-target="#leaderboard" hx-swap="outerHTML"{{else}}hx-target="#vote-{{.Question.ID}}" hx-swap="outerHTML"{{end}}>
       <input type="hidden" name="_csrf" value="{{.CSRF}}">
-      {{if eq .Post.UserVote -1}}<input type="hidden" name="value" value="0">{{else}}<input type="hidden" name="value" value="-1">{{end}}
+      {{if eq .Question.UserVote -1}}<input type="hidden" name="value" value="0">{{else}}<input type="hidden" name="value" value="-1">{{end}}
       <input type="hidden" name="view" value="{{.View}}">
       <input type="hidden" name="date" value="{{.Date}}">
-      <button type="submit" class="vote-btn{{if eq .Post.UserVote -1}} is-down{{end}}" aria-label="Downvote" aria-pressed="{{if eq .Post.UserVote -1}}true{{else}}false{{end}}">
+      <button type="submit" class="vote-btn{{if eq .Question.UserVote -1}} is-down{{end}}" aria-label="Downvote" aria-pressed="{{if eq .Question.UserVote -1}}true{{else}}false{{end}}">
         <svg width="18" height="18" viewBox="0 0 18 18" aria-hidden="true"><path d="M9 14.5 3 6h12z" fill="currentColor"/></svg>
       </button>
     </form>
@@ -28,7 +28,7 @@
     <a class="vote-btn" href="/login" hx-get="/auth/prompt" hx-target="#flash" aria-label="Sign in to upvote">
       <svg width="18" height="18" viewBox="0 0 18 18" aria-hidden="true"><path d="M9 3.5 15 12H3z" fill="currentColor"/></svg>
     </a>
-    <span class="score" aria-label="Net score {{.Post.Score}}">{{.Post.Score}}</span>
+    <span class="score" aria-label="Net score {{.Question.Score}}">{{.Question.Score}}</span>
     <a class="vote-btn" href="/login" hx-get="/auth/prompt" hx-target="#flash" aria-label="Sign in to downvote">
       <svg width="18" height="18" viewBox="0 0 18 18" aria-hidden="true"><path d="M9 14.5 3 6h12z" fill="currentColor"/></svg>
     </a>

templates/profile.html

@@ -25,10 +25,6 @@
       </div>
     </div>
 
-    <label for="email">Email</label>
-    <input id="email" name="email" type="email" required maxlength="254" autocomplete="email" value="{{.EmailVal}}">
-    <p class="hint">Required. We’ll email you when a plumber answers your question.</p>
-
     <label for="state">State</label>
     <select id="state" name="state">
       <option value=""{{if eq .StateVal ""}} selected{{end}}>Prefer not to say</option>
@@ -43,12 +39,12 @@
 
   <section class="profile-questions" aria-labelledby="profile-q-heading">
     <h2 id="profile-q-heading">{{.QuestionsLabel}}</h2>
-    {{if .Posts}}
+    {{if .Questions}}
       <ul class="profile-q-list">
-        {{range .Posts}}
+        {{range .Questions}}
           <li>
             <a href="/questions/{{.ID}}">{{.Title}}</a>
-            <span class="meta">{{.PostDate}}</span>
+            <span class="meta">{{.HuntDate}}</span>
           </li>
         {{end}}
       </ul>

templates/question.html

@@ -1,41 +1,37 @@
 {{define "question"}}
 {{template "header" .}}
 <main id="main" class="wrap question-page">
-  <p class="crumb"><a href="{{if eq .Question.PostDate .Today}}/{{else}}/hunt/{{.Question.PostDate}}{{end}}">← {{pacificLabel .Question.PostDate}}</a></p>
-  <article id="post-{{.Question.ID}}" class="q-detail">
-    {{template "vote" (voteCtx .User .CSRF "question" .Question.PostDate .Question)}}
-    <div class="post-content">
-      <p class="post-kicker">Question</p>
+  <p class="crumb"><a href="{{if eq .Question.HuntDate .Today}}/{{else}}/hunt/{{.Question.HuntDate}}{{end}}">← {{pacificLabel .Question.HuntDate}}</a></p>
+  <article class="q-detail">
+    {{template "vote" (voteCtx .User .CSRF "question" .Question.HuntDate .Question)}}
+    <div>
       <h1>{{.Question.Title}}</h1>
       <p class="meta">
         <span>{{.Question.AuthorName}}</span>
         {{if .Question.City}}<span class="dot" aria-hidden="true">·</span><span>{{.Question.City}}</span>{{end}}
         <span class="dot" aria-hidden="true">·</span>
-        <a href="{{if eq .Question.PostDate .Today}}/{{else}}/hunt/{{.Question.PostDate}}{{end}}">{{.Question.PostDate}}</a>
-        {{if eq .Question.PostState "locked"}}<span class="badge">Locked</span>{{end}}
-        {{if eq .Question.PostState "hidden"}}<span class="badge">Hidden</span>{{end}}
-        {{if isEdited .Question}}<span class="edited">Edited</span>{{end}}
+        <a href="{{if eq .Question.HuntDate .Today}}/{{else}}/hunt/{{.Question.HuntDate}}{{end}}">{{.Question.HuntDate}}</a>
       </p>
-      <p class="post-body">{{.Question.Body}}</p>
-      {{template "postActions" (postCtx .User .CSRF .Question .Question 0)}}
+      <p class="q-body">{{.Question.Body}}</p>
+      {{if isAdmin .User}}
+        <form method="post" action="/questions/{{.Question.ID}}/hide"
+          hx-post="/questions/{{.Question.ID}}/hide" hx-target="body">
+          <input type="hidden" name="_csrf" value="{{.CSRF}}">
+          <button type="submit" class="linkish">Hide this question</button>
+        </form>
+      {{end}}
     </div>
   </article>
-  <section class="conversation" aria-labelledby="conversation-heading">
-    <div class="conversation-head">
-      <p class="eyebrow">Thread</p>
-      <h2 id="conversation-heading">Conversation</h2>
-    </div>
-    {{if .Question.Replies}}
-      <div class="thread">
-        {{$page := .}}
-        {{range .Question.Replies}}
-          {{template "threadReply" (postCtx $page.User $page.CSRF $page.Question . 1)}}
-        {{end}}
-      </div>
-    {{else}}
-      <p class="waiting">No replies yet.</p>
-    {{end}}
-  </section>
+  {{template "answer" .}}
+  {{if isAdmin .User}}
+    <form class="answer-form" method="post" action="/questions/{{.Question.ID}}/answer"
+      hx-post="/questions/{{.Question.ID}}/answer" hx-target="#answer-block" hx-swap="outerHTML">
+      <input type="hidden" name="_csrf" value="{{.CSRF}}">
+      <label for="answer-body">{{if .Answer}}Edit answer{{else}}Write the answer{{end}}</label>
+      <textarea id="answer-body" name="body" rows="8" required maxlength="12000">{{if .Answer}}{{.Answer.Body}}{{end}}</textarea>
+      <button type="submit" class="btn btn-primary">Save answer</button>
+    </form>
+  {{end}}
 </main>
 {{template "footer" .}}
 {{end}}

templates/register.html

@@ -9,9 +9,6 @@
     <label for="username">Username</label>
     <input id="username" name="username" type="text" required minlength="3" maxlength="20" pattern="[A-Za-z0-9_]+" autocomplete="username" autocapitalize="off" spellcheck="false" value="{{.Username}}">
     <p class="hint">3–20 letters, numbers, or underscores.</p>
-    <label for="email">Email</label>
-    <input id="email" name="email" type="email" required maxlength="254" autocomplete="email" value="{{.Email}}">
-    <p class="hint">We’ll email you when a plumber answers your question.</p>
     <label for="password">Password</label>
     <input id="password" name="password" type="password" required minlength="8" maxlength="72" autocomplete="new-password">
     <p class="hint">At least 8 characters (max 72 bytes).</p>

templates/submit.html

@@ -4,8 +4,7 @@
   <h1>Ask a question</h1>
   <p class="lede">It lands on today’s hunt (Pacific time). People vote; the ranking resets at midnight PT.</p>
   {{if .Error}}<p class="banner error" role="alert">{{.Error}}</p>{{end}}
-  <form class="ask" method="post" action="/submit"
-    data-submit-once data-submitting-label="Posting…">
+  <form class="ask" method="post" action="/submit">
     <input type="hidden" name="_csrf" value="{{.CSRF}}">
     <label for="title">Title</label>
     <input id="title" name="title" type="text" required maxlength="120" value="{{.TitleVal}}" placeholder="Water heater popping after showers">
@@ -13,7 +12,7 @@
     <textarea id="body" name="body" rows="8" required maxlength="8000" placeholder="Age of the house, what you already tried, where you are in the Bay if it helps.">{{.BodyVal}}</textarea>
     <label for="city">City <span class="optional">(optional)</span></label>
     <input id="city" name="city" type="text" maxlength="80" value="{{.CityVal}}" placeholder="Oakland">
-    <button type="submit" class="btn btn-primary" data-submit-button>Submit to today’s hunt</button>
+    <button type="submit" class="btn btn-primary">Submit to today’s hunt</button>
   </form>
 </main>
 {{template "footer" .}}