create-svc 0.1.8 → 0.1.10

package/templates/variants/go-connectrpc/internal/config/config.go

@@ -1,17 +1,32 @@
 package config
 
-import "os"
+import (
+	"errors"
+	"os"
+	"strings"
+)
 
 type Config struct {
-	Port        string
-	DatabaseURL string
+	Port                    string
+	DatabaseURL             string
+	AttachmentBucket        string
+	AttachmentPublicBaseURL string
 }
 
 func Load() (Config, error) {
-	return Config{
-		Port:        envOr("PORT", "8080"),
-		DatabaseURL: envOr("DATABASE_URL", ""),
-	}, nil
+	cfg := Config{
+		Port:                    envOr("PORT", "8080"),
+		DatabaseURL:             strings.TrimSpace(os.Getenv("DATABASE_URL")),
+		AttachmentBucket:        strings.TrimSpace(os.Getenv("ATTACHMENT_BUCKET")),
+		AttachmentPublicBaseURL: strings.TrimSpace(os.Getenv("ATTACHMENT_PUBLIC_BASE_URL")),
+	}
+	if cfg.DatabaseURL == "" {
+		return Config{}, errors.New("DATABASE_URL is required")
+	}
+	if cfg.AttachmentBucket == "" {
+		return Config{}, errors.New("ATTACHMENT_BUCKET is required")
+	}
+	return cfg, nil
 }
 
 func envOr(key string, fallback string) string {

package/templates/variants/go-connectrpc/internal/connectapi/handler.go

@@ -6,74 +6,286 @@ import (
 
 	"connectrpc.com/connect"
 
-	dnsv1 "{{MODULE_PATH}}/gen/dns/v1"
-	dnsv1connect "{{MODULE_PATH}}/gen/dns/v1/dnsv1connect"
+	chatv1 "{{MODULE_PATH}}/gen/chat/v1"
+	chatv1connect "{{MODULE_PATH}}/gen/chat/v1/chatv1connect"
 	"{{MODULE_PATH}}/internal/app"
 )
 
 type Handler struct {
-	service *app.DNSService
+	service *app.ChatService
 }
 
-func NewHandler(service *app.DNSService) (string, http.Handler) {
-	return dnsv1connect.NewDNSServiceHandler(&Handler{service: service})
+func NewHandler(service *app.ChatService) (string, http.Handler) {
+	return chatv1connect.NewChatServiceHandler(&Handler{service: service})
 }
 
-func (h *Handler) ListRecords(ctx context.Context, _ *connect.Request[dnsv1.ListRecordsRequest]) (*connect.Response[dnsv1.ListRecordsResponse], error) {
-	records, err := h.service.ListRecords(ctx)
+func (h *Handler) CreateUser(ctx context.Context, request *connect.Request[chatv1.CreateUserRequest]) (*connect.Response[chatv1.CreateUserResponse], error) {
+	user, err := h.service.CreateUser(ctx, app.CreateUserInput{
+		Username:    request.Msg.GetUsername(),
+		DisplayName: request.Msg.GetDisplayName(),
+	})
+	if err != nil {
+		return nil, toConnectError(err)
+	}
+	return connect.NewResponse(&chatv1.CreateUserResponse{User: toProtoUser(user)}), nil
+}
+
+func (h *Handler) GetUser(ctx context.Context, request *connect.Request[chatv1.GetUserRequest]) (*connect.Response[chatv1.GetUserResponse], error) {
+	user, err := h.service.GetUser(ctx, request.Msg.GetUserId())
+	if err != nil {
+		return nil, toConnectError(err)
+	}
+	return connect.NewResponse(&chatv1.GetUserResponse{User: toProtoUser(user)}), nil
+}
+
+func (h *Handler) GetUserByUsername(ctx context.Context, request *connect.Request[chatv1.GetUserByUsernameRequest]) (*connect.Response[chatv1.GetUserByUsernameResponse], error) {
+	user, err := h.service.GetUserByUsername(ctx, request.Msg.GetUsername())
+	if err != nil {
+		return nil, toConnectError(err)
+	}
+	return connect.NewResponse(&chatv1.GetUserByUsernameResponse{User: toProtoUser(user)}), nil
+}
+
+func (h *Handler) CreateConversation(ctx context.Context, request *connect.Request[chatv1.CreateConversationRequest]) (*connect.Response[chatv1.CreateConversationResponse], error) {
+	conversation, err := h.service.CreateConversation(ctx, app.CreateConversationInput{
+		CreatedByUserID:    request.Msg.GetCreatedByUserId(),
+		Title:              request.Msg.GetTitle(),
+		ParticipantUserIDs: request.Msg.GetParticipantUserIds(),
+	})
+	if err != nil {
+		return nil, toConnectError(err)
+	}
+	return connect.NewResponse(&chatv1.CreateConversationResponse{Conversation: toProtoConversation(conversation)}), nil
+}
+
+func (h *Handler) GetConversation(ctx context.Context, request *connect.Request[chatv1.GetConversationRequest]) (*connect.Response[chatv1.GetConversationResponse], error) {
+	conversation, err := h.service.GetConversation(ctx, request.Msg.GetConversationId())
+	if err != nil {
+		return nil, toConnectError(err)
+	}
+	return connect.NewResponse(&chatv1.GetConversationResponse{Conversation: toProtoConversation(conversation)}), nil
+}
+
+func (h *Handler) UpdateConversation(ctx context.Context, request *connect.Request[chatv1.UpdateConversationRequest]) (*connect.Response[chatv1.UpdateConversationResponse], error) {
+	conversation, err := h.service.UpdateConversation(ctx, request.Msg.GetConversationId(), app.UpdateConversationInput{
+		Title: request.Msg.GetTitle(),
+	})
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, toConnectError(err)
+	}
+	return connect.NewResponse(&chatv1.UpdateConversationResponse{Conversation: toProtoConversation(conversation)}), nil
+}
+
+func (h *Handler) DeleteConversation(ctx context.Context, request *connect.Request[chatv1.DeleteConversationRequest]) (*connect.Response[chatv1.DeleteConversationResponse], error) {
+	if err := h.service.DeleteConversation(ctx, request.Msg.GetConversationId()); err != nil {
+		return nil, toConnectError(err)
 	}
+	return connect.NewResponse(&chatv1.DeleteConversationResponse{}), nil
+}
 
-	response := &dnsv1.ListRecordsResponse{Records: make([]*dnsv1.Record, 0, len(records))}
-	for _, record := range records {
-		response.Records = append(response.Records, toProtoRecord(record))
+func (h *Handler) AddConversationParticipant(ctx context.Context, request *connect.Request[chatv1.AddConversationParticipantRequest]) (*connect.Response[chatv1.AddConversationParticipantResponse], error) {
+	conversation, err := h.service.AddParticipant(ctx, request.Msg.GetConversationId(), request.Msg.GetUserId())
+	if err != nil {
+		return nil, toConnectError(err)
 	}
-	return connect.NewResponse(response), nil
+	return connect.NewResponse(&chatv1.AddConversationParticipantResponse{Conversation: toProtoConversation(conversation)}), nil
 }
 
-func (h *Handler) CreateRecord(ctx context.Context, request *connect.Request[dnsv1.CreateRecordRequest]) (*connect.Response[dnsv1.CreateRecordResponse], error) {
-	record, err := h.service.CreateRecord(ctx, app.CreateRecordInput{
-		Type:    request.Msg.GetType(),
-		Name:    request.Msg.GetName(),
-		Content: request.Msg.GetContent(),
-		TTL:     int(request.Msg.GetTtl()),
-		Proxied: request.Msg.GetProxied(),
+func (h *Handler) RemoveConversationParticipant(ctx context.Context, request *connect.Request[chatv1.RemoveConversationParticipantRequest]) (*connect.Response[chatv1.RemoveConversationParticipantResponse], error) {
+	if err := h.service.RemoveParticipant(ctx, request.Msg.GetConversationId(), request.Msg.GetUserId()); err != nil {
+		return nil, toConnectError(err)
+	}
+	return connect.NewResponse(&chatv1.RemoveConversationParticipantResponse{}), nil
+}
+
+func (h *Handler) ListMessages(ctx context.Context, request *connect.Request[chatv1.ListMessagesRequest]) (*connect.Response[chatv1.ListMessagesResponse], error) {
+	result, err := h.service.ListMessages(ctx, request.Msg.GetConversationId(), app.ListMessagesInput{
+		Cursor: request.Msg.GetCursor(),
+		Limit:  int(request.Msg.GetLimit()),
 	})
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, toConnectError(err)
+	}
+	items := make([]*chatv1.Message, 0, len(result.Messages))
+	for _, message := range result.Messages {
+		items = append(items, toProtoMessage(message))
 	}
-	return connect.NewResponse(&dnsv1.CreateRecordResponse{Record: toProtoRecord(record)}), nil
+	return connect.NewResponse(&chatv1.ListMessagesResponse{
+		Messages:   items,
+		NextCursor: result.NextCursor,
+	}), nil
 }
 
-func (h *Handler) UpdateRecord(ctx context.Context, request *connect.Request[dnsv1.UpdateRecordRequest]) (*connect.Response[dnsv1.UpdateRecordResponse], error) {
-	record, err := h.service.UpdateRecord(ctx, request.Msg.GetId(), app.UpdateRecordInput{
-		Type:    request.Msg.GetType(),
-		Name:    request.Msg.GetName(),
-		Content: request.Msg.GetContent(),
-		TTL:     int(request.Msg.GetTtl()),
-		Proxied: request.Msg.GetProxied(),
+func (h *Handler) CreateMessage(ctx context.Context, request *connect.Request[chatv1.CreateMessageRequest]) (*connect.Response[chatv1.CreateMessageResponse], error) {
+	message, err := h.service.CreateMessage(ctx, request.Msg.GetConversationId(), app.CreateMessageInput{
+		UserID: request.Msg.GetUserId(),
+		Body:   request.Msg.GetBody(),
 	})
 	if err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+		return nil, toConnectError(err)
 	}
-	return connect.NewResponse(&dnsv1.UpdateRecordResponse{Record: toProtoRecord(record)}), nil
+	return connect.NewResponse(&chatv1.CreateMessageResponse{Message: toProtoMessage(message)}), nil
 }
 
-func (h *Handler) DeleteRecord(ctx context.Context, request *connect.Request[dnsv1.DeleteRecordRequest]) (*connect.Response[dnsv1.DeleteRecordResponse], error) {
-	if err := h.service.DeleteRecord(ctx, request.Msg.GetId()); err != nil {
-		return nil, connect.NewError(connect.CodeInternal, err)
+func (h *Handler) UpdateMessage(ctx context.Context, request *connect.Request[chatv1.UpdateMessageRequest]) (*connect.Response[chatv1.UpdateMessageResponse], error) {
+	message, err := h.service.UpdateMessage(ctx, request.Msg.GetConversationId(), request.Msg.GetMessageId(), app.UpdateMessageInput{
+		Body: request.Msg.GetBody(),
+	})
+	if err != nil {
+		return nil, toConnectError(err)
+	}
+	return connect.NewResponse(&chatv1.UpdateMessageResponse{Message: toProtoMessage(message)}), nil
+}
+
+func (h *Handler) DeleteMessage(ctx context.Context, request *connect.Request[chatv1.DeleteMessageRequest]) (*connect.Response[chatv1.DeleteMessageResponse], error) {
+	if err := h.service.DeleteMessage(ctx, request.Msg.GetConversationId(), request.Msg.GetMessageId()); err != nil {
+		return nil, toConnectError(err)
+	}
+	return connect.NewResponse(&chatv1.DeleteMessageResponse{}), nil
+}
+
+func (h *Handler) CreateAttachmentUpload(ctx context.Context, request *connect.Request[chatv1.CreateAttachmentUploadRequest]) (*connect.Response[chatv1.CreateAttachmentUploadResponse], error) {
+	result, err := h.service.CreateAttachmentUpload(ctx, app.CreateAttachmentUploadInput{
+		ConversationID:   request.Msg.GetConversationId(),
+		UploadedByUserID: request.Msg.GetUserId(),
+		Filename:         request.Msg.GetFilename(),
+		ContentType:      request.Msg.GetContentType(),
+		ByteSize:         request.Msg.GetByteSize(),
+	})
+	if err != nil {
+		return nil, toConnectError(err)
+	}
+	return connect.NewResponse(&chatv1.CreateAttachmentUploadResponse{
+		Attachment: toProtoAttachment(result.Attachment),
+		Upload: &chatv1.UploadTarget{
+			Method:  result.Upload.Method,
+			Url:     result.Upload.URL,
+			Headers: result.Upload.Headers,
+		},
+	}), nil
+}
+
+func (h *Handler) FinalizeAttachment(ctx context.Context, request *connect.Request[chatv1.FinalizeAttachmentRequest]) (*connect.Response[chatv1.FinalizeAttachmentResponse], error) {
+	attachment, err := h.service.FinalizeAttachment(ctx, request.Msg.GetAttachmentId(), app.FinalizeAttachmentInput{
+		MessageID: request.Msg.GetMessageId(),
+	})
+	if err != nil {
+		return nil, toConnectError(err)
+	}
+	return connect.NewResponse(&chatv1.FinalizeAttachmentResponse{Attachment: toProtoAttachment(attachment)}), nil
+}
+
+func (h *Handler) GetAttachment(ctx context.Context, request *connect.Request[chatv1.GetAttachmentRequest]) (*connect.Response[chatv1.GetAttachmentResponse], error) {
+	attachment, err := h.service.GetAttachment(ctx, request.Msg.GetAttachmentId())
+	if err != nil {
+		return nil, toConnectError(err)
+	}
+	return connect.NewResponse(&chatv1.GetAttachmentResponse{Attachment: toProtoAttachment(attachment)}), nil
+}
+
+func (h *Handler) DeleteAttachment(ctx context.Context, request *connect.Request[chatv1.DeleteAttachmentRequest]) (*connect.Response[chatv1.DeleteAttachmentResponse], error) {
+	if err := h.service.DeleteAttachment(ctx, request.Msg.GetAttachmentId()); err != nil {
+		return nil, toConnectError(err)
+	}
+	return connect.NewResponse(&chatv1.DeleteAttachmentResponse{}), nil
+}
+
+func toConnectError(err error) error {
+	var appErr *app.AppError
+	if ok := asAppError(err, &appErr); ok {
+		return connect.NewError(statusCodeToConnectCode(appErr.Status), err)
+	}
+	return connect.NewError(connect.CodeInternal, err)
+}
+
+func asAppError(err error, target **app.AppError) bool {
+	if err == nil {
+		return false
+	}
+	appErr, ok := err.(*app.AppError)
+	if ok {
+		*target = appErr
+		return true
+	}
+	return false
+}
+
+func statusCodeToConnectCode(status int) connect.Code {
+	switch status {
+	case 400:
+		return connect.CodeInvalidArgument
+	case 404:
+		return connect.CodeNotFound
+	case 409:
+		return connect.CodeAlreadyExists
+	default:
+		return connect.CodeInternal
+	}
+}
+
+func toProtoUser(user app.User) *chatv1.User {
+	return &chatv1.User{
+		Id:          user.ID,
+		Username:    user.Username,
+		DisplayName: user.DisplayName,
+		CreatedAt:   user.CreatedAt,
+		UpdatedAt:   user.UpdatedAt,
+	}
+}
+
+func toProtoConversation(conversation app.Conversation) *chatv1.Conversation {
+	participants := make([]*chatv1.User, 0, len(conversation.Participants))
+	for _, participant := range conversation.Participants {
+		participants = append(participants, toProtoUser(participant))
+	}
+	return &chatv1.Conversation{
+		Id:              conversation.ID,
+		Title:           conversation.Title,
+		CreatedByUserId: conversation.CreatedByUserID,
+		Participants:    participants,
+		CreatedAt:       conversation.CreatedAt,
+		UpdatedAt:       conversation.UpdatedAt,
+	}
+}
+
+func toProtoMessage(message app.Message) *chatv1.Message {
+	attachments := make([]*chatv1.MessageAttachment, 0, len(message.Attachments))
+	for _, attachment := range message.Attachments {
+		attachments = append(attachments, &chatv1.MessageAttachment{
+			Id:          attachment.ID,
+			Filename:    attachment.Filename,
+			ContentType: attachment.ContentType,
+			ByteSize:    attachment.ByteSize,
+			Status:      attachment.Status,
+			PublicUrl:   attachment.PublicURL,
+		})
+	}
+	return &chatv1.Message{
+		Id:             message.ID,
+		ConversationId: message.ConversationID,
+		UserId:         message.UserID,
+		Body:           message.Body,
+		EditedAt:       message.EditedAt,
+		CreatedAt:      message.CreatedAt,
+		UpdatedAt:      message.UpdatedAt,
+		Attachments:    attachments,
 	}
-	return connect.NewResponse(&dnsv1.DeleteRecordResponse{}), nil
 }
 
-func toProtoRecord(record app.Record) *dnsv1.Record {
-	return &dnsv1.Record{
-		Id:      record.ID,
-		Type:    record.Type,
-		Name:    record.Name,
-		Content: record.Content,
-		Ttl:     int32(record.TTL),
-		Proxied: record.Proxied,
+func toProtoAttachment(attachment app.Attachment) *chatv1.Attachment {
+	return &chatv1.Attachment{
+		Id:               attachment.ID,
+		ConversationId:   attachment.ConversationID,
+		MessageId:        attachment.MessageID,
+		UploadedByUserId: attachment.UploadedByUserID,
+		StorageBucket:    attachment.StorageBucket,
+		StorageKey:       attachment.StorageKey,
+		ContentType:      attachment.ContentType,
+		ByteSize:         attachment.ByteSize,
+		Filename:         attachment.Filename,
+		Status:           attachment.Status,
+		PublicUrl:        attachment.PublicURL,
+		CreatedAt:        attachment.CreatedAt,
+		UpdatedAt:        attachment.UpdatedAt,
 	}
 }

package/templates/variants/go-connectrpc/internal/connectapi/list_messages_integration_test.go

@@ -0,0 +1,216 @@
+package connectapi
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"connectrpc.com/connect"
+	_ "github.com/jackc/pgx/v5/stdlib"
+	"github.com/jmoiron/sqlx"
+
+	chatv1 "{{MODULE_PATH}}/gen/chat/v1"
+	chatv1connect "{{MODULE_PATH}}/gen/chat/v1/chatv1connect"
+	"{{MODULE_PATH}}/internal/app"
+)
+
+func TestListMessagesPaginationIncludesAttachmentMetadata(t *testing.T) {
+	databaseURL := strings.TrimSpace(os.Getenv("DATABASE_URL"))
+	if databaseURL == "" {
+		t.Skip("DATABASE_URL is required for integration test")
+	}
+
+	t.Setenv("ATTACHMENT_PUBLIC_BASE_URL", "https://storage.test")
+
+	db, err := app.OpenDatabase(context.Background(), databaseURL)
+	if err != nil {
+		t.Fatalf("open database: %v", err)
+	}
+	t.Cleanup(func() { _ = db.Close() })
+
+	if _, err := db.ExecContext(context.Background(), `
+truncate table
+  webhook_events,
+  attachments,
+  messages,
+  conversation_participants,
+  conversations,
+  users
+restart identity cascade`); err != nil {
+		t.Fatalf("truncate tables: %v", err)
+	}
+
+	storage := newFakeStorage()
+	service := app.NewChatService(db, storage, app.GenericWebhookAdapter{})
+	path, handler := NewHandler(service)
+	mux := http.NewServeMux()
+	mux.Handle(path, handler)
+	server := httptest.NewServer(mux)
+	t.Cleanup(server.Close)
+
+	client := chatv1connect.NewChatServiceClient(http.DefaultClient, server.URL)
+
+	createUserResponse, err := client.CreateUser(context.Background(), connect.NewRequest(&chatv1.CreateUserRequest{
+		Username:    "alice",
+		DisplayName: "Alice",
+	}))
+	if err != nil {
+		t.Fatalf("create user: %v", err)
+	}
+	userID := createUserResponse.Msg.GetUser().GetId()
+
+	createConversationResponse, err := client.CreateConversation(context.Background(), connect.NewRequest(&chatv1.CreateConversationRequest{
+		CreatedByUserId:    userID,
+		Title:              "General",
+		ParticipantUserIds: []string{userID},
+	}))
+	if err != nil {
+		t.Fatalf("create conversation: %v", err)
+	}
+	conversationID := createConversationResponse.Msg.GetConversation().GetId()
+
+	messageIDs := make([]string, 0, 55)
+	for index := 1; index <= 55; index++ {
+		response, err := client.CreateMessage(context.Background(), connect.NewRequest(&chatv1.CreateMessageRequest{
+			ConversationId: conversationID,
+			UserId:         userID,
+			Body:           fmt.Sprintf("message-%d", index),
+		}))
+		if err != nil {
+			t.Fatalf("create message %d: %v", index, err)
+		}
+		messageIDs = append(messageIDs, response.Msg.GetMessage().GetId())
+	}
+	rewriteMessageTimestamps(t, db, messageIDs)
+
+	uploadResponse, err := client.CreateAttachmentUpload(context.Background(), connect.NewRequest(&chatv1.CreateAttachmentUploadRequest{
+		ConversationId: conversationID,
+		UserId:         userID,
+		Filename:       "photo.png",
+		ContentType:    "image/png",
+		ByteSize:       1234,
+	}))
+	if err != nil {
+		t.Fatalf("create attachment upload: %v", err)
+	}
+	storage.set(uploadResponse.Msg.GetAttachment().GetPublicUrl(), "image/png", 1234)
+	if _, err := client.FinalizeAttachment(context.Background(), connect.NewRequest(&chatv1.FinalizeAttachmentRequest{
+		AttachmentId: uploadResponse.Msg.GetAttachment().GetId(),
+		MessageId:    messageIDs[54],
+	})); err != nil {
+		t.Fatalf("finalize attachment: %v", err)
+	}
+
+	firstPage, err := client.ListMessages(context.Background(), connect.NewRequest(&chatv1.ListMessagesRequest{
+		ConversationId: conversationID,
+	}))
+	if err != nil {
+		t.Fatalf("list messages first page: %v", err)
+	}
+	if len(firstPage.Msg.GetMessages()) != 50 {
+		t.Fatalf("expected 50 messages, got %d", len(firstPage.Msg.GetMessages()))
+	}
+	if firstPage.Msg.GetMessages()[0].GetBody() != "message-55" {
+		t.Fatalf("expected newest message first, got %s", firstPage.Msg.GetMessages()[0].GetBody())
+	}
+	if firstPage.Msg.GetMessages()[49].GetBody() != "message-6" {
+		t.Fatalf("expected oldest message on first page to be message-6, got %s", firstPage.Msg.GetMessages()[49].GetBody())
+	}
+	if firstPage.Msg.GetNextCursor() == "" {
+		t.Fatal("expected next cursor on first page")
+	}
+	attachments := firstPage.Msg.GetMessages()[0].GetAttachments()
+	if len(attachments) != 1 {
+		t.Fatalf("expected attachment metadata on newest message, got %#v", attachments)
+	}
+	if attachments[0].GetPublicUrl() != uploadResponse.Msg.GetAttachment().GetPublicUrl() {
+		t.Fatalf("expected public_url %s, got %s", uploadResponse.Msg.GetAttachment().GetPublicUrl(), attachments[0].GetPublicUrl())
+	}
+
+	secondPage, err := client.ListMessages(context.Background(), connect.NewRequest(&chatv1.ListMessagesRequest{
+		ConversationId: conversationID,
+		Cursor:         firstPage.Msg.GetNextCursor(),
+	}))
+	if err != nil {
+		t.Fatalf("list messages second page: %v", err)
+	}
+	expectedBodies := []string{"message-5", "message-4", "message-3", "message-2", "message-1"}
+	if len(secondPage.Msg.GetMessages()) != len(expectedBodies) {
+		t.Fatalf("expected %d messages on second page, got %d", len(expectedBodies), len(secondPage.Msg.GetMessages()))
+	}
+	for index, body := range expectedBodies {
+		if secondPage.Msg.GetMessages()[index].GetBody() != body {
+			t.Fatalf("expected %s at index %d, got %s", body, index, secondPage.Msg.GetMessages()[index].GetBody())
+		}
+	}
+	if secondPage.Msg.GetNextCursor() != "" {
+		t.Fatalf("expected no next cursor on final page, got %s", secondPage.Msg.GetNextCursor())
+	}
+}
+
+type fakeStorage struct {
+	metadata map[string]struct {
+		contentType string
+		byteSize    int64
+		publicURL   string
+	}
+}
+
+func newFakeStorage() *fakeStorage {
+	return &fakeStorage{metadata: map[string]struct {
+		contentType string
+		byteSize    int64
+		publicURL   string
+	}{}}
+}
+
+func (f *fakeStorage) CreateSignedUpload(_ context.Context, attachmentID string, conversationID string, filename string, contentType string) (string, string, app.UploadTarget, string, error) {
+	key := fmt.Sprintf("attachments/%s/%s/%s", conversationID, attachmentID, filename)
+	return "test-bucket", key, app.UploadTarget{
+		Method: http.MethodPut,
+		URL:    "https://uploads.test/" + key,
+		Headers: map[string]string{
+			"Content-Type": contentType,
+		},
+	}, "https://storage.test/" + key, nil
+}
+
+func (f *fakeStorage) GetObjectMetadata(_ context.Context, bucket string, key string) (string, int64, string, error) {
+	entry, ok := f.metadata[bucket+"/"+key]
+	if !ok {
+		return "", 0, "", fmt.Errorf("missing metadata for %s/%s", bucket, key)
+	}
+	return entry.contentType, entry.byteSize, entry.publicURL, nil
+}
+
+func (f *fakeStorage) set(publicURL string, contentType string, byteSize int64) {
+	key := strings.TrimPrefix(publicURL, "https://storage.test/")
+	f.metadata["test-bucket/"+key] = struct {
+		contentType string
+		byteSize    int64
+		publicURL   string
+	}{
+		contentType: contentType,
+		byteSize:    byteSize,
+		publicURL:   publicURL,
+	}
+}
+
+func rewriteMessageTimestamps(t *testing.T, db *sqlx.DB, messageIDs []string) {
+	t.Helper()
+	baseTime := time.Date(2026, time.January, 1, 0, 0, 0, 0, time.UTC)
+	for index, messageID := range messageIDs {
+		createdAt := baseTime.Add(time.Duration(index+1) * time.Second)
+		if _, err := db.ExecContext(context.Background(), `
+update messages
+set created_at = $2, updated_at = $2
+where id = $1`, messageID, createdAt); err != nil {
+			t.Fatalf("rewrite message timestamp: %v", err)
+		}
+	}
+}