Embed comments in document record; rewrite CommentCreate/CommentList

Co-Authored-By: Claude Sonnet 4.6 <[e-mail]>

internal/atproto/xrpc/client.go

···
 	return c.PutRecord(collectionDocument, rkey, doc)
 }
 
-const collectionComment = "com.diffdown.comment"
-
-// CreateComment creates a new comment record.
-func (c *Client) CreateComment(comment *model.Comment) (string, error) {
-	record := map[string]interface{}{
-		"$type":       "com.diffdown.comment",
-		"documentURI": comment.DocumentURI,
-		"paragraphId": comment.ParagraphID,
-		"text":        comment.Text,
-		"author":      comment.Author,
-	}
-	uri, _, err := c.CreateRecord(collectionComment, record)
-	if err != nil {
-		return "", err
-	}
-	return uri, nil
-}
-
-// ListComments fetches all comments for a document.
-func (c *Client) ListComments(documentRKey string) ([]model.Comment, error) {
-	records, _, err := c.ListRecords(c.session.DID, collectionComment, 100, "")
-	if err != nil {
-		return nil, err
-	}
-
-	var comments []model.Comment
-	for _, r := range records {
-		var comment model.Comment
-		if err := json.Unmarshal(r.Value, &comment); err != nil {
-			continue
-		}
-		// Filter by documentRKey: at://{did}/com.diffdown.document/{rkey}
-		expectedSuffix := "/com.diffdown.document/" + documentRKey
-		if documentRKey != "" && !strings.HasSuffix(comment.DocumentURI, expectedSuffix) {
-			continue
-		}
-		comment.URI = r.URI
-		comments = append(comments, comment)
-	}
-	return comments, nil
-}

internal/handler/handler.go

···
 package handler
 
 import (
+	"crypto/rand"
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"html/template"
···
 )
 
 const collectionDocument = "com.diffdown.document"
-const collectionComment = "com.diffdown.comment"
+
+func randomID() string {
+	b := make([]byte, 4)
+	rand.Read(b)
+	return hex.EncodeToString(b)
+}
 
 type Handler struct {
 	DB               *db.DB
···
 	}
 
 	var req struct {
+		OwnerDID    string `json:"ownerDID"`
 		ParagraphID string `json:"paragraphId"`
 		Text        string `json:"text"`
 	}
···
 		http.Error(w, "Invalid request", http.StatusBadRequest)
 		return
 	}
-
 	if req.Text == "" {
 		http.Error(w, "Comment text required", http.StatusBadRequest)
 		return
···
 		return
 	}
 
-	client, err := h.xrpcClient(user.ID)
+	ownerUserID := user.ID
+	ownerDID := session.DID
+	if req.OwnerDID != "" && req.OwnerDID != session.DID {
+		ownerUser, err := h.DB.GetUserByDID(req.OwnerDID)
+		if err != nil {
+			http.Error(w, "Owner not found", http.StatusBadRequest)
+			return
+		}
+		ownerUserID = ownerUser.ID
+		ownerDID = req.OwnerDID
+	}
+
+	ownerClient, err := h.xrpcClient(ownerUserID)
+	if err != nil {
+		http.Error(w, "Failed to connect to owner PDS", http.StatusInternalServerError)
+		return
+	}
+
+	value, _, err := ownerClient.GetRecord(ownerDID, collectionDocument, rKey)
 	if err != nil {
-		http.Error(w, "Failed to connect to ATProto", http.StatusInternalServerError)
+		log.Printf("CommentCreate: GetRecord: %v", err)
+		http.Error(w, "Document not found", http.StatusNotFound)
+		return
+	}
+	var doc model.Document
+	if err := json.Unmarshal(value, &doc); err != nil {
+		http.Error(w, "Failed to parse document", http.StatusInternalServerError)
 		return
 	}
 
-	comment := &model.Comment{
-		DocumentURI: fmt.Sprintf("at://%s/com.diffdown.document/%s", session.DID, rKey),
-		ParagraphID: req.ParagraphID,
-		Text:        req.Text,
-		Author:      session.DID,
+	authorHandle, _ := atproto.ResolveHandleFromDID(session.DID)
+
+	paragraphID := req.ParagraphID
+	if paragraphID == "" {
+		paragraphID = "general"
 	}
 
-	uri, err := client.CreateComment(comment)
-	if err != nil {
-		log.Printf("CommentCreate: %v", err)
-		http.Error(w, "Failed to create comment", http.StatusInternalServerError)
+	comment := model.EmbeddedComment{
+		ID:           randomID(),
+		ParagraphID:  paragraphID,
+		Text:         req.Text,
+		Author:       session.DID,
+		AuthorHandle: authorHandle,
+		CreatedAt:    time.Now().UTC().Format(time.RFC3339),
+	}
+	doc.Comments = append(doc.Comments, comment)
+
+	if _, _, err := ownerClient.PutDocument(rKey, &doc); err != nil {
+		log.Printf("CommentCreate: PutDocument: %v", err)
+		http.Error(w, "Failed to save comment", http.StatusInternalServerError)
 		return
 	}
 
-	h.jsonResponse(w, map[string]string{"uri": uri}, http.StatusCreated)
+	h.jsonResponse(w, comment, http.StatusCreated)
 }
 
 func (h *Handler) CommentList(w http.ResponseWriter, r *http.Request) {
···
 		return
 	}
 
-	client, err := h.xrpcClient(user.ID)
+	ownerUserID := user.ID
+	ownerDID := session.DID
+	if qOwner := r.URL.Query().Get("ownerDID"); qOwner != "" && qOwner != session.DID {
+		ownerUser, err := h.DB.GetUserByDID(qOwner)
+		if err != nil {
+			http.Error(w, "Owner not found", http.StatusBadRequest)
+			return
+		}
+		ownerUserID = ownerUser.ID
+		ownerDID = qOwner
+	}
+
+	ownerClient, err := h.xrpcClient(ownerUserID)
 	if err != nil {
-		http.Error(w, "Failed to connect to ATProto", http.StatusInternalServerError)
+		http.Error(w, "Failed to connect to owner PDS", http.StatusInternalServerError)
 		return
 	}
 
-	comments, err := client.ListComments(rKey)
+	value, _, err := ownerClient.GetRecord(ownerDID, collectionDocument, rKey)
 	if err != nil {
-		log.Printf("CommentList: %v", err)
-		http.Error(w, "Failed to list comments", http.StatusInternalServerError)
+		log.Printf("CommentList: GetRecord: %v", err)
+		http.Error(w, "Document not found", http.StatusNotFound)
+		return
+	}
+	var doc model.Document
+	if err := json.Unmarshal(value, &doc); err != nil {
+		http.Error(w, "Failed to parse document", http.StatusInternalServerError)
 		return
 	}
 
+	comments := doc.Comments
+	if comments == nil {
+		comments = []model.EmbeddedComment{}
+	}
 	h.jsonResponse(w, comments, http.StatusOK)
 }
 

internal/model/models.go

···
 	ExpiresAt    time.Time `json:"expires_at"`
 }
 
-type Comment struct {
-	URI         string    `json:"uri"`
-	DocumentURI string    `json:"documentURI"`
-	ParagraphID string    `json:"paragraphId"`
-	Text        string    `json:"text"`
-	Author      string    `json:"author"`
-	AuthorName  string    `json:"authorName"`
-	CreatedAt   time.Time `json:"createdAt"`
-}
-
 // RKeyFromURI extracts the rkey (last path segment) from an at:// URI.
 func RKeyFromURI(uri string) string {
 	parts := strings.Split(uri, "/")