Use canonical production domain.

Reference https://www.askaplumberfirst.com for production email links and configuration examples.

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

@@ -61,52 +61,6 @@ SET
   updated_at = sqlc.arg(updated_at)
 WHERE id = sqlc.arg(id);
 
--- name: CreatePostImage :exec
-INSERT INTO post_images (
-  id, post_id, object_key, public_url, description, position, width, height, created_at
-)
-VALUES (
-  sqlc.arg(id),
-  sqlc.arg(post_id),
-  sqlc.arg(object_key),
-  sqlc.arg(public_url),
-  sqlc.arg(description),
-  sqlc.arg(position),
-  sqlc.arg(width),
-  sqlc.arg(height),
-  sqlc.arg(created_at)
-);
-
--- name: DeletePostImages :exec
-DELETE FROM post_images
-WHERE post_id = sqlc.arg(post_id);
-
--- name: ListPostImages :many
-SELECT
-  id, post_id, object_key, public_url, description, position, width, height, created_at
-FROM post_images
-WHERE post_id = sqlc.arg(post_id)
-ORDER BY position;
-
--- name: ListPostThreadImages :many
-WITH RECURSIVE thread AS (
-  SELECT p.id
-  FROM posts p
-  WHERE p.id = sqlc.arg(root_id) AND p.parent_id IS NULL
-
-  UNION ALL
-
-  SELECT child.id
-  FROM posts child
-  JOIN thread parent ON child.parent_id = parent.id
-)
-SELECT
-  images.id, images.post_id, images.object_key, images.public_url,
-  images.description, images.position, images.width, images.height, images.created_at
-FROM post_images images
-JOIN thread ON thread.id = images.post_id
-ORDER BY images.post_id, images.position;
-
 -- name: UpdateRootPostState :execrows
 UPDATE posts
 SET

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/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

@@ -11,7 +11,6 @@ require (
 	github.com/google/uuid v1.6.0
 	github.com/jackc/pgx/v5 v5.10.0
 	github.com/joho/godotenv v1.5.1
-	github.com/rwcarlsen/goexif v0.0.0-20190401172101-9e8deecbddbd
 	golang.org/x/crypto v0.55.0
 	golang.org/x/image v0.45.0
 )

go.sum

@@ -45,8 +45,6 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 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/rwcarlsen/goexif v0.0.0-20190401172101-9e8deecbddbd h1:CmH9+J6ZSsIjUK3dcGsnCnO41eRBOnY12zwkn5qVwgc=
-github.com/rwcarlsen/goexif v0.0.0-20190401172101-9e8deecbddbd/go.mod h1:hPqNNc0+uJM6H+SuU8sEs5K5IQeKccPqeSjfgcKGgPk=
 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/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/memory.go

@@ -10,15 +10,20 @@ 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
+	users     map[string]*User           // id -> user
-	byName    map[string]string         // username -> id
+	byName    map[string]string          // username -> id
-	posts     map[string]*Post          // id -> post
+	questions map[string]*RankedQuestion // id -> question
-	postVotes map[string]map[string]int // postID -> userID -> value
+	answers   map[string]*Answer         // questionID -> answer
+	votes     map[string]map[string]int  // questionID -> userID -> value
+	posts     map[string]*Post           // id -> post
+	postVotes map[string]map[string]int  // postID -> userID -> value
 }
 
 // NewMemory returns an empty Memory store.
@@ -26,6 +31,9 @@ func NewMemory() *Memory {
 	return &Memory{
 		users:     map[string]*User{},
 		byName:    map[string]string{},
+		questions: map[string]*RankedQuestion{},
+		answers:   map[string]*Answer{},
+		votes:     map[string]map[string]int{},
 		posts:     map[string]*Post{},
 		postVotes: map[string]map[string]int{},
 	}
@@ -202,6 +210,172 @@ func (m *Memory) SaveUserProfile(_ context.Context, u *User) error {
 	return nil
 }
 
+func (m *Memory) CreateQuestion(_ context.Context, q *RankedQuestion) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	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)
+	}
+	author, ok := m.users[q.AuthorID]
+	if !ok {
+		return fmt.Errorf("unknown author")
+	}
+	cp := *q
+	cp.AuthorName = author.Name
+	cp.db = nil
+	m.questions[cp.ID] = &cp
+	*q = cp
+	return nil
+}
+
+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()
+	q, ok := m.questions[id]
+	if !ok {
+		return nil, sql.ErrNoRows
+	}
+	out := m.annotate(q, viewerID)
+	return &out, nil
+}
+
+func (m *Memory) ListHunt(_ context.Context, huntDate, viewerID string) ([]RankedQuestion, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	out := make([]RankedQuestion, 0)
+	for _, q := range m.questions {
+		if q.HuntDate != huntDate || q.Hidden {
+			continue
+		}
+		out = append(out, m.annotate(q, viewerID))
+	}
+	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 out, nil
+}
+
+func (m *Memory) ListQuestionsByAuthor(_ context.Context, authorID string) ([]RankedQuestion, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	out := make([]RankedQuestion, 0)
+	for _, q := range m.questions {
+		if q.AuthorID != authorID || q.Hidden {
+			continue
+		}
+		out = append(out, m.annotate(q, ""))
+	}
+	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) ListQuestionsAnsweredBy(_ context.Context, adminID string) ([]RankedQuestion, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	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
+	}
+	q.Hidden = true
+	return nil
+}
+
+func (m *Memory) GetAnswer(_ context.Context, questionID string) (*Answer, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	a, ok := m.answers[questionID]
+	if !ok {
+		return nil, sql.ErrNoRows
+	}
+	cp := *a
+	if u, ok := m.users[a.AuthorID]; ok {
+		cp.AuthorName = u.Name
+	}
+	return &cp, nil
+}
+
+func (m *Memory) UpsertAnswer(_ context.Context, a *Answer) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if _, ok := m.questions[a.QuestionID]; !ok {
+		return fmt.Errorf("unknown question")
+	}
+	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
+	}
+	a.UpdatedAt = now
+	cp := *a
+	cp.db = nil
+	m.answers[a.QuestionID] = &cp
+	*a = cp
+	return nil
+}
+
 func (m *Memory) CreatePost(_ context.Context, post *Post) error {
 	if post == nil {
 		return fmt.Errorf("%w: post is nil", ErrInvalidPost)
@@ -209,9 +383,6 @@ func (m *Memory) CreatePost(_ context.Context, post *Post) error {
 	if err := preparePost(post); err != nil {
 		return err
 	}
-	if err := preparePostImages(post); err != nil {
-		return err
-	}
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	if _, ok := m.users[post.AuthorID]; !ok {
@@ -290,10 +461,6 @@ func (m *Memory) UpdatePost(_ context.Context, post *Post) error {
 	if body == "" {
 		return fmt.Errorf("%w: body is required", ErrInvalidPost)
 	}
-	post.Body = body
-	if err := preparePostImages(post); err != nil {
-		return err
-	}
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	existing, ok := m.posts[post.ID]
@@ -301,7 +468,6 @@ func (m *Memory) UpdatePost(_ context.Context, post *Post) error {
 		return sql.ErrNoRows
 	}
 	existing.Body = body
-	existing.Images = append([]PostImage(nil), post.Images...)
 	existing.UpdatedAt = time.Now().UTC().Format(time.RFC3339Nano)
 	*post = *clonePostWithAuthor(existing, m.users)
 	return nil
@@ -459,7 +625,6 @@ func clonePost(post *Post) *Post {
 		parentID := *post.ParentID
 		cp.ParentID = &parentID
 	}
-	cp.Images = append([]PostImage(nil), post.Images...)
 	cp.Replies = nil
 	return &cp
 }
@@ -472,3 +637,24 @@ func clonePostWithAuthor(post *Post, users map[string]*User) *Post {
 	}
 	return cp
 }
+
+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")
+	}
+	q, ok := m.questions[questionID]
+	if !ok || q.Hidden {
+		return ErrHiddenOrMissing
+	}
+	if m.votes[questionID] == nil {
+		m.votes[questionID] = map[string]int{}
+	}
+	if value == 0 {
+		delete(m.votes[questionID], userID)
+		return nil
+	}
+	m.votes[questionID][userID] = value
+	return nil
+}

internal/store/migrate.go

@@ -35,11 +35,13 @@ CREATE UNIQUE INDEX IF NOT EXISTS users_email_lower_uidx
 	return nil
 }
 
-// migratePosts creates the unified post model.
+// migratePosts creates the unified post model and snapshots legacy content.
+// Legacy tables remain in place until the application cutover is complete.
 func migratePosts(ctx context.Context, exec execContext) error {
 	steps := []struct {
 		name string
 		sql  string
+		args []any
 	}{
 		{name: "create posts", sql: `
 CREATE TABLE IF NOT EXISTS posts (
@@ -76,9 +78,33 @@ CREATE TABLE IF NOT EXISTS post_votes (
   value INTEGER NOT NULL CHECK (value IN (-1, 1)),
   PRIMARY KEY (user_id, post_id)
 )`},
+		{name: "copy questions", sql: `
+INSERT INTO posts (
+  id, parent_id, author_id, title, body, city, post_date, post_state, created_at, updated_at
+)
+SELECT
+  id, NULL, author_id, title, body, city, hunt_date,
+  CASE WHEN hidden = 0 THEN $1 ELSE $2 END,
+  created_at, created_at
+FROM questions
+ON CONFLICT (id) DO NOTHING`, args: []any{string(PostStateVisible), string(PostStateHidden)}},
+		{name: "copy answers", sql: `
+INSERT INTO posts (
+  id, parent_id, author_id, title, body, city, post_date, post_state, created_at, updated_at
+)
+SELECT
+  'answer:' || question_id, question_id, author_id, '', body, '', '',
+  $1, created_at, updated_at
+FROM answers
+ON CONFLICT (id) DO NOTHING`, args: []any{string(PostStateVisible)}},
+		{name: "copy votes", sql: `
+INSERT INTO post_votes (user_id, post_id, value)
+SELECT user_id, question_id, value
+FROM votes
+ON CONFLICT (user_id, post_id) DO NOTHING`},
 	}
 	for _, step := range steps {
-		if _, err := exec.ExecContext(ctx, step.sql); err != nil {
+		if _, err := exec.ExecContext(ctx, step.sql, step.args...); err != nil {
 			return fmt.Errorf("%s: %w", step.name, err)
 		}
 	}
@@ -103,42 +129,6 @@ CREATE INDEX IF NOT EXISTS idx_posts_author_created
 	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 migratePostImages(ctx context.Context, exec execContext) error {
-	if _, err := exec.ExecContext(ctx, `
-CREATE TABLE IF NOT EXISTS post_images (
-  id TEXT PRIMARY KEY,
-  post_id TEXT NOT NULL REFERENCES posts(id) ON DELETE CASCADE,
-  object_key TEXT NOT NULL UNIQUE,
-  public_url TEXT NOT NULL,
-  description TEXT NOT NULL DEFAULT '' CHECK (char_length(description) <= 500),
-  position SMALLINT NOT NULL CHECK (position BETWEEN 0 AND 3),
-  width INTEGER NOT NULL CHECK (width > 0),
-  height INTEGER NOT NULL CHECK (height > 0),
-  created_at TEXT NOT NULL,
-  UNIQUE (post_id, position)
-)`); err != nil {
-		return fmt.Errorf("create post images: %w", err)
-	}
-	return nil
-}
-
 func migratePostDate(ctx context.Context, exec execContext) error {
 	steps := []struct {
 		name string
@@ -329,8 +319,6 @@ CREATE TABLE IF NOT EXISTS schema_migrations (
 		{"006_post_date", migratePostDate},
 		{"007_post_state", migratePostState},
 		{"008_post_author_index", migratePostAuthorIndex},
-		{"009_drop_legacy_post_tables", migrateDropLegacyPostTables},
-		{"010_post_images", migratePostImages},
 	}
 	for _, m := range migrations {
 		if applied[m.version] {

internal/store/migrate_posts_test.go

@@ -13,7 +13,7 @@ import (
 	"plumber/internal/store/sqlc"
 )
 
-func TestPostMigrationsAndQueries(t *testing.T) {
+func TestMigratePostsCopiesLegacyData(t *testing.T) {
 	rawURL := strings.TrimSpace(os.Getenv("TEST_DATABASE_URL"))
 	if rawURL == "" {
 		t.Skip("TEST_DATABASE_URL is not set")
@@ -47,13 +47,47 @@ func TestPostMigrationsAndQueries(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	baseSchema := `
+	legacySchema := `
 CREATE TABLE users (
   id TEXT PRIMARY KEY,
   name TEXT NOT NULL,
   role TEXT NOT NULL
+);
+CREATE TABLE questions (
+  id TEXT PRIMARY KEY,
+  author_id TEXT NOT NULL REFERENCES users(id),
+  title TEXT NOT NULL,
+  body TEXT NOT NULL,
+  city TEXT NOT NULL DEFAULT '',
+  hunt_date TEXT NOT NULL,
+  hidden INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL
+);
+CREATE TABLE 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 votes (
+  user_id TEXT NOT NULL REFERENCES users(id),
+  question_id TEXT NOT NULL REFERENCES questions(id) ON DELETE CASCADE,
+  value INTEGER NOT NULL CHECK (value IN (-1, 1)),
+  PRIMARY KEY (user_id, question_id)
 );`
-	if err := applySchema(ctx, conn, baseSchema); err != nil {
+	if err := applySchema(ctx, conn, legacySchema); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := conn.ExecContext(ctx, `
+INSERT INTO users (id, name, role)
+VALUES ('homeowner', 'Home Owner', 'user'), ('plumber', 'The Plumber', 'admin');
+INSERT INTO questions (id, author_id, title, body, city, hunt_date, hidden, created_at)
+VALUES ('question-1', 'homeowner', 'Leaky sink', 'It drips.', 'Oakland', '2026-08-26', 0, '2026-08-26T08:00:00Z');
+INSERT INTO answers (question_id, author_id, body, created_at, updated_at)
+VALUES ('question-1', 'plumber', 'Replace the cartridge.', '2026-08-26T09:00:00Z', '2026-08-26T09:05:00Z');
+INSERT INTO votes (user_id, question_id, value)
+VALUES ('homeowner', 'question-1', 1);`); err != nil {
 		t.Fatal(err)
 	}
 
@@ -69,79 +103,28 @@ CREATE TABLE users (
 	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 := migratePostImages(ctx, conn); err != nil {
-		t.Fatal(err)
-	}
-	if err := migratePostImages(ctx, conn); err != nil {
-		t.Fatalf("post images 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
+	var postCount, voteCount, legacyQuestionCount, legacyAnswerCount 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 {
+	if err := conn.QueryRowContext(ctx, "SELECT count(*) FROM questions").Scan(&legacyQuestionCount); err != nil {
-		t.Fatalf("counts posts=%d votes=%d", postCount, voteCount)
-	}
-	imageQueries := sqlc.New(conn)
-	for _, image := range []sqlc.CreatePostImageParams{
-		{ID: "root-image-1", PostID: "root-1", ObjectKey: "posts/root-1/1.jpg", PublicUrl: "https://cdn.example/root-1.jpg", Description: "Valve", Position: 0, Width: 1200, Height: 900, CreatedAt: "2026-08-26T08:00:00Z"},
-		{ID: "root-image-2", PostID: "root-1", ObjectKey: "posts/root-1/2.png", PublicUrl: "https://cdn.example/root-2.png", Position: 1, Width: 900, Height: 1200, CreatedAt: "2026-08-26T08:00:00Z"},
-		{ID: "reply-image-1", PostID: "reply-1", ObjectKey: "posts/reply-1/1.jpg", PublicUrl: "https://cdn.example/reply-1.jpg", Description: "Cartridge", Position: 0, Width: 1000, Height: 1000, CreatedAt: "2026-08-26T09:00:00Z"},
-	} {
-		if err := imageQueries.CreatePostImage(ctx, image); err != nil {
-			t.Fatal(err)
-		}
-	}
-	rootImages, err := imageQueries.ListPostImages(ctx, "root-1")
-	if err != nil {
 		t.Fatal(err)
 	}
-	if len(rootImages) != 2 ||
+	if err := conn.QueryRowContext(ctx, "SELECT count(*) FROM answers").Scan(&legacyAnswerCount); err != nil {
-		rootImages[0].ID != "root-image-1" ||
-		rootImages[1].ID != "root-image-2" {
-		t.Fatalf("root images = %+v", rootImages)
-	}
-	threadImages, err := imageQueries.ListPostThreadImages(ctx, "root-1")
-	if err != nil {
 		t.Fatal(err)
 	}
-	if len(threadImages) != 3 {
+	if postCount != 2 || voteCount != 1 || legacyQuestionCount != 1 || legacyAnswerCount != 1 {
-		t.Fatalf("thread images = %+v", threadImages)
+		t.Fatalf(
-	}
+			"counts posts=%d votes=%d legacy questions=%d answers=%d",
-	if err := imageQueries.CreatePostImage(ctx, sqlc.CreatePostImageParams{
+			postCount,
-		ID: "too-many", PostID: "root-1", ObjectKey: "posts/root-1/5.jpg",
+			voteCount,
-		PublicUrl: "https://cdn.example/root-5.jpg", Position: 4,
+			legacyQuestionCount,
-		Width: 100, Height: 100, CreatedAt: "2026-08-26T08:00:00Z",
+			legacyAnswerCount,
-	}); err == nil {
+		)
-		t.Fatal("fifth image position unexpectedly succeeded")
 	}
 	var postVoteIndexCount int
 	if err := conn.QueryRowContext(ctx, `
@@ -169,7 +152,7 @@ WHERE schemaname = current_schema()
 	}
 	if _, err := conn.ExecContext(ctx, `
 INSERT INTO post_votes (user_id, post_id, value)
-VALUES ('homeowner', 'root-1', -1)`); err == nil {
+VALUES ('homeowner', 'question-1', -1)`); err == nil {
 		t.Fatal("duplicate user/post vote unexpectedly succeeded")
 	}
 
@@ -178,7 +161,7 @@ VALUES ('homeowner', 'root-1', -1)`); err == nil {
 	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(
+WHERE id = 'question-1'`).Scan(
 		&rootParent,
 		&rootAuthor,
 		&title,
@@ -207,7 +190,7 @@ WHERE id = 'root-1'`).Scan(
 	if err := conn.QueryRowContext(ctx, `
 SELECT parent_id, author_id, body, post_state, created_at, updated_at
 FROM posts
-WHERE id = 'reply-1'`).Scan(
+WHERE id = 'answer:question-1'`).Scan(
 		&replyParent,
 		&replyAuthor,
 		&replyBody,
@@ -217,7 +200,7 @@ WHERE id = 'reply-1'`).Scan(
 	); err != nil {
 		t.Fatal(err)
 	}
-	if replyParent != "root-1" ||
+	if replyParent != "question-1" ||
 		replyAuthor != "plumber" ||
 		replyBody != "Replace the cartridge." ||
 		replyState != "visible" ||
@@ -229,7 +212,7 @@ WHERE id = 'reply-1'`).Scan(
 	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 {
+WHERE user_id = 'homeowner' AND post_id = 'question-1'`).Scan(&voteValue); err != nil {
 		t.Fatal(err)
 	}
 	if voteValue != 1 {
@@ -240,7 +223,7 @@ WHERE user_id = 'homeowner' AND post_id = 'root-1'`).Scan(&voteValue); err != ni
 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', '', '',
+  'invalid-reply', 'question-1', 'homeowner', 'Replies cannot have titles', 'Body', '', '',
   'visible', 'now', 'now'
 )`); err == nil {
 		t.Fatal("reply with root-only title unexpectedly succeeded")
@@ -249,7 +232,7 @@ INSERT INTO posts (
 	queries := sqlc.New(conn)
 	if err := queries.CreatePost(ctx, sqlc.CreatePostParams{
 		ID:        "follow-up",
-		ParentID:  sql.NullString{String: "reply-1", Valid: true},
+		ParentID:  sql.NullString{String: "answer:question-1", Valid: true},
 		AuthorID:  "homeowner",
 		Body:      "It is still dripping.",
 		PostState: string(PostStateVisible),
@@ -258,17 +241,17 @@ INSERT INTO posts (
 	}); err != nil {
 		t.Fatal(err)
 	}
-	thread, err := queries.ListPostThread(ctx, "root-1")
+	thread, err := queries.ListPostThread(ctx, "question-1")
 	if err != nil {
 		t.Fatal(err)
 	}
 	if len(thread) != 3 ||
-		thread[0].ID != "root-1" ||
+		thread[0].ID != "question-1" ||
-		thread[1].ID != "reply-1" ||
+		thread[1].ID != "answer:question-1" ||
 		thread[2].ID != "follow-up" {
 		t.Fatalf("recursive thread = %+v", thread)
 	}
-	nonRootThread, err := queries.ListPostThread(ctx, "reply-1")
+	nonRootThread, err := queries.ListPostThread(ctx, "answer:question-1")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -284,7 +267,7 @@ INSERT INTO posts (
 	}
 	if n, err := queries.UpsertPostVoteOnVisibleRoot(ctx, sqlc.UpsertPostVoteOnVisibleRootParams{
 		UserID:      "plumber",
-		PostID:      "root-1",
+		PostID:      "question-1",
 		Value:       1,
 		HiddenState: string(PostStateHidden),
 	}); err != nil || n != 1 {
@@ -307,7 +290,7 @@ INSERT INTO posts (
 	}
 	summary, err := queries.GetRootPostVoteSummary(ctx, sqlc.GetRootPostVoteSummaryParams{
 		ViewerID: "plumber",
-		RootID:   "root-1",
+		RootID:   "question-1",
 	})
 	if err != nil || summary.Score != 2 || summary.UserVote != 1 {
 		t.Fatalf("root vote summary = %+v, %v", summary, err)
@@ -317,7 +300,7 @@ INSERT INTO posts (
 		HiddenState: string(PostStateHidden),
 		RowLimit:    50,
 	})
-	if err != nil || len(byAuthor) != 1 || byAuthor[0].ID != "root-1" {
+	if err != nil || len(byAuthor) != 1 || byAuthor[0].ID != "question-1" {
 		t.Fatalf("roots by author = %+v, %v", byAuthor, err)
 	}
 	answeredBy, err := queries.ListRootPostsAnsweredBy(ctx, sqlc.ListRootPostsAnsweredByParams{
@@ -325,14 +308,14 @@ INSERT INTO posts (
 		AdminID:     "plumber",
 		RowLimit:    50,
 	})
-	if err != nil || len(answeredBy) != 1 || answeredBy[0].ID != "root-1" {
+	if err != nil || len(answeredBy) != 1 || answeredBy[0].ID != "question-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",
+			ID:        "question-1",
 		})
 		if err != nil || n != 1 {
 			t.Fatalf("set root state %q rows=%d error=%v", state, n, err)
@@ -375,7 +358,7 @@ WHERE schemaname = current_schema()
 	}
 	var migratedPostDate string
 	if err := conn.QueryRowContext(ctx, `
-SELECT post_date FROM posts WHERE id = 'root-1'`).Scan(&migratedPostDate); err != nil {
+SELECT post_date FROM posts WHERE id = 'question-1'`).Scan(&migratedPostDate); err != nil {
 		t.Fatal(err)
 	}
 	if postDateColumnCount != 1 ||
@@ -397,7 +380,7 @@ SELECT post_date FROM posts WHERE id = 'root-1'`).Scan(&migratedPostDate); err !
 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;
+UPDATE posts SET hidden = CASE WHEN id = 'question-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 <> '')
@@ -428,11 +411,11 @@ WHERE table_schema = current_schema()
 	}
 	var hiddenState, replyStateAfterMigration string
 	if err := conn.QueryRowContext(ctx, `
-SELECT post_state FROM posts WHERE id = 'root-1'`).Scan(&hiddenState); err != nil {
+SELECT post_state FROM posts WHERE id = 'question-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 {
+SELECT post_state FROM posts WHERE id = 'answer:question-1'`).Scan(&replyStateAfterMigration); err != nil {
 		t.Fatal(err)
 	}
 	var postStateDataType string
@@ -470,37 +453,15 @@ WHERE schemaname = current_schema()
 			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}
+	exec := &failingMigrationExec{failAt: 6}
 	err := migratePosts(context.Background(), exec)
-	if err == nil || !strings.Contains(err.Error(), "create post votes") {
+	if err == nil || !strings.Contains(err.Error(), "copy questions") {
-		t.Fatalf("error = %v, want create post votes context", err)
+		t.Fatalf("error = %v, want copy questions context", err)
 	}
 }
 

internal/store/post.go

@@ -5,7 +5,6 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
-	"math"
 	"sort"
 	"strings"
 	"time"
@@ -25,26 +24,11 @@ var (
 type PostState string
 
 const (
-	PostStateVisible         PostState = "visible"
+	PostStateVisible PostState = "visible"
-	PostStateHidden          PostState = "hidden"
+	PostStateHidden  PostState = "hidden"
-	PostStateLocked          PostState = "locked"
+	PostStateLocked  PostState = "locked"
-	MaxPostImages                      = 4
-	MaxImageDescriptionRunes           = 500
 )
 
-// PostImage is one ordered public image attached to a post.
-type PostImage struct {
-	ID          string
-	PostID      string
-	ObjectKey   string
-	PublicURL   string
-	Description string
-	Position    int
-	Width       int
-	Height      int
-	CreatedAt   string
-}
-
 // Post is either a root question (ParentID nil) or a reply to another post.
 type Post struct {
 	ID         string
@@ -62,7 +46,6 @@ type Post struct {
 	Score      int
 	Answered   bool
 	UserVote   int
-	Images     []PostImage
 	Replies    []*Post
 	db         *sql.DB
 }
@@ -80,16 +63,7 @@ func (p *Post) Create(ctx context.Context) error {
 	if err := preparePost(p); err != nil {
 		return err
 	}
-	if err := preparePostImages(p); err != nil {
+	err := sqlc.New(p.db).CreatePost(ctx, sqlc.CreatePostParams{
-		return err
-	}
-	tx, err := p.db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-	defer tx.Rollback()
-	q := sqlc.New(tx)
-	if err := q.CreatePost(ctx, sqlc.CreatePostParams{
 		ID:        p.ID,
 		ParentID:  nullableParentID(p.ParentID),
 		AuthorID:  p.AuthorID,
@@ -100,16 +74,11 @@ func (p *Post) Create(ctx context.Context) error {
 		PostState: string(p.PostState),
 		CreatedAt: p.CreatedAt,
 		UpdatedAt: p.UpdatedAt,
-	}); err != nil {
+	})
-		return mapPostCreateError(err)
+	return mapPostCreateError(err)
-	}
-	if err := createPostImages(ctx, q, p.Images); err != nil {
-		return mapPostCreateError(err)
-	}
-	return tx.Commit()
 }
 
-// Update changes the post body, update timestamp, and complete image set.
+// 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")
@@ -119,16 +88,7 @@ func (p *Post) Update(ctx context.Context) error {
 		return fmt.Errorf("%w: body is required", ErrInvalidPost)
 	}
 	p.UpdatedAt = time.Now().UTC().Format(time.RFC3339Nano)
-	if err := preparePostImages(p); err != nil {
+	n, err := sqlc.New(p.db).UpdatePost(ctx, sqlc.UpdatePostParams{
-		return err
-	}
-	tx, err := p.db.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-	defer tx.Rollback()
-	q := sqlc.New(tx)
-	n, err := q.UpdatePost(ctx, sqlc.UpdatePostParams{
 		ID:        p.ID,
 		Body:      p.Body,
 		UpdatedAt: p.UpdatedAt,
@@ -139,13 +99,7 @@ func (p *Post) Update(ctx context.Context) error {
 	if n == 0 {
 		return sql.ErrNoRows
 	}
-	if err := q.DeletePostImages(ctx, p.ID); err != nil {
+	return nil
-		return err
-	}
-	if err := createPostImages(ctx, q, p.Images); err != nil {
-		return mapPostCreateError(err)
-	}
-	return tx.Commit()
 }
 
 func preparePost(p *Post) error {
@@ -199,85 +153,6 @@ func preparePost(p *Post) error {
 	return nil
 }
 
-func preparePostImages(p *Post) error {
-	if len(p.Images) > MaxPostImages {
-		return fmt.Errorf("%w: at most %d images are allowed", ErrInvalidPost, MaxPostImages)
-	}
-	ids := make(map[string]bool, len(p.Images))
-	keys := make(map[string]bool, len(p.Images))
-	now := time.Now().UTC().Format(time.RFC3339Nano)
-	for i := range p.Images {
-		image := &p.Images[i]
-		image.ID = strings.TrimSpace(image.ID)
-		image.PostID = strings.TrimSpace(image.PostID)
-		image.ObjectKey = strings.TrimSpace(image.ObjectKey)
-		image.PublicURL = strings.TrimSpace(image.PublicURL)
-		image.Description = strings.TrimSpace(image.Description)
-		if image.ID == "" {
-			image.ID = uuid.NewString()
-		}
-		if image.PostID == "" {
-			image.PostID = p.ID
-		}
-		if image.PostID != p.ID {
-			return fmt.Errorf("%w: image belongs to another post", ErrInvalidPost)
-		}
-		if image.ObjectKey == "" || image.PublicURL == "" {
-			return fmt.Errorf("%w: image storage metadata is required", ErrInvalidPost)
-		}
-		if len([]rune(image.Description)) > MaxImageDescriptionRunes {
-			return fmt.Errorf("%w: image description is too long", ErrInvalidPost)
-		}
-		if image.Width <= 0 || image.Height <= 0 ||
-			image.Width > math.MaxInt32 || image.Height > math.MaxInt32 {
-			return fmt.Errorf("%w: invalid image dimensions", ErrInvalidPost)
-		}
-		if ids[image.ID] || keys[image.ObjectKey] {
-			return fmt.Errorf("%w: duplicate image", ErrInvalidPost)
-		}
-		ids[image.ID] = true
-		keys[image.ObjectKey] = true
-		image.Position = i
-		if image.CreatedAt == "" {
-			image.CreatedAt = now
-		}
-	}
-	return nil
-}
-
-func createPostImages(ctx context.Context, q *sqlc.Queries, images []PostImage) error {
-	for _, image := range images {
-		if err := q.CreatePostImage(ctx, sqlc.CreatePostImageParams{
-			ID:          image.ID,
-			PostID:      image.PostID,
-			ObjectKey:   image.ObjectKey,
-			PublicUrl:   image.PublicURL,
-			Description: image.Description,
-			Position:    int16(image.Position),
-			Width:       int32(image.Width),
-			Height:      int32(image.Height),
-			CreatedAt:   image.CreatedAt,
-		}); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func postImageFromSQL(image sqlc.PostImage) PostImage {
-	return PostImage{
-		ID:          image.ID,
-		PostID:      image.PostID,
-		ObjectKey:   image.ObjectKey,
-		PublicURL:   image.PublicUrl,
-		Description: image.Description,
-		Position:    int(image.Position),
-		Width:       int(image.Width),
-		Height:      int(image.Height),
-		CreatedAt:   image.CreatedAt,
-	}
-}
-
 func nullableParentID(parentID *string) sql.NullString {
 	if parentID == nil {
 		return sql.NullString{}
@@ -334,8 +209,7 @@ func postFromValues(
 
 // GetPost returns one post without loading its replies.
 func GetPost(ctx context.Context, db *sql.DB, id string) (*Post, error) {
-	q := sqlc.New(db)
+	r, err := sqlc.New(db).GetPost(ctx, id)
-	r, err := q.GetPost(ctx, id)
 	if err != nil {
 		return nil, err
 	}
@@ -354,20 +228,12 @@ func GetPost(ctx context.Context, db *sql.DB, id string) (*Post, error) {
 		r.CreatedAt,
 		r.UpdatedAt,
 	)
-	imageRows, err := q.ListPostImages(ctx, id)
-	if err != nil {
-		return nil, err
-	}
-	for _, image := range imageRows {
-		p.Images = append(p.Images, postImageFromSQL(image))
-	}
 	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) {
-	q := sqlc.New(db)
+	rows, err := sqlc.New(db).ListPostThread(ctx, rootID)
-	rows, err := q.ListPostThread(ctx, rootID)
 	if err != nil {
 		return nil, err
 	}
@@ -389,21 +255,6 @@ func GetPostThread(ctx context.Context, db *sql.DB, rootID string) (*Post, error
 			r.UpdatedAt,
 		))
 	}
-	imageRows, err := q.ListPostThreadImages(ctx, rootID)
-	if err != nil {
-		return nil, err
-	}
-	postsByID := make(map[string]*Post, len(posts))
-	for i := range posts {
-		postsByID[posts[i].ID] = &posts[i]
-	}
-	for _, image := range imageRows {
-		post, ok := postsByID[image.PostID]
-		if !ok {
-			return nil, fmt.Errorf("image %s belongs to missing post %s", image.ID, image.PostID)
-		}
-		post.Images = append(post.Images, postImageFromSQL(image))
-	}
 	return buildPostTree(posts, rootID)
 }
 

internal/store/post_test.go

@@ -267,93 +267,6 @@ func TestMemoryPostValidation(t *testing.T) {
 	}
 }
 
-func TestMemoryPostImages(t *testing.T) {
-	t.Parallel()
-
-	ctx := context.Background()
-	mem := NewMemory()
-	homeowner := &User{Username: "images", PasswordHash: "hash", Role: RoleUser}
-	if err := mem.CreateUser(ctx, homeowner); err != nil {
-		t.Fatal(err)
-	}
-	root := &Post{
-		ID:       "image-root",
-		AuthorID: homeowner.ID,
-		Title:    "What is leaking?",
-		Body:     "Here are two photos.",
-		Images: []PostImage{
-			{ID: "image-a", ObjectKey: "posts/image-root/image-a.jpg", PublicURL: "https://cdn.example/image-a.jpg", Description: "  Supply valve  ", Position: 3, Width: 1200, Height: 900},
-			{ID: "image-b", ObjectKey: "posts/image-root/image-b.png", PublicURL: "https://cdn.example/image-b.png", Width: 900, Height: 1200},
-		},
-	}
-	if err := mem.CreatePost(ctx, root); err != nil {
-		t.Fatal(err)
-	}
-	if root.Images[0].Position != 0 ||
-		root.Images[1].Position != 1 ||
-		root.Images[0].PostID != root.ID ||
-		root.Images[0].Description != "Supply valve" {
-		t.Fatalf("created images were not normalized: %+v", root.Images)
-	}
-
-	loaded, err := mem.GetPost(ctx, root.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	loaded.Images[0].Description = "mutated outside store"
-	reloaded, err := mem.GetPost(ctx, root.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if reloaded.Images[0].Description != "Supply valve" {
-		t.Fatalf("stored image mutated through clone: %+v", reloaded.Images[0])
-	}
-
-	reloaded.Body = "Updated photos."
-	reloaded.Images = []PostImage{
-		reloaded.Images[1],
-		{ID: "image-c", ObjectKey: "posts/image-root/image-c.jpg", PublicURL: "https://cdn.example/image-c.jpg", Description: "Trap connection", Width: 1600, Height: 1000},
-	}
-	if err := mem.UpdatePost(ctx, reloaded); err != nil {
-		t.Fatal(err)
-	}
-	updated, err := mem.GetPost(ctx, root.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(updated.Images) != 2 ||
-		updated.Images[0].ID != "image-b" ||
-		updated.Images[0].Position != 0 ||
-		updated.Images[1].ID != "image-c" ||
-		updated.Images[1].Position != 1 {
-		t.Fatalf("updated images = %+v", updated.Images)
-	}
-
-	tooMany := &Post{
-		AuthorID: homeowner.ID,
-		Title:    "Too many",
-		Body:     "Five photos.",
-		Images:   validPostImages(5),
-	}
-	if err := mem.CreatePost(ctx, tooMany); !errors.Is(err, ErrInvalidPost) {
-		t.Fatalf("five-image create error = %v, want ErrInvalidPost", err)
-	}
-}
-
-func validPostImages(count int) []PostImage {
-	images := make([]PostImage, count)
-	for i := range images {
-		images[i] = PostImage{
-			ID:        "image-" + string(rune('a'+i)),
-			ObjectKey: "posts/key-" + string(rune('a'+i)) + ".jpg",
-			PublicURL: "https://cdn.example/" + string(rune('a'+i)) + ".jpg",
-			Width:     100,
-			Height:    100,
-		}
-	}
-	return images
-}
-
 func ptr(value string) *string {
 	return &value
 }

internal/store/postgres_store.go

@@ -109,6 +109,41 @@ func (p *Postgres) SaveUserProfile(ctx context.Context, u *User) error {
 	return u.SaveProfile(ctx)
 }
 
+func (p *Postgres) CreateQuestion(ctx context.Context, q *RankedQuestion) error {
+	q.db = p.db
+	return q.Create(ctx)
+}
+
+func (p *Postgres) GetQuestion(ctx context.Context, id, viewerID string) (*RankedQuestion, error) {
+	return GetQuestion(ctx, p.db, id, viewerID)
+}
+
+func (p *Postgres) ListHunt(ctx context.Context, huntDate, viewerID string) ([]RankedQuestion, error) {
+	return ListHunt(ctx, p.db, huntDate, viewerID)
+}
+
+func (p *Postgres) ListQuestionsByAuthor(ctx context.Context, authorID string) ([]RankedQuestion, error) {
+	return ListQuestionsByAuthor(ctx, p.db, authorID)
+}
+
+func (p *Postgres) ListQuestionsAnsweredBy(ctx context.Context, adminID string) ([]RankedQuestion, error) {
+	return ListQuestionsAnsweredBy(ctx, p.db, adminID)
+}
+
+func (p *Postgres) HideQuestion(ctx context.Context, id string) error {
+	q := &RankedQuestion{ID: id, db: p.db}
+	return q.Hide(ctx)
+}
+
+func (p *Postgres) GetAnswer(ctx context.Context, questionID string) (*Answer, error) {
+	return GetAnswer(ctx, p.db, questionID)
+}
+
+func (p *Postgres) UpsertAnswer(ctx context.Context, a *Answer) error {
+	a.db = p.db
+	return a.Upsert(ctx)
+}
+
 func (p *Postgres) CreatePost(ctx context.Context, post *Post) error {
 	post.db = p.db
 	return post.Create(ctx)
@@ -150,3 +185,7 @@ func (p *Postgres) SetRootPostState(ctx context.Context, id string, state PostSt
 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

@@ -9,6 +9,14 @@ import (
 	"time"
 )
 
+type Answer struct {
+	QuestionID string
+	AuthorID   string
+	Body       string
+	CreatedAt  string
+	UpdatedAt  string
+}
+
 type Post struct {
 	ID        string
 	ParentID  sql.NullString
@@ -22,24 +30,23 @@ type Post struct {
 	UpdatedAt string
 }
 
-type PostImage struct {
-	ID          string
-	PostID      string
-	ObjectKey   string
-	PublicUrl   string
-	Description string
-	Position    int16
-	Width       int32
-	Height      int32
-	CreatedAt   string
-}
-
 type PostVote struct {
 	UserID string
 	PostID string
 	Value  int32
 }
 
+type Question struct {
+	ID        string
+	AuthorID  string
+	Title     string
+	Body      string
+	City      string
+	HuntDate  string
+	Hidden    int32
+	CreatedAt string
+}
+
 type Session struct {
 	Token  string
 	Data   []byte
@@ -57,3 +64,9 @@ type User struct {
 	State        string
 	CreatedAt    string
 }
+
+type Vote struct {
+	UserID     string
+	QuestionID string
+	Value      int32
+}

internal/store/sqlc/posts.sql.go

@@ -57,60 +57,6 @@ func (q *Queries) CreatePost(ctx context.Context, arg CreatePostParams) error {
 	return err
 }
 
-const createPostImage = `-- name: CreatePostImage :exec
-INSERT INTO post_images (
-  id, post_id, object_key, public_url, description, position, width, height, created_at
-)
-VALUES (
-  $1,
-  $2,
-  $3,
-  $4,
-  $5,
-  $6,
-  $7,
-  $8,
-  $9
-)
-`
-
-type CreatePostImageParams struct {
-	ID          string
-	PostID      string
-	ObjectKey   string
-	PublicUrl   string
-	Description string
-	Position    int16
-	Width       int32
-	Height      int32
-	CreatedAt   string
-}
-
-func (q *Queries) CreatePostImage(ctx context.Context, arg CreatePostImageParams) error {
-	_, err := q.db.ExecContext(ctx, createPostImage,
-		arg.ID,
-		arg.PostID,
-		arg.ObjectKey,
-		arg.PublicUrl,
-		arg.Description,
-		arg.Position,
-		arg.Width,
-		arg.Height,
-		arg.CreatedAt,
-	)
-	return err
-}
-
-const deletePostImages = `-- name: DeletePostImages :exec
-DELETE FROM post_images
-WHERE post_id = $1
-`
-
-func (q *Queries) DeletePostImages(ctx context.Context, postID string) error {
-	_, err := q.db.ExecContext(ctx, deletePostImages, postID)
-	return err
-}
-
 const deletePostVote = `-- name: DeletePostVote :exec
 DELETE FROM post_votes
 WHERE user_id = $1
@@ -199,47 +145,6 @@ func (q *Queries) GetRootPostVoteSummary(ctx context.Context, arg GetRootPostVot
 	return i, err
 }
 
-const listPostImages = `-- name: ListPostImages :many
-SELECT
-  id, post_id, object_key, public_url, description, position, width, height, created_at
-FROM post_images
-WHERE post_id = $1
-ORDER BY position
-`
-
-func (q *Queries) ListPostImages(ctx context.Context, postID string) ([]PostImage, error) {
-	rows, err := q.db.QueryContext(ctx, listPostImages, postID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []PostImage{}
-	for rows.Next() {
-		var i PostImage
-		if err := rows.Scan(
-			&i.ID,
-			&i.PostID,
-			&i.ObjectKey,
-			&i.PublicUrl,
-			&i.Description,
-			&i.Position,
-			&i.Width,
-			&i.Height,
-			&i.CreatedAt,
-		); 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 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
@@ -313,59 +218,6 @@ func (q *Queries) ListPostThread(ctx context.Context, rootID string) ([]ListPost
 	return items, nil
 }
 
-const listPostThreadImages = `-- name: ListPostThreadImages :many
-WITH RECURSIVE thread AS (
-  SELECT p.id
-  FROM posts p
-  WHERE p.id = $1 AND p.parent_id IS NULL
-
-  UNION ALL
-
-  SELECT child.id
-  FROM posts child
-  JOIN thread parent ON child.parent_id = parent.id
-)
-SELECT
-  images.id, images.post_id, images.object_key, images.public_url,
-  images.description, images.position, images.width, images.height, images.created_at
-FROM post_images images
-JOIN thread ON thread.id = images.post_id
-ORDER BY images.post_id, images.position
-`
-
-func (q *Queries) ListPostThreadImages(ctx context.Context, rootID string) ([]PostImage, error) {
-	rows, err := q.db.QueryContext(ctx, listPostThreadImages, rootID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []PostImage{}
-	for rows.Next() {
-		var i PostImage
-		if err := rows.Scan(
-			&i.ID,
-			&i.PostID,
-			&i.ObjectKey,
-			&i.PublicUrl,
-			&i.Description,
-			&i.Position,
-			&i.Width,
-			&i.Height,
-			&i.CreatedAt,
-		); 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

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/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,6 +27,16 @@ type Store interface {
 	SetUserRole(ctx context.Context, id string, role Role) error
 	SaveUserProfile(ctx context.Context, u *User) 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
+
 	CreatePost(ctx context.Context, post *Post) error
 	GetPost(ctx context.Context, id string) (*Post, error)
 	GetPostThread(ctx context.Context, rootID string) (*Post, error)
@@ -37,4 +47,7 @@ type Store interface {
 	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
+
+	// 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 is returned when demoting the only remaining admin.
+var ErrLastAdmin = errors.New("cannot demote the last 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")
-)
 
 // Role is a user privilege level stored in users.role.
 type Role string
@@ -58,17 +51,6 @@ 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 {
 	return &User{
 		ID:           id,

internal/store/vote.go

@@ -0,0 +1,71 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"strings"
+
+	"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")
+
+// ErrDuplicateEmail is returned when inserting/updating an email that already exists.
+var ErrDuplicateEmail = errors.New("email 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" {
+		if strings.Contains(strings.ToLower(pgErr.ConstraintName), "email") {
+			return ErrDuplicateEmail
+		}
+		return ErrDuplicateUsername
+	}
+	return err
+}

internal/web/post_images.go

@@ -1,395 +0,0 @@
-package web
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"image"
-	"image/jpeg"
-	"image/png"
-	"io"
-	"log"
-	"mime"
-	"mime/multipart"
-	"net/http"
-	"path"
-	"strings"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/rwcarlsen/goexif/exif"
-	"golang.org/x/image/draw"
-	_ "golang.org/x/image/webp"
-
-	"plumber/internal/blob"
-	"plumber/internal/store"
-)
-
-const (
-	defaultRequestBodyBytes  = 3 << 20
-	postImageMaxFileBytes    = 5 << 20
-	postImageMaxRequestBytes = 22 << 20
-	postImageMultipartMemory = 2 << 20
-	postImageMaxSourceDim    = 6000
-	postImageMaxSourcePixels = 16_000_000
-	postImageMaxRenderedDim  = 1600
-	postImageCleanupTimeout  = 10 * time.Second
-)
-
-func requestBodyLimit(r *http.Request) int64 {
-	if r.Method != http.MethodPost {
-		return defaultRequestBodyBytes
-	}
-	switch {
-	case r.URL.Path == "/submit", r.URL.Path == "/posts":
-		return postImageMaxRequestBytes
-	case strings.HasPrefix(r.URL.Path, "/posts/") && strings.HasSuffix(r.URL.Path, "/edit"):
-		return postImageMaxRequestBytes
-	default:
-		return defaultRequestBodyBytes
-	}
-}
-
-type postImageRequestError struct {
-	status  int
-	message string
-	cause   error
-}
-
-func (e *postImageRequestError) Error() string {
-	if e.cause == nil {
-		return e.message
-	}
-	return e.message + ": " + e.cause.Error()
-}
-
-func parsePostMutationForm(w http.ResponseWriter, r *http.Request) (func(), bool) {
-	contentType := r.Header.Get("Content-Type")
-	mediaType, _, err := mime.ParseMediaType(contentType)
-	if err != nil && strings.HasPrefix(strings.ToLower(contentType), "multipart/") {
-		http.Error(w, "Could not read image upload.", http.StatusBadRequest)
-		return func() {}, false
-	}
-	if mediaType != "multipart/form-data" {
-		if err := r.ParseForm(); err != nil {
-			writePostImageRequestError(w, err)
-			return func() {}, false
-		}
-		return func() {}, true
-	}
-	if err := r.ParseMultipartForm(postImageMultipartMemory); err != nil {
-		writePostImageRequestError(w, err)
-		return func() {}, false
-	}
-	cleanup := func() {
-		if r.MultipartForm != nil {
-			_ = r.MultipartForm.RemoveAll()
-		}
-	}
-	return cleanup, true
-}
-
-func writePostImageRequestError(w http.ResponseWriter, err error) {
-	var requestErr *postImageRequestError
-	if errors.As(err, &requestErr) {
-		http.Error(w, requestErr.message, requestErr.status)
-		return
-	}
-	var maxErr *http.MaxBytesError
-	if errors.As(err, &maxErr) {
-		http.Error(w, "Image upload is too large.", http.StatusRequestEntityTooLarge)
-		return
-	}
-	http.Error(w, "Could not read image upload.", http.StatusBadRequest)
-}
-
-func (s *Server) postImagesFromForm(
-	ctx context.Context,
-	r *http.Request,
-	postID string,
-	existing []store.PostImage,
-) ([]store.PostImage, []string, error) {
-	if r.MultipartForm == nil {
-		return append([]store.PostImage(nil), existing...), nil, nil
-	}
-	retained, err := retainedPostImages(r.MultipartForm, existing)
-	if err != nil {
-		return nil, nil, err
-	}
-	files := r.MultipartForm.File["images"]
-	descriptions := r.MultipartForm.Value["image_description"]
-	if len(descriptions) > len(files) {
-		return nil, nil, invalidPostImage("Image descriptions do not match selected images.", nil)
-	}
-	if len(retained)+len(files) > store.MaxPostImages {
-		return nil, nil, invalidPostImage("You can attach up to 4 images.", nil)
-	}
-	if len(files) > 0 && !s.cfg.Blob.Enabled() {
-		return nil, nil, &postImageRequestError{
-			status:  http.StatusServiceUnavailable,
-			message: "Image uploads are not configured on this server.",
-		}
-	}
-
-	images := append([]store.PostImage(nil), retained...)
-	newKeys := make([]string, 0, len(files))
-	for i, header := range files {
-		description := ""
-		if i < len(descriptions) {
-			description = strings.TrimSpace(descriptions[i])
-		}
-		if len([]rune(description)) > store.MaxImageDescriptionRunes {
-			s.deletePostImageObjects(newKeys)
-			return nil, nil, invalidPostImage("Image descriptions must be 500 characters or fewer.", nil)
-		}
-		prepared, err := preparePostImage(header)
-		if err != nil {
-			s.deletePostImageObjects(newKeys)
-			return nil, nil, err
-		}
-		imageID := uuid.NewString()
-		objectKey := path.Join("post-images", postID, imageID+prepared.extension)
-		publicURL, err := s.cfg.Blob.Upload(ctx, blob.FileUpload{
-			Key:         objectKey,
-			Body:        bytes.NewReader(prepared.body),
-			ContentType: prepared.contentType,
-			Size:        int64(len(prepared.body)),
-		})
-		if err != nil {
-			s.deletePostImageObjects(newKeys)
-			return nil, nil, &postImageRequestError{
-				status:  http.StatusServiceUnavailable,
-				message: "Could not upload image. Try again later.",
-				cause:   err,
-			}
-		}
-		newKeys = append(newKeys, objectKey)
-		images = append(images, store.PostImage{
-			ID:          imageID,
-			PostID:      postID,
-			ObjectKey:   objectKey,
-			PublicURL:   publicURL,
-			Description: description,
-			Width:       prepared.width,
-			Height:      prepared.height,
-		})
-	}
-	return images, newKeys, nil
-}
-
-func retainedPostImages(form *multipart.Form, existing []store.PostImage) ([]store.PostImage, error) {
-	byID := make(map[string]store.PostImage, len(existing))
-	for _, image := range existing {
-		byID[image.ID] = image
-	}
-	ids := form.Value["existing_image_id"]
-	descriptions := form.Value["existing_image_description"]
-	if len(descriptions) > len(ids) {
-		return nil, invalidPostImage("Existing image descriptions do not match the images.", nil)
-	}
-	seen := make(map[string]bool, len(ids))
-	retained := make([]store.PostImage, 0, len(ids))
-	for i, id := range ids {
-		id = strings.TrimSpace(id)
-		image, ok := byID[id]
-		if !ok || seen[id] {
-			return nil, invalidPostImage("An existing image selection is invalid.", nil)
-		}
-		seen[id] = true
-		if i < len(descriptions) {
-			image.Description = strings.TrimSpace(descriptions[i])
-		}
-		if len([]rune(image.Description)) > store.MaxImageDescriptionRunes {
-			return nil, invalidPostImage("Image descriptions must be 500 characters or fewer.", nil)
-		}
-		retained = append(retained, image)
-	}
-	return retained, nil
-}
-
-func invalidPostImage(message string, cause error) error {
-	return &postImageRequestError{status: http.StatusBadRequest, message: message, cause: cause}
-}
-
-type preparedPostImage struct {
-	body        []byte
-	extension   string
-	contentType string
-	width       int
-	height      int
-}
-
-func preparePostImage(header *multipart.FileHeader) (preparedPostImage, error) {
-	if header == nil {
-		return preparedPostImage{}, invalidPostImage("Select a valid image.", nil)
-	}
-	if header.Size > postImageMaxFileBytes {
-		return preparedPostImage{}, &postImageRequestError{
-			status:  http.StatusRequestEntityTooLarge,
-			message: "Each image must be 5 MB or smaller.",
-		}
-	}
-	file, err := header.Open()
-	if err != nil {
-		return preparedPostImage{}, invalidPostImage("Could not read image.", err)
-	}
-	defer file.Close()
-	raw, err := io.ReadAll(io.LimitReader(file, postImageMaxFileBytes+1))
-	if err != nil {
-		return preparedPostImage{}, invalidPostImage("Could not read image.", err)
-	}
-	if len(raw) == 0 {
-		return preparedPostImage{}, invalidPostImage("Images cannot be empty.", nil)
-	}
-	if int64(len(raw)) > postImageMaxFileBytes {
-		return preparedPostImage{}, &postImageRequestError{
-			status:  http.StatusRequestEntityTooLarge,
-			message: "Each image must be 5 MB or smaller.",
-		}
-	}
-	sniffed := http.DetectContentType(raw)
-	switch sniffed {
-	case "image/jpeg", "image/png", "image/webp":
-	default:
-		return preparedPostImage{}, invalidPostImage("Images must be JPEG, PNG, or WebP.", nil)
-	}
-	cfg, format, err := image.DecodeConfig(bytes.NewReader(raw))
-	if err != nil {
-		return preparedPostImage{}, invalidPostImage("Could not decode image.", err)
-	}
-	if cfg.Width <= 0 || cfg.Height <= 0 ||
-		cfg.Width > postImageMaxSourceDim || cfg.Height > postImageMaxSourceDim ||
-		int64(cfg.Width)*int64(cfg.Height) > postImageMaxSourcePixels {
-		return preparedPostImage{}, invalidPostImage("Image dimensions are too large.", nil)
-	}
-	decoded, decodedFormat, err := image.Decode(bytes.NewReader(raw))
-	if err != nil {
-		return preparedPostImage{}, invalidPostImage("Could not decode image.", err)
-	}
-	if format != "" {
-		decodedFormat = format
-	}
-	if sniffed == "image/jpeg" {
-		decoded = orientPostImage(decoded, jpegOrientation(raw))
-	}
-	decoded = fitPostImage(decoded, postImageMaxRenderedDim)
-
-	var out bytes.Buffer
-	result := preparedPostImage{}
-	switch decodedFormat {
-	case "jpeg":
-		if err := jpeg.Encode(&out, decoded, &jpeg.Options{Quality: 85}); err != nil {
-			return preparedPostImage{}, invalidPostImage("Could not encode image.", err)
-		}
-		result.extension = ".jpg"
-		result.contentType = "image/jpeg"
-	case "png", "webp":
-		if err := png.Encode(&out, decoded); err != nil {
-			return preparedPostImage{}, invalidPostImage("Could not encode image.", err)
-		}
-		result.extension = ".png"
-		result.contentType = "image/png"
-	default:
-		return preparedPostImage{}, invalidPostImage("Images must be JPEG, PNG, or WebP.", nil)
-	}
-	result.body = out.Bytes()
-	result.width = decoded.Bounds().Dx()
-	result.height = decoded.Bounds().Dy()
-	return result, nil
-}
-
-func jpegOrientation(raw []byte) int {
-	metadata, err := exif.Decode(bytes.NewReader(raw))
-	if err != nil {
-		return 1
-	}
-	tag, err := metadata.Get(exif.Orientation)
-	if err != nil {
-		return 1
-	}
-	orientation, err := tag.Int(0)
-	if err != nil || orientation < 1 || orientation > 8 {
-		return 1
-	}
-	return orientation
-}
-
-func orientPostImage(source image.Image, orientation int) image.Image {
-	if orientation <= 1 || orientation > 8 {
-		return source
-	}
-	bounds := source.Bounds()
-	width, height := bounds.Dx(), bounds.Dy()
-	targetWidth, targetHeight := width, height
-	if orientation >= 5 {
-		targetWidth, targetHeight = height, width
-	}
-	target := image.NewNRGBA(image.Rect(0, 0, targetWidth, targetHeight))
-	for y := 0; y < targetHeight; y++ {
-		for x := 0; x < targetWidth; x++ {
-			sourceX, sourceY := x, y
-			switch orientation {
-			case 2:
-				sourceX = width - 1 - x
-			case 3:
-				sourceX, sourceY = width-1-x, height-1-y
-			case 4:
-				sourceY = height - 1 - y
-			case 5:
-				sourceX, sourceY = y, x
-			case 6:
-				sourceX, sourceY = y, height-1-x
-			case 7:
-				sourceX, sourceY = width-1-y, height-1-x
-			case 8:
-				sourceX, sourceY = width-1-y, x
-			}
-			target.Set(x, y, source.At(bounds.Min.X+sourceX, bounds.Min.Y+sourceY))
-		}
-	}
-	return target
-}
-
-func fitPostImage(source image.Image, maxDimension int) image.Image {
-	bounds := source.Bounds()
-	width, height := bounds.Dx(), bounds.Dy()
-	if width <= maxDimension && height <= maxDimension {
-		return source
-	}
-	scale := float64(maxDimension) / float64(width)
-	if float64(height)*scale > float64(maxDimension) {
-		scale = float64(maxDimension) / float64(height)
-	}
-	targetWidth := max(1, int(float64(width)*scale))
-	targetHeight := max(1, int(float64(height)*scale))
-	target := image.NewNRGBA(image.Rect(0, 0, targetWidth, targetHeight))
-	draw.CatmullRom.Scale(target, target.Bounds(), source, bounds, draw.Over, nil)
-	return target
-}
-
-func (s *Server) deletePostImageObjects(keys []string) {
-	if len(keys) == 0 {
-		return
-	}
-	ctx, cancel := context.WithTimeout(context.Background(), postImageCleanupTimeout)
-	defer cancel()
-	for _, key := range keys {
-		if err := s.cfg.Blob.Delete(ctx, key); err != nil {
-			log.Printf("delete post image %s: %v", key, err)
-		}
-	}
-}
-
-func removedPostImageKeys(before, after []store.PostImage) []string {
-	retained := make(map[string]bool, len(after))
-	for _, image := range after {
-		retained[image.ObjectKey] = true
-	}
-	var removed []string
-	for _, image := range before {
-		if !retained[image.ObjectKey] {
-			removed = append(removed, image.ObjectKey)
-		}
-	}
-	return removed
-}

internal/web/post_images_test.go

@@ -1,443 +0,0 @@
-package web
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"image"
-	"image/color"
-	"image/jpeg"
-	"image/png"
-	"io"
-	"mime/multipart"
-	"net/http"
-	"net/http/httptest"
-	"sync"
-	"testing"
-
-	"plumber/internal/blob"
-	"plumber/internal/pacific"
-	"plumber/internal/store"
-)
-
-func TestPreparePostImage(t *testing.T) {
-	t.Parallel()
-
-	wide := solidPNG(t, 2000, 1000)
-	prepared, err := preparePostImageHeader(t, "wide.png", wide)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if prepared.width != 1600 || prepared.height != 800 ||
-		prepared.extension != ".png" || prepared.contentType != "image/png" {
-		t.Fatalf("prepared PNG = %+v", prepared)
-	}
-
-	jpegBody := solidJPEG(t, 40, 20)
-	prepared, err = preparePostImageHeader(t, "photo.jpg", jpegBody)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if prepared.width != 40 || prepared.height != 20 ||
-		prepared.extension != ".jpg" || prepared.contentType != "image/jpeg" {
-		t.Fatalf("prepared JPEG = %+v", prepared)
-	}
-
-	if _, err := preparePostImageHeader(t, "notes.txt", []byte("not an image")); err == nil {
-		t.Fatal("text upload unexpectedly succeeded")
-	}
-	_, err = preparePostImageHeader(t, "too-large.jpg", make([]byte, postImageMaxFileBytes+1))
-	var requestErr *postImageRequestError
-	if !errors.As(err, &requestErr) || requestErr.status != http.StatusRequestEntityTooLarge {
-		t.Fatalf("oversized file error = %v, want 413 request error", err)
-	}
-	if _, err := preparePostImageHeader(t, "too-wide.png", solidPNG(t, 6001, 1)); err == nil {
-		t.Fatal("oversized dimensions unexpectedly succeeded")
-	}
-}
-
-func TestOrientPostImage(t *testing.T) {
-	t.Parallel()
-
-	source := image.NewNRGBA(image.Rect(0, 0, 2, 1))
-	source.Set(0, 0, color.NRGBA{R: 255, A: 255})
-	source.Set(1, 0, color.NRGBA{B: 255, A: 255})
-	rotated := orientPostImage(source, 6)
-	if rotated.Bounds().Dx() != 1 || rotated.Bounds().Dy() != 2 {
-		t.Fatalf("rotated bounds = %v", rotated.Bounds())
-	}
-	top := color.NRGBAModel.Convert(rotated.At(0, 0)).(color.NRGBA)
-	bottom := color.NRGBAModel.Convert(rotated.At(0, 1)).(color.NRGBA)
-	if top.R != 255 || bottom.B != 255 {
-		t.Fatalf("rotation colors top=%v bottom=%v", top, bottom)
-	}
-}
-
-func TestPostImageMultipartLifecycle(t *testing.T) {
-	t.Parallel()
-
-	images := &recordingImageBlob{}
-	srv, mem := newTestServer(t, Config{Blob: images})
-	handler := srv.Handler()
-	homeowner := seedUser(t, mem, uniq("images"), "hunter22", store.RoleUser)
-	cookies := loginUser(t, handler, homeowner.Username, "hunter22")
-	csrf := csrfForCookies(t, handler, cookies)
-
-	rec := multipartPost(t, handler, "/submit", map[string][]string{
-		"_csrf":             {csrf},
-		"title":             {"Leaky valve"},
-		"body":              {"Two views of the leak."},
-		"city":              {"Oakland"},
-		"image_description": {"Front view", "Under the sink"},
-	}, []multipartTestFile{
-		{name: "front.png", body: solidPNG(t, 80, 40)},
-		{name: "under.jpg", body: solidJPEG(t, 40, 80)},
-	}, cookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("root image upload status = %d: %s", rec.Code, rec.Body.String())
-	}
-	roots, err := mem.ListRootPosts(context.Background(), pacific.Today(), homeowner.ID)
-	if err != nil || len(roots) != 1 {
-		t.Fatalf("roots = %+v, %v", roots, err)
-	}
-	root, err := mem.GetPost(context.Background(), roots[0].ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(root.Images) != 2 ||
-		root.Images[0].Description != "Front view" ||
-		root.Images[1].Description != "Under the sink" {
-		t.Fatalf("root images = %+v", root.Images)
-	}
-
-	rec = multipartPost(t, handler, "/posts", map[string][]string{
-		"_csrf":             {csrf},
-		"parent_id":         {root.ID},
-		"body":              {"Here is the model label."},
-		"image_description": {"Model label"},
-	}, []multipartTestFile{{name: "label.png", body: solidPNG(t, 60, 30)}}, cookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("reply image upload 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("thread = %+v, %v", thread, err)
-	}
-	reply := thread.Replies[0]
-	if len(reply.Images) != 1 || reply.Images[0].Description != "Model label" {
-		t.Fatalf("reply images = %+v", reply.Images)
-	}
-	originalKey := reply.Images[0].ObjectKey
-
-	rec = multipartPost(t, handler, "/posts/"+reply.ID+"/edit", map[string][]string{
-		"_csrf":                      {csrf},
-		"body":                       {"Updated label photos."},
-		"existing_image_id":          {reply.Images[0].ID},
-		"existing_image_description": {"Existing label"},
-		"image_description":          {"Serial number"},
-	}, []multipartTestFile{{name: "serial.jpg", body: solidJPEG(t, 50, 25)}}, cookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("image edit status = %d: %s", rec.Code, rec.Body.String())
-	}
-	edited, err := mem.GetPost(context.Background(), reply.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(edited.Images) != 2 ||
-		edited.Images[0].Description != "Existing label" ||
-		edited.Images[1].Description != "Serial number" {
-		t.Fatalf("edited images = %+v", edited.Images)
-	}
-
-	rec = multipartPost(t, handler, "/posts/"+reply.ID+"/edit", map[string][]string{
-		"_csrf":                      {csrf},
-		"body":                       {"Keep only the serial number."},
-		"existing_image_id":          {edited.Images[1].ID},
-		"existing_image_description": {"Serial number"},
-	}, nil, cookies)
-	if rec.Code != http.StatusSeeOther {
-		t.Fatalf("image removal status = %d: %s", rec.Code, rec.Body.String())
-	}
-	edited, err = mem.GetPost(context.Background(), reply.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(edited.Images) != 1 || edited.Images[0].Description != "Serial number" {
-		t.Fatalf("images after removal = %+v", edited.Images)
-	}
-	if !images.wasDeleted(originalKey) {
-		t.Fatalf("removed object %q was not deleted: %+v", originalKey, images.deletedKeys())
-	}
-
-	uploadsBefore := images.uploadCount()
-	rec = multipartPost(t, handler, "/posts/"+reply.ID+"/edit", map[string][]string{
-		"_csrf":             {csrf},
-		"body":              {"Invalid retained image."},
-		"existing_image_id": {"not-owned"},
-	}, nil, cookies)
-	if rec.Code != http.StatusBadRequest {
-		t.Fatalf("invalid retained image status = %d, want 400", rec.Code)
-	}
-	unchanged, err := mem.GetPost(context.Background(), reply.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if unchanged.Body != "Keep only the serial number." || len(unchanged.Images) != 1 {
-		t.Fatalf("invalid retained image changed post: %+v", unchanged)
-	}
-
-	files := make([]multipartTestFile, store.MaxPostImages+1)
-	for i := range files {
-		files[i] = multipartTestFile{name: "extra.png", body: solidPNG(t, 10, 10)}
-	}
-	rec = multipartPost(t, handler, "/posts", map[string][]string{
-		"_csrf":     {csrf},
-		"parent_id": {root.ID},
-		"body":      {"Too many images."},
-	}, files, cookies)
-	if rec.Code != http.StatusBadRequest {
-		t.Fatalf("five-image status = %d, want 400", rec.Code)
-	}
-	if images.uploadCount() != uploadsBefore {
-		t.Fatal("five-image request uploaded objects before rejecting count")
-	}
-}
-
-func TestPostImageUploadCompensation(t *testing.T) {
-	t.Parallel()
-
-	t.Run("blob failure deletes earlier upload", func(t *testing.T) {
-		images := &recordingImageBlob{failAt: 2}
-		srv, mem := newTestServer(t, Config{Blob: images})
-		handler := srv.Handler()
-		user := seedUser(t, mem, uniq("blob-fail"), "hunter22", store.RoleUser)
-		cookies := loginUser(t, handler, user.Username, "hunter22")
-		csrf := csrfForCookies(t, handler, cookies)
-		rec := multipartPost(t, handler, "/submit", map[string][]string{
-			"_csrf": {csrf},
-			"title": {"Upload failure"},
-			"body":  {"Should not persist."},
-		}, []multipartTestFile{
-			{name: "one.png", body: solidPNG(t, 10, 10)},
-			{name: "two.png", body: solidPNG(t, 10, 10)},
-		}, cookies)
-		if rec.Code != http.StatusServiceUnavailable {
-			t.Fatalf("blob failure status = %d: %s", rec.Code, rec.Body.String())
-		}
-		if images.uploadCount() != 1 || len(images.deletedKeys()) != 1 {
-			t.Fatalf("blob compensation uploads=%d deletes=%v", images.uploadCount(), images.deletedKeys())
-		}
-	})
-
-	t.Run("store failure deletes uploaded object", func(t *testing.T) {
-		images := &recordingImageBlob{}
-		mem := store.NewMemory()
-		failing := &failingCreatePostStore{Store: mem}
-		srv := newTestServerStore(t, failing, Config{Blob: images})
-		handler := srv.Handler()
-		user := seedUser(t, mem, uniq("store-fail"), "hunter22", store.RoleUser)
-		cookies := loginUser(t, handler, user.Username, "hunter22")
-		csrf := csrfForCookies(t, handler, cookies)
-		rec := multipartPost(t, handler, "/submit", map[string][]string{
-			"_csrf": {csrf},
-			"title": {"Store failure"},
-			"body":  {"Should clean up."},
-		}, []multipartTestFile{{name: "one.png", body: solidPNG(t, 10, 10)}}, cookies)
-		if rec.Code != http.StatusInternalServerError {
-			t.Fatalf("store failure status = %d: %s", rec.Code, rec.Body.String())
-		}
-		if images.uploadCount() != 1 || len(images.deletedKeys()) != 1 {
-			t.Fatalf("store compensation uploads=%d deletes=%v", images.uploadCount(), images.deletedKeys())
-		}
-	})
-}
-
-func TestPostImageRequestLimits(t *testing.T) {
-	t.Parallel()
-
-	for _, test := range []struct {
-		method string
-		path   string
-		want   int64
-	}{
-		{http.MethodPost, "/submit", postImageMaxRequestBytes},
-		{http.MethodPost, "/posts", postImageMaxRequestBytes},
-		{http.MethodPost, "/posts/id/edit", postImageMaxRequestBytes},
-		{http.MethodPost, "/login", defaultRequestBodyBytes},
-		{http.MethodGet, "/posts", defaultRequestBodyBytes},
-	} {
-		req := httptest.NewRequest(test.method, test.path, nil)
-		if got := requestBodyLimit(req); got != test.want {
-			t.Errorf("%s %s limit = %d, want %d", test.method, test.path, got, test.want)
-		}
-	}
-}
-
-type multipartTestFile struct {
-	name string
-	body []byte
-}
-
-func multipartPost(
-	t *testing.T,
-	handler http.Handler,
-	requestPath string,
-	fields map[string][]string,
-	files []multipartTestFile,
-	cookies []*http.Cookie,
-) *httptest.ResponseRecorder {
-	t.Helper()
-	var body bytes.Buffer
-	writer := multipart.NewWriter(&body)
-	for name, values := range fields {
-		for _, value := range values {
-			if err := writer.WriteField(name, value); err != nil {
-				t.Fatal(err)
-			}
-		}
-	}
-	for _, file := range files {
-		part, err := writer.CreateFormFile("images", file.name)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, err := part.Write(file.body); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := writer.Close(); err != nil {
-		t.Fatal(err)
-	}
-	req := httptest.NewRequest(http.MethodPost, requestPath, &body)
-	req.Header.Set("Content-Type", writer.FormDataContentType())
-	for _, cookie := range cookies {
-		req.AddCookie(cookie)
-	}
-	rec := httptest.NewRecorder()
-	handler.ServeHTTP(rec, req)
-	return rec
-}
-
-func preparePostImageHeader(t *testing.T, name string, body []byte) (preparedPostImage, error) {
-	t.Helper()
-	var requestBody bytes.Buffer
-	writer := multipart.NewWriter(&requestBody)
-	part, err := writer.CreateFormFile("images", name)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := part.Write(body); err != nil {
-		t.Fatal(err)
-	}
-	if err := writer.Close(); err != nil {
-		t.Fatal(err)
-	}
-	req := httptest.NewRequest(http.MethodPost, "/posts", &requestBody)
-	req.Header.Set("Content-Type", writer.FormDataContentType())
-	if err := req.ParseMultipartForm(postImageMultipartMemory); err != nil {
-		t.Fatal(err)
-	}
-	defer req.MultipartForm.RemoveAll()
-	return preparePostImage(req.MultipartForm.File["images"][0])
-}
-
-func solidPNG(t *testing.T, width, height int) []byte {
-	t.Helper()
-	img := image.NewNRGBA(image.Rect(0, 0, width, height))
-	for y := 0; y < height; y++ {
-		for x := 0; x < width; x++ {
-			img.Set(x, y, color.NRGBA{R: 30, G: 90, B: 140, A: 255})
-		}
-	}
-	var out bytes.Buffer
-	if err := png.Encode(&out, img); err != nil {
-		t.Fatal(err)
-	}
-	return out.Bytes()
-}
-
-func solidJPEG(t *testing.T, width, height int) []byte {
-	t.Helper()
-	img := image.NewNRGBA(image.Rect(0, 0, width, height))
-	for y := 0; y < height; y++ {
-		for x := 0; x < width; x++ {
-			img.Set(x, y, color.NRGBA{R: 140, G: 90, B: 30, A: 255})
-		}
-	}
-	var out bytes.Buffer
-	if err := jpeg.Encode(&out, img, &jpeg.Options{Quality: 90}); err != nil {
-		t.Fatal(err)
-	}
-	return out.Bytes()
-}
-
-type recordedImageUpload struct {
-	key         string
-	contentType string
-	body        []byte
-}
-
-type recordingImageBlob struct {
-	mu      sync.Mutex
-	calls   int
-	failAt  int
-	uploads []recordedImageUpload
-	deletes []string
-}
-
-func (b *recordingImageBlob) Enabled() bool { return true }
-
-func (b *recordingImageBlob) Upload(_ context.Context, object blob.FileUpload) (string, error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	b.calls++
-	if b.failAt > 0 && b.calls == b.failAt {
-		return "", errors.New("injected upload failure")
-	}
-	body, err := io.ReadAll(object.Body)
-	if err != nil {
-		return "", err
-	}
-	b.uploads = append(b.uploads, recordedImageUpload{
-		key:         object.Key,
-		contentType: object.ContentType,
-		body:        body,
-	})
-	return "https://cdn.example/" + object.Key, nil
-}
-
-func (b *recordingImageBlob) Delete(_ context.Context, key string) error {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	b.deletes = append(b.deletes, key)
-	return nil
-}
-
-func (b *recordingImageBlob) uploadCount() int {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	return len(b.uploads)
-}
-
-func (b *recordingImageBlob) deletedKeys() []string {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	return append([]string(nil), b.deletes...)
-}
-
-func (b *recordingImageBlob) wasDeleted(key string) bool {
-	for _, deleted := range b.deletedKeys() {
-		if deleted == key {
-			return true
-		}
-	}
-	return false
-}
-
-type failingCreatePostStore struct {
-	store.Store
-}
-
-func (f *failingCreatePostStore) CreatePost(context.Context, *store.Post) error {
-	return errors.New("injected store failure")
-}

internal/web/posts.go

@@ -12,7 +12,6 @@ import (
 	"time"
 
 	"github.com/go-chi/chi/v5"
-	"github.com/google/uuid"
 
 	"plumber/internal/mail"
 	"plumber/internal/store"
@@ -21,11 +20,6 @@ import (
 // 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) {
-	cleanup, ok := parsePostMutationForm(w, r)
-	if !ok {
-		return
-	}
-	defer cleanup()
 	if !s.requireCSRF(w, r) {
 		return
 	}
@@ -43,7 +37,6 @@ func (s *Server) handleCreatePost(w http.ResponseWriter, r *http.Request) {
 	}
 
 	post := &store.Post{
-		ID:       uuid.NewString(),
 		AuthorID: user.ID,
 		Body:     truncateRunes(body, 12000),
 	}
@@ -78,14 +71,7 @@ func (s *Server) handleCreatePost(w http.ResponseWriter, r *http.Request) {
 		root = threadRoot
 	}
 
-	images, newKeys, err := s.postImagesFromForm(r.Context(), r, post.ID, nil)
-	if err != nil {
-		writePostImageRequestError(w, err)
-		return
-	}
-	post.Images = images
 	if err := s.store.CreatePost(r.Context(), post); err != nil {
-		s.deletePostImageObjects(newKeys)
 		if errors.Is(err, store.ErrInvalidPost) {
 			http.Error(w, "invalid post", http.StatusBadRequest)
 			return
@@ -107,8 +93,7 @@ func (s *Server) handleCreatePost(w http.ResponseWriter, r *http.Request) {
 	)
 }
 
-// notifyPostReply emails the root homeowner for admin replies and the direct
+// notifyPostReply asynchronously emails the direct parent post's author.
-// parent author for homeowner replies.
 func (s *Server) notifyPostReply(
 	parent *store.Post,
 	root *store.Post,
@@ -119,19 +104,13 @@ func (s *Server) notifyPostReply(
 		root == nil ||
 		reply == nil ||
 		replyAuthor == nil ||
-		s.cfg.Mail == nil {
+		s.cfg.Mail == nil ||
+		parent.AuthorID == replyAuthor.ID {
 		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,
@@ -139,6 +118,7 @@ func (s *Server) notifyPostReply(
 		ReplyBody:       reply.Body,
 		ReplyAuthorName: replyAuthor.Name,
 	}
+	recipientID := parent.AuthorID
 	go func() {
 		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 		defer cancel()
@@ -163,11 +143,6 @@ func (s *Server) notifyPostReply(
 // 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) {
-	cleanup, ok := parsePostMutationForm(w, r)
-	if !ok {
-		return
-	}
-	defer cleanup()
 	if !s.requireCSRF(w, r) {
 		return
 	}
@@ -196,16 +171,8 @@ func (s *Server) handleEditPost(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "post body required", http.StatusBadRequest)
 		return
 	}
-	previousImages := append([]store.PostImage(nil), post.Images...)
-	images, newKeys, err := s.postImagesFromForm(r.Context(), r, post.ID, previousImages)
-	if err != nil {
-		writePostImageRequestError(w, err)
-		return
-	}
 	post.Body = truncateRunes(body, 12000)
-	post.Images = images
 	if err := s.store.UpdatePost(r.Context(), post); err != nil {
-		s.deletePostImageObjects(newKeys)
 		if errors.Is(err, store.ErrInvalidPost) {
 			http.Error(w, "invalid post", http.StatusBadRequest)
 			return
@@ -217,7 +184,6 @@ func (s *Server) handleEditPost(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "could not save post", http.StatusInternalServerError)
 		return
 	}
-	s.deletePostImageObjects(removedPostImageKeys(previousImages, images))
 	http.Redirect(
 		w,
 		r,

internal/web/posts_test.go

@@ -334,22 +334,6 @@ func TestPostReplyNotifications(t *testing.T) {
 		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},
@@ -392,7 +376,7 @@ func TestPostReplyNotifications(t *testing.T) {
 		t.Fatalf("no-email reply status = %d: %s", rec.Code, rec.Body.String())
 	}
 	time.Sleep(50 * time.Millisecond)
-	if recording.Len() != 3 {
+	if recording.Len() != 2 {
 		t.Fatalf("self, edit, or no-email action sent a notification: %+v", recording.Snapshot())
 	}
 }
@@ -458,13 +442,8 @@ func TestQuestionPageRendersNestedPostControls(t *testing.T) {
 		"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')`,
 	} {
@@ -472,9 +451,6 @@ func TestQuestionPageRendersNestedPostControls(t *testing.T) {
 			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)
 	}

internal/web/server.go

@@ -18,7 +18,6 @@ import (
 	"github.com/alexedwards/scs/v2"
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
-	"github.com/google/uuid"
 
 	"plumber/internal/blob"
 	"plumber/internal/geo"
@@ -183,7 +182,7 @@ func (s *Server) Handler() http.Handler {
 	r.Use(middleware.Recoverer)
 	r.Use(func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			r.Body = http.MaxBytesReader(w, r.Body, requestBodyLimit(r))
+			r.Body = http.MaxBytesReader(w, r.Body, 3<<20)
 			next.ServeHTTP(w, r)
 		})
 	})
@@ -197,6 +196,7 @@ 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)
@@ -332,11 +332,6 @@ func (s *Server) handleSubmitForm(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s *Server) handleSubmit(w http.ResponseWriter, r *http.Request) {
-	cleanup, ok := parsePostMutationForm(w, r)
-	if !ok {
-		return
-	}
-	defer cleanup()
 	if !s.requireCSRF(w, r) {
 		return
 	}
@@ -368,20 +363,12 @@ func (s *Server) handleSubmit(w http.ResponseWriter, r *http.Request) {
 		city = truncateRunes(city, 80)
 	}
 	post := &store.Post{
-		ID:       uuid.NewString(),
 		AuthorID: u.ID,
 		Title:    title,
 		Body:     body,
 		City:     city,
 	}
-	images, newKeys, err := s.postImagesFromForm(r.Context(), r, post.ID, nil)
-	if err != nil {
-		writePostImageRequestError(w, err)
-		return
-	}
-	post.Images = images
 	if err := s.store.CreatePost(r.Context(), post); err != nil {
-		s.deletePostImageObjects(newKeys)
 		http.Error(w, "could not save question", http.StatusInternalServerError)
 		return
 	}
@@ -491,6 +478,48 @@ func (s *Server) renderLeaderboard(w http.ResponseWriter, r *http.Request, date
 	})
 }
 
+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)
+	}
+	root, err := s.store.GetPost(r.Context(), id)
+	if err != nil || root.ParentID != nil || root.PostState == store.PostStateHidden {
+		http.NotFound(w, r)
+		return
+	}
+	reply := &store.Post{
+		ParentID: &root.ID,
+		AuthorID: u.ID,
+		Body:     body,
+	}
+	if err := s.store.CreatePost(r.Context(), reply); err != nil {
+		http.Error(w, "could not save answer", http.StatusInternalServerError)
+		return
+	}
+	s.notifyPostReply(root, root, reply, u)
+	location := "/questions/" + url.PathEscape(id) + "#post-" + url.PathEscape(reply.ID)
+	if isHTMX(r) {
+		w.Header().Set("HX-Redirect", location)
+		w.WriteHeader(http.StatusSeeOther)
+		return
+	}
+	http.Redirect(w, r, location, http.StatusSeeOther)
+}
+
 func (s *Server) handleHide(w http.ResponseWriter, r *http.Request) {
 	if !s.requireCSRF(w, r) {
 		return

internal/web/server_test.go

@@ -19,6 +19,7 @@ import (
 
 	"plumber"
 	"plumber/internal/blob"
+	"plumber/internal/mail"
 	"plumber/internal/pacific"
 	"plumber/internal/store"
 )
@@ -168,16 +169,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)
@@ -492,12 +483,13 @@ func TestProfileAdminAnsweredListAndAvatarUpload(t *testing.T) {
 	}
 }
 
-func TestMutationsVoteHideAndCSRF(t *testing.T) {
+func TestMutationsVoteAnswerHideAndCSRF(t *testing.T) {
-	srv, mem := newTestServer(t, Config{})
+	recording := &mail.Recording{}
+	srv, mem := newTestServer(t, Config{Mail: recording})
 	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")
@@ -570,11 +562,92 @@ func TestMutationsVoteHideAndCSRF(t *testing.T) {
 		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 {
+	csrf = csrfFrom(rec.Body.String())
-		t.Fatalf("removed answer endpoint want 404, got %d", rec.Code)
+	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 compatibility route creates a reply and redirects the thread.
+	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 != http.StatusSeeOther {
+		t.Fatalf("admin answer: %d %s", rec.Code, rec.Body.String())
+	}
+	thread, err := mem.GetPostThread(context.Background(), q.ID)
+	if err != nil || len(thread.Replies) != 1 {
+		t.Fatalf("admin reply missing: %+v %v", thread, err)
+	}
+	adminReply := thread.Replies[0]
+	if adminReply.AuthorID != admin.ID || adminReply.Body != "Tighten the nuts." {
+		t.Fatalf("unexpected admin reply: %+v", adminReply)
+	}
+	if got := rec.Header().Get("HX-Redirect"); got != "/questions/"+q.ID+"#post-"+adminReply.ID {
+		t.Fatalf("admin answer redirect = %q", got)
+	}
+	msgs := waitForMail(t, recording, 1)
+	if msg := msgs[0]; msg.ToEmail != user.Email ||
+		msg.RootID != q.ID ||
+		msg.ReplyID != adminReply.ID ||
+		msg.ReplyBody != adminReply.Body {
+		t.Fatalf("compatibility reply notification = %+v", msg)
+	}
+
+	rec = httptest.NewRecorder()
+	req = httptest.NewRequest(http.MethodGet, "/questions/"+q.ID, nil)
+	for _, c := range adminCookies {
+		req.AddCookie(c)
+	}
+	h.ServeHTTP(rec, req)
+	if body := rec.Body.String(); !strings.Contains(body, "Tighten the nuts.") ||
+		!strings.Contains(body, "<summary>Edit</summary>") ||
+		!strings.Contains(body, ">Tighten the nuts.</textarea>") ||
+		!strings.Contains(body, `type="reset" class="btn btn-ghost"`) ||
+		!strings.Contains(body, `removeAttribute('open')`) ||
+		strings.Contains(body, `<details class="post-composer" open`) {
+		t.Fatalf("admin reply editor is not collapsed and populated: %s", body)
+	}
+
+	// The public reply is visible to the root author, but editing remains admin-only.
+	rec = httptest.NewRecorder()
+	req = httptest.NewRequest(http.MethodGet, "/questions/"+q.ID, nil)
+	for _, c := range userCookies {
+		req.AddCookie(c)
+	}
+	h.ServeHTTP(rec, req)
+	if rec.Code != 200 || !strings.Contains(rec.Body.String(), "Tighten the nuts.") {
+		t.Fatalf("question author cannot see answer: %d %s", rec.Code, rec.Body.String())
+	}
+	if strings.Contains(rec.Body.String(), `/posts/`+adminReply.ID+`/edit`) {
+		t.Fatalf("question author can edit admin reply: %s", rec.Body.String())
 	}
 
 	// Hide invalid id

schema.sql

@@ -14,6 +14,34 @@ CREATE UNIQUE INDEX IF NOT EXISTS users_email_lower_uidx
   ON users (lower(email))
   WHERE email <> '';
 
+CREATE TABLE IF NOT EXISTS questions (
+  id TEXT PRIMARY KEY,
+  author_id TEXT NOT NULL REFERENCES users(id),
+  title TEXT NOT NULL,
+  body TEXT NOT NULL,
+  city TEXT NOT NULL DEFAULT '',
+  hunt_date TEXT NOT NULL,
+  hidden INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_questions_hunt_date ON questions(hunt_date, hidden);
+
+CREATE TABLE IF NOT EXISTS votes (
+  user_id TEXT NOT NULL REFERENCES users(id),
+  question_id TEXT NOT NULL REFERENCES questions(id) ON DELETE CASCADE,
+  value INTEGER NOT NULL CHECK (value IN (-1, 1)),
+  PRIMARY KEY (user_id, question_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 posts (
   id TEXT PRIMARY KEY,
   parent_id TEXT REFERENCES posts(id) ON DELETE CASCADE,
@@ -42,19 +70,6 @@ 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_images (
-  id TEXT PRIMARY KEY,
-  post_id TEXT NOT NULL REFERENCES posts(id) ON DELETE CASCADE,
-  object_key TEXT NOT NULL UNIQUE,
-  public_url TEXT NOT NULL,
-  description TEXT NOT NULL DEFAULT '' CHECK (char_length(description) <= 500),
-  position SMALLINT NOT NULL CHECK (position BETWEEN 0 AND 3),
-  width INTEGER NOT NULL CHECK (width > 0),
-  height INTEGER NOT NULL CHECK (height > 0),
-  created_at TEXT NOT NULL,
-  UNIQUE (post_id, position)
-);
-
 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,

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);
@@ -749,11 +718,6 @@ input:focus, textarea:focus, .btn:focus-visible, .chip:focus-visible, .vote-btn:
 
 .post-form-actions .btn { flex: 1 1 10rem; }
 
-.post-permalink {
-  display: inline-flex;
-  align-items: center;
-}
-
 .post-hide {
   margin: 0;
 }
@@ -799,10 +763,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/_post.html

@@ -3,14 +3,13 @@
   {{if canReply .User .Root}}
     <details class="post-composer">
       <summary>Reply</summary>
-      <form class="post-form" method="post" action="/posts"
+      <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="submit" class="btn btn-primary">Post reply</button>
           <button type="reset" class="btn btn-ghost"
             onclick="this.closest('details').removeAttribute('open')">Cancel</button>
         </div>
@@ -33,9 +32,6 @@
       </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}}">

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"
+  <form class="ask" method="post" action="/submit">
-    data-submit-once data-submitting-label="Posting…">
     <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" .}}