Add video picker and Discord video attachments.

The picker accepts one MP4 or WebM, the thread lightbox zooms photos, and Discord gets the video as a file on a follow-up message so photo embeds still render.

internal/web/events.go

@@ -7,8 +7,26 @@ import (
 	"plumber/internal/store"
 )
 
-func (s *Server) publishPostCreated(post, root *store.Post, author *store.User) {
-	s.publishPost(events.PostCreated{PostEvent: s.postEvent(post, root, author)}, root)
+func (s *Server) publishPostCreated(post, root *store.Post, author *store.User, media []events.Media, cleanup func()) {
+	release := events.Once(func() {
+		closeHeldMedia(media)
+		if cleanup != nil {
+			cleanup()
+		}
+	})
+	if root != nil && root.PostState == store.PostStateHidden {
+		release()
+		return
+	}
+	ev := events.PostCreated{PostEvent: s.postEvent(post, root, author)}
+	if s.cfg.HoldUploadUntilDiscord && len(media) > 0 {
+		ev.Media = media
+		ev.Release = release
+		s.cfg.Events.Publish(context.Background(), ev)
+		return
+	}
+	release()
+	s.cfg.Events.Publish(context.Background(), events.PostCreated{PostEvent: ev.PostEvent})
 }
 
 func (s *Server) publishPostUpdated(post, root *store.Post, author *store.User) {
@@ -55,12 +73,10 @@ func (s *Server) postEvent(post, root *store.Post, author *store.User) events.Po
 	if n := len(post.Images); n > 0 {
 		ev.Images = make([]events.Image, 0, n)
 		for _, img := range post.Images {
-			if img.Kind == store.MediaKindVideo {
-				continue
-			}
 			ev.Images = append(ev.Images, events.Image{
 				URL:         img.PublicURL,
 				Description: img.Description,
+				Kind:        img.Kind,
 			})
 		}
 	}

internal/web/events_test.go

@@ -1,8 +1,10 @@
 package web
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
+	"io"
 	"net/http"
 	"net/url"
 	"strings"
@@ -237,20 +239,72 @@ func assertPostEvent(t *testing.T, got, want events.PostEvent) {
 	}
 }
 
-func TestPostEventOmitsVideos(t *testing.T) {
+func TestPostEventIncludesPhotosAndVideos(t *testing.T) {
 	t.Parallel()
 
 	srv, _ := newTestServer(t, Config{})
 	got := srv.postEvent(&store.Post{
-		ID:     "root-1",
-		Title:  "Clip",
-		Body:   "Photo and video.",
+		ID:    "root-1",
+		Title: "Clip",
+		Body:  "Photo and video.",
 		Images: []store.PostImage{
 			{PublicURL: "https://cdn.example/a.jpg", Description: "Still", Kind: store.MediaKindImage},
 			{PublicURL: "https://cdn.example/a.mp4", Description: "Walkthrough", Kind: store.MediaKindVideo},
 		},
 	}, nil, nil)
-	if len(got.Images) != 1 || got.Images[0].URL != "https://cdn.example/a.jpg" {
+	if len(got.Images) != 2 ||
+		got.Images[0].URL != "https://cdn.example/a.jpg" || got.Images[0].Kind != store.MediaKindImage ||
+		got.Images[1].URL != "https://cdn.example/a.mp4" || got.Images[1].Kind != store.MediaKindVideo {
 		t.Fatalf("event images = %+v", got.Images)
 	}
 }
+
+func TestCreatePostHoldsVideoUntilRelease(t *testing.T) {
+	t.Parallel()
+
+	rec := &events.Recording{}
+	blobs := &recordingImageBlob{}
+	srv, mem := newTestServer(t, Config{
+		Events:                 rec,
+		Blob:                   blobs,
+		HoldUploadUntilDiscord: true,
+	})
+	handler := srv.Handler()
+	user := seedUser(t, mem, uniq("hold-video"), "hunter22", store.RoleUser)
+	cookies := loginUser(t, handler, user.Username, "hunter22")
+	csrf := csrfForCookies(t, handler, cookies)
+	clip := tinyMP4()
+
+	res := multipartPost(t, handler, "/submit", map[string][]string{
+		"_csrf": {csrf},
+		"title": {"Valve clip"},
+		"body":  {"Watch the handle."},
+		"city":  {"Oakland"},
+	}, []multipartTestFile{{name: "walk.mp4", body: clip}}, cookies)
+	if res.Code != http.StatusSeeOther {
+		t.Fatalf("submit status = %d: %s", res.Code, res.Body.String())
+	}
+
+	got := rec.Snapshot()
+	if len(got) != 1 {
+		t.Fatalf("published %d events, want 1: %#v", len(got), got)
+	}
+	created, ok := got[0].(events.PostCreated)
+	if !ok {
+		t.Fatalf("event %T, want PostCreated", got[0])
+	}
+	if len(created.Media) != 1 ||
+		created.Media[0].Kind != store.MediaKindVideo ||
+		created.Media[0].ContentType != "video/mp4" ||
+		created.Media[0].Body == nil {
+		t.Fatalf("held media = %+v", created.Media)
+	}
+	if created.Release == nil {
+		t.Fatal("missing Release")
+	}
+	body, err := io.ReadAll(created.Media[0].Body)
+	if err != nil || !bytes.Equal(body, clip) {
+		t.Fatalf("held video body = %d bytes err=%v", len(body), err)
+	}
+	created.Release()
+}

internal/web/post_images.go

@@ -22,6 +22,7 @@ import (
 	_ "golang.org/x/image/webp"
 
 	"plumber/internal/blob"
+	"plumber/internal/events"
 	"plumber/internal/store"
 )
 
@@ -109,18 +110,18 @@ func (s *Server) postImagesFromForm(
 	r *http.Request,
 	postID string,
 	existing []store.PostImage,
-) ([]store.PostImage, []string, error) {
+) ([]store.PostImage, []string, []events.Media, error) {
 	if r.MultipartForm == nil {
-		return append([]store.PostImage(nil), existing...), nil, nil
+		return append([]store.PostImage(nil), existing...), nil, nil, nil
 	}
 	retained, err := retainedPostImages(r.MultipartForm, existing)
 	if err != nil {
-		return nil, nil, err
+		return nil, 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)
+		return nil, nil, nil, invalidPostImage("Image descriptions do not match selected images.", nil)
 	}
 	kinds := make([]string, len(files))
 	newImages, newVideos := 0, 0
@@ -134,13 +135,13 @@ func (s *Server) postImagesFromForm(
 	}
 	retainedImages, retainedVideos := countPostMedia(retained)
 	if retainedImages+newImages > store.MaxPostImages {
-		return nil, nil, invalidPostImage("You can attach up to 4 images.", nil)
+		return nil, nil, nil, invalidPostImage("You can attach up to 4 images.", nil)
 	}
 	if retainedVideos+newVideos > store.MaxPostVideos {
-		return nil, nil, invalidPostImage("You can attach one video.", nil)
+		return nil, nil, nil, invalidPostImage("You can attach one video.", nil)
 	}
 	if len(files) > 0 && !s.cfg.Blob.Enabled() {
-		return nil, nil, &postImageRequestError{
+		return nil, nil, nil, &postImageRequestError{
 			status:  http.StatusServiceUnavailable,
 			message: "Image uploads are not configured on this server.",
 		}
@@ -148,24 +149,28 @@ func (s *Server) postImagesFromForm(
 
 	images := append([]store.PostImage(nil), retained...)
 	newKeys := make([]string, 0, len(files))
+	held := make([]events.Media, 0, len(files))
 	for i, header := range files {
 		description := ""
 		if i < len(descriptions) {
 			description = strings.TrimSpace(descriptions[i])
 		}
 		if len([]rune(description)) > store.MaxImageDescriptionRunes {
+			closeHeldMedia(held)
 			s.deletePostImageObjects(newKeys)
-			return nil, nil, invalidPostImage("Image descriptions must be 500 characters or fewer.", nil)
+			return nil, nil, nil, invalidPostImage("Image descriptions must be 500 characters or fewer.", nil)
 		}
-		item, objectKey, err := s.uploadPostMedia(ctx, postID, header, kinds[i], description)
+		item, objectKey, media, err := s.uploadPostMedia(ctx, postID, header, kinds[i], description)
 		if err != nil {
+			closeHeldMedia(held)
 			s.deletePostImageObjects(newKeys)
-			return nil, nil, err
+			return nil, nil, nil, err
 		}
 		newKeys = append(newKeys, objectKey)
 		images = append(images, item)
+		held = append(held, media)
 	}
-	return images, newKeys, nil
+	return images, newKeys, held, nil
 }
 
 func countPostMedia(items []store.PostImage) (images, videos int) {
@@ -179,18 +184,26 @@ func countPostMedia(items []store.PostImage) (images, videos int) {
 	return images, videos
 }
 
+func closeHeldMedia(media []events.Media) {
+	for i := range media {
+		if media[i].Body != nil {
+			_ = media[i].Body.Close()
+			media[i].Body = nil
+		}
+	}
+}
+
 func (s *Server) uploadPostMedia(
 	ctx context.Context,
 	postID string,
 	header *multipart.FileHeader,
 	kind, description string,
-) (store.PostImage, string, error) {
+) (store.PostImage, string, events.Media, error) {
 	if kind == store.MediaKindVideo {
 		prepared, err := preparePostVideo(header)
 		if err != nil {
-			return store.PostImage{}, "", err
+			return store.PostImage{}, "", events.Media{}, err
 		}
-		defer prepared.body.Close()
 		mediaID := uuid.NewString()
 		objectKey := path.Join("post-videos", postID, mediaID+prepared.extension)
 		publicURL, err := s.cfg.Blob.Upload(ctx, blob.FileUpload{
@@ -200,12 +213,28 @@ func (s *Server) uploadPostMedia(
 			Size:        prepared.size,
 		})
 		if err != nil {
-			return store.PostImage{}, "", &postImageRequestError{
+			_ = prepared.body.Close()
+			return store.PostImage{}, "", events.Media{}, &postImageRequestError{
 				status:  http.StatusServiceUnavailable,
 				message: "Could not upload video. Try again later.",
 				cause:   err,
 			}
 		}
+		media := events.Media{
+			Name:        mediaID + prepared.extension,
+			ContentType: prepared.contentType,
+			Kind:        store.MediaKindVideo,
+			Size:        prepared.size,
+		}
+		if seeker, ok := prepared.body.(io.Seeker); ok {
+			if _, err := seeker.Seek(0, io.SeekStart); err == nil {
+				media.Body = prepared.body
+			} else {
+				_ = prepared.body.Close()
+			}
+		} else {
+			_ = prepared.body.Close()
+		}
 		return store.PostImage{
 			ID:          mediaID,
 			PostID:      postID,
@@ -213,11 +242,11 @@ func (s *Server) uploadPostMedia(
 			PublicURL:   publicURL,
 			Description: description,
 			Kind:        store.MediaKindVideo,
-		}, objectKey, nil
+		}, objectKey, media, nil
 	}
 	prepared, err := preparePostImage(header)
 	if err != nil {
-		return store.PostImage{}, "", err
+		return store.PostImage{}, "", events.Media{}, err
 	}
 	imageID := uuid.NewString()
 	objectKey := path.Join("post-images", postID, imageID+prepared.extension)
@@ -228,22 +257,28 @@ func (s *Server) uploadPostMedia(
 		Size:        int64(len(prepared.body)),
 	})
 	if err != nil {
-		return store.PostImage{}, "", &postImageRequestError{
+		return store.PostImage{}, "", events.Media{}, &postImageRequestError{
 			status:  http.StatusServiceUnavailable,
 			message: "Could not upload image. Try again later.",
 			cause:   err,
 		}
 	}
 	return store.PostImage{
-		ID:          imageID,
-		PostID:      postID,
-		ObjectKey:   objectKey,
-		PublicURL:   publicURL,
-		Description: description,
-		Kind:        store.MediaKindImage,
-		Width:       prepared.width,
-		Height:      prepared.height,
-	}, objectKey, nil
+			ID:          imageID,
+			PostID:      postID,
+			ObjectKey:   objectKey,
+			PublicURL:   publicURL,
+			Description: description,
+			Kind:        store.MediaKindImage,
+			Width:       prepared.width,
+			Height:      prepared.height,
+		}, objectKey, events.Media{
+			Name:        imageID + prepared.extension,
+			ContentType: prepared.contentType,
+			Kind:        store.MediaKindImage,
+			Size:        int64(len(prepared.body)),
+			Bytes:       prepared.body,
+		}, nil
 }
 
 func retainedPostImages(form *multipart.Form, existing []store.PostImage) ([]store.PostImage, error) {

internal/web/post_images_test.go

@@ -295,6 +295,19 @@ func TestPostVideoMultipartLifecycle(t *testing.T) {
 		t.Fatalf("streamed video upload = %+v", streamed)
 	}
 
+	rec = httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/questions/"+root.ID, nil)
+	for _, cookie := range cookies {
+		req.AddCookie(cookie)
+	}
+	handler.ServeHTTP(rec, req)
+	page := rec.Body.String()
+	if rec.Code != http.StatusOK ||
+		!strings.Contains(page, `<video src="`+root.Images[1].PublicURL) ||
+		!strings.Contains(page, `data-existing-video`) {
+		t.Fatalf("question page missing video player: %d %s", rec.Code, page)
+	}
+
 	rec = multipartPost(t, handler, "/posts/"+root.ID+"/edit", map[string][]string{
 		"_csrf":                      {csrf},
 		"body":                       {"Keep the clip."},

internal/web/posts.go

@@ -12,6 +12,7 @@ import (
 	"github.com/go-chi/chi/v5"
 	"github.com/google/uuid"
 
+	"plumber/internal/events"
 	"plumber/internal/store"
 )
 
@@ -22,7 +23,14 @@ func (s *Server) handleCreatePost(w http.ResponseWriter, r *http.Request) {
 	if !ok {
 		return
 	}
-	defer cleanup()
+	var media []events.Media
+	held := false
+	defer func() {
+		if !held {
+			closeHeldMedia(media)
+			cleanup()
+		}
+	}()
 	if !s.requireCSRF(w, r) {
 		return
 	}
@@ -75,7 +83,7 @@ func (s *Server) handleCreatePost(w http.ResponseWriter, r *http.Request) {
 		root = threadRoot
 	}
 
-	images, newKeys, err := s.postImagesFromForm(r.Context(), r, post.ID, nil)
+	images, newKeys, media, err := s.postImagesFromForm(r.Context(), r, post.ID, nil)
 	if err != nil {
 		writePostImageRequestError(w, err)
 		return
@@ -93,7 +101,8 @@ func (s *Server) handleCreatePost(w http.ResponseWriter, r *http.Request) {
 	if root == nil {
 		root = post
 	}
-	s.publishPostCreated(post, root, user)
+	s.publishPostCreated(post, root, user, media, cleanup)
+	held = true
 	http.Redirect(
 		w,
 		r,
@@ -139,11 +148,12 @@ func (s *Server) handleEditPost(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	previousImages := append([]store.PostImage(nil), post.Images...)
-	images, newKeys, err := s.postImagesFromForm(r.Context(), r, post.ID, previousImages)
+	images, newKeys, media, err := s.postImagesFromForm(r.Context(), r, post.ID, previousImages)
 	if err != nil {
 		writePostImageRequestError(w, err)
 		return
 	}
+	closeHeldMedia(media)
 	post.Body = truncateRunes(body, 12000)
 	post.Images = images
 	if err := s.store.UpdatePost(r.Context(), post); err != nil {

internal/web/posts_test.go

@@ -484,16 +484,19 @@ func TestQuestionPageRendersNestedPostControls(t *testing.T) {
 		`data-submit-button`,
 		`enctype="multipart/form-data"`,
 		`data-image-picker`,
-		`accept="image/jpeg,image/png,image/webp"`,
+		`accept="image/jpeg,image/png,image/webp,video/mp4,video/webm,.mp4,.webm"`,
 		`aria-live="polite"`,
 		`name="existing_image_id" value="root-photo"`,
 		`name="existing_image_id" value="reply-photo"`,
+		`data-image-zoom`,
+		`href="https://cdn.example/root-photo.jpg"`,
 		`src="https://cdn.example/root-photo.jpg"`,
 		`alt="Water pooling below the shutoff valve"`,
 		`src="https://cdn.example/reply-photo.png"`,
 		`alt="Photo attached to this post"`,
 		`src="https://cdn.example/admin-photo.webp"`,
 		`loading="lazy" decoding="async"`,
+		`data-image-zoom-dialog`,
 		`<figcaption>Replacement cartridge orientation</figcaption>`,
 		`action="/posts/` + root.ID + `/edit"`,
 		`action="/posts/` + homeownerReply.ID + `/edit"`,
@@ -556,6 +559,9 @@ func TestImagePickerAssetsAreServed(t *testing.T) {
 			path: "/static/app.js",
 			wants: []string{
 				`const pickerSelector = "[data-image-picker]"`,
+				`video/mp4`,
+				`video/webm`,
+				`showModal`,
 				`new DataTransfer()`,
 				`addEventListener("drop"`,
 				`resetImagePicker`,
@@ -569,6 +575,8 @@ func TestImagePickerAssetsAreServed(t *testing.T) {
 				`.image-dropzone:focus-within`,
 				`.image-preview-list`,
 				`.post-image-grid`,
+				`.post-video`,
+				`.image-zoom`,
 				`@media (max-width: 520px)`,
 			},
 		},

internal/web/server.go

@@ -37,6 +37,8 @@ type Config struct {
 	Blob           blob.Uploader
 	Events         events.Publisher
 	BaseURL        string
+	// HoldUploadUntilDiscord keeps create-post temp files until PostedToDiscord.
+	HoldUploadUntilDiscord bool
 }
 
 type Server struct {
@@ -107,7 +109,27 @@ type threadPostCtx struct {
 
 type imagePickerCtx struct {
 	ID     string
-	Images []store.PostImage
+	Video  *store.PostImage
+	Photos []store.PostImage
+}
+
+func splitPickerMedia(images []store.PostImage) (*store.PostImage, []store.PostImage) {
+	photos := make([]store.PostImage, 0, len(images))
+	var video *store.PostImage
+	for i := range images {
+		if images[i].Kind == store.MediaKindVideo {
+			img := images[i]
+			video = &img
+			continue
+		}
+		photos = append(photos, images[i])
+	}
+	return video, photos
+}
+
+func postPhotos(images []store.PostImage) []store.PostImage {
+	_, photos := splitPickerMedia(images)
+	return photos
 }
 
 func New(st store.Store, sessionStore scs.Store, templateFS fs.FS, staticFS fs.FS, cfg Config) (*Server, error) {
@@ -125,11 +147,13 @@ func New(st store.Store, sessionStore scs.Store, templateFS fs.FS, staticFS fs.F
 			return threadPostCtx{User: user, CSRF: csrf, Root: root, Post: post, Depth: depth}
 		},
 		"imagePicker": func(id string, images []store.PostImage) imagePickerCtx {
-			return imagePickerCtx{ID: id, Images: images}
+			video, photos := splitPickerMedia(images)
+			return imagePickerCtx{ID: id, Video: video, Photos: photos}
 		},
 		"newImagePicker": func(id string) imagePickerCtx {
 			return imagePickerCtx{ID: id}
 		},
+		"postPhotos":  postPhotos,
 		"add":         func(a, b int) int { return a + b },
 		"rank":        func(i int) int { return i + 1 },
 		"isAdmin":     func(u *store.User) bool { return u.Admin() },
@@ -348,7 +372,14 @@ func (s *Server) handleSubmit(w http.ResponseWriter, r *http.Request) {
 	if !ok {
 		return
 	}
-	defer cleanup()
+	var media []events.Media
+	held := false
+	defer func() {
+		if !held {
+			closeHeldMedia(media)
+			cleanup()
+		}
+	}()
 	if !s.requireCSRF(w, r) {
 		return
 	}
@@ -386,7 +417,7 @@ func (s *Server) handleSubmit(w http.ResponseWriter, r *http.Request) {
 		Body:     body,
 		City:     city,
 	}
-	images, newKeys, err := s.postImagesFromForm(r.Context(), r, post.ID, nil)
+	images, newKeys, media, err := s.postImagesFromForm(r.Context(), r, post.ID, nil)
 	if err != nil {
 		writePostImageRequestError(w, err)
 		return
@@ -397,7 +428,8 @@ func (s *Server) handleSubmit(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "could not save question", http.StatusInternalServerError)
 		return
 	}
-	s.publishPostCreated(post, post, u)
+	s.publishPostCreated(post, post, u, media, cleanup)
+	held = true
 	http.Redirect(w, r, "/questions/"+url.PathEscape(post.ID), http.StatusSeeOther)
 }
 

internal/web/server_test.go

@@ -176,8 +176,10 @@ func TestRegisterLoginAsk(t *testing.T) {
 		`enctype="multipart/form-data"`,
 		`data-image-picker`,
 		`id="submit-images"`,
-		`accept="image/jpeg,image/png,image/webp"`,
-		`Add up to 4 JPEG, PNG, or WebP images.`,
+		`accept="image/jpeg,image/png,image/webp,video/mp4,video/webm,.mp4,.webm"`,
+		`Add up to 4 JPEG, PNG, or WebP images (5 MB each) and one MP4 or WebM video (25 MB).`,
+		`Drop photos or a video here`,
+		`data-video-slot`,
 	} {
 		if !strings.Contains(rec.Body.String(), want) {
 			t.Fatalf("submit form missing %q: %s", want, rec.Body.String())