feat(sync): wire annotation sync into all device and web handlers

Complete the annotation sync pipeline across all ingest and serve paths. Previously, annotations sent inline with KOReader progress pushes were silently discarded, and no annotations were ever served back to devices. INGEST (device → server): KOReader (koreader.go): - Add processBookAnnotations helper that processes inline highlights, notes, and bookmarks from every progress push (immediate + checkpoint) - Highlights get CRE→CFI position conversion before SaveHighlight - KOReader 'notes' (text + notes) stored as highlights with NoteText to ensure correct round-trip classification - Bookmarks routed through SaveBookmark with device sync data - Called from both updateProgressForBook and handleCheckpointSync Kobo (kobo.go): - Markup handler: annotations and bookmarks route through AnnotationService (SaveHighlight/SaveBookmark) - Bookmark handler: same routing with device sync data - SyncFromServer handler: same routing - All handlers fall back to direct DB calls when annotationSvc == nil Web reader (media.go): - CreateMediaHighlight → SaveHighlight (Source="web", ModifiedAt=now) - CreateMediaNote → SaveNote (Source="web") - DeleteMediaHighlight → TombstoneHighlightByID - DeleteMediaNote → TombstoneNoteByID (was hard delete, now tombstone) - All fall back to old behavior when annotationSvc == nil SERVE (server → device): KOReader GetMetadata (koreader.go): - Query and serve bookmarks from media_bookmarks table (was missing) - Serve deleted_highlights and deleted_bookmarks arrays containing device_sync_data + dedup_key for client-side deletion - Highlights/notes already served with reverse CFI conversion Kobo Markup handler (kobo.go): - Track processed books during sync - Query tombstones per book, extract bookmark_id from device_sync_data - Return DeletedAnnotations array in KoboSyncStatus response Conflict resolution (conflicts.go): - Enable annotation conflict types in ResolveConflict handler - Add applyAnnotationResolution dispatching to: applyHighlightResolution / applyBookmarkResolution / applyNoteResolution - Each looks up by dedup_key and applies winner's fields - Allow manual override of auto_resolved conflicts (changed check from != "unresolved" to == "user_resolved") Infrastructure: - AnnotationService field + SetAnnotationService in router Config - Inject AnnotationService into KOReader, Kobo, Media handlers - Start tombstone purger goroutine in main.go (24h interval) - Test helpers: construct AnnotationService in test setup
2026-07-29 14:49:19 -04:00
parent 635a9439cb
commit 75b33fdae6
8 changed files with 772 additions and 110 deletions
@@ -225,7 +225,7 @@ func (h *ConflictHandler) ResolveConflict(c *echo.Context) error {
 		return echo.NewHTTPError(http.StatusForbidden, "access denied")
 	}

-	if conflict.ResolutionStatus.String != "unresolved" {
+	if conflict.ResolutionStatus.String == "user_resolved" {
 		return echo.NewHTTPError(http.StatusBadRequest, "conflict already resolved")
 	}

@@ -258,6 +258,12 @@ func (h *ConflictHandler) ResolveConflict(c *echo.Context) error {
 		}
 	}

+	if conflict.ConflictType == "annotation_highlight" || conflict.ConflictType == "annotation_bookmark" || conflict.ConflictType == "annotation_note" {
+		if err := h.applyAnnotationResolution(conflict.MediaItemID, conflict.UserID, winnerData, conflict.ConflictType); err == nil {
+			appliedTo["annotations"] = true
+		}
+	}
+
 	resolutionData := map[string]interface{}{
 		"winner":      req.Winner,
 		"applied_to":  appliedTo,
@@ -356,6 +362,143 @@ func (h *ConflictHandler) applyProgressResolution(mediaItemID pgtype.UUID, userI
 	return err
 }

+func (h *ConflictHandler) applyAnnotationResolution(mediaItemID pgtype.UUID, userID pgtype.UUID, winnerData map[string]interface{}, conflictType string) error {
+	ctx := context.Background()
+
+	dedupKey, _ := winnerData["dedup_key"].(string)
+	if dedupKey == "" {
+		return errors.New("missing dedup_key in winner data")
+	}
+
+	switch conflictType {
+	case "annotation_highlight":
+		return h.applyHighlightResolution(ctx, mediaItemID, userID, dedupKey, winnerData)
+	case "annotation_bookmark":
+		return h.applyBookmarkResolution(ctx, mediaItemID, userID, dedupKey, winnerData)
+	case "annotation_note":
+		return h.applyNoteResolution(ctx, mediaItemID, userID, dedupKey, winnerData)
+	default:
+		return errors.New("unknown annotation conflict type")
+	}
+}
+
+func (h *ConflictHandler) applyHighlightResolution(ctx context.Context, mediaItemID pgtype.UUID, userID pgtype.UUID, dedupKey string, data map[string]interface{}) error {
+	existing, err := h.db.GetMediaHighlightByDedupKey(ctx, database.GetMediaHighlightByDedupKeyParams{
+		MediaItemID: mediaItemID,
+		DedupKey:    pgtype.Text{String: dedupKey, Valid: true},
+	})
+	if err != nil {
+		return err
+	}
+
+	params := database.UpdateMediaHighlightForSyncParams{
+		ID:                existing.ID,
+		SelectionText:     existing.SelectionText,
+		StartPosition:     existing.StartPosition,
+		EndPosition:       existing.EndPosition,
+		Color:             existing.Color,
+		NoteText:          existing.NoteText,
+		PercentageStart:   existing.PercentageStart,
+		PercentageEnd:     existing.PercentageEnd,
+		EpubcfiStart:      existing.EpubcfiStart,
+		EpubcfiEnd:        existing.EpubcfiEnd,
+		ChapterReference:  existing.ChapterReference,
+		LastModifiedAt:    pgtype.Timestamptz{Time: time.Now(), Valid: true},
+		LastModifiedSource: pgtype.Text{String: "conflict_resolution", Valid: true},
+		DeviceSyncData:     existing.DeviceSyncData,
+	}
+
+	if v, ok := data["selection_text"].(string); ok {
+		params.SelectionText = v
+	}
+	if v, ok := data["color"].(string); ok {
+		params.Color = pgtype.Text{String: v, Valid: true}
+	}
+	if v, ok := data["note_text"].(string); ok {
+		params.NoteText = pgtype.Text{String: v, Valid: true}
+	}
+	if v, ok := data["start_position"].(string); ok {
+		params.StartPosition = pgtype.Text{String: v, Valid: true}
+	}
+	if v, ok := data["end_position"].(string); ok {
+		params.EndPosition = pgtype.Text{String: v, Valid: true}
+	}
+
+	_, err = h.db.UpdateMediaHighlightForSync(ctx, params)
+	return err
+}
+
+func (h *ConflictHandler) applyBookmarkResolution(ctx context.Context, mediaItemID pgtype.UUID, userID pgtype.UUID, dedupKey string, data map[string]interface{}) error {
+	existing, err := h.db.GetMediaBookmarkByDedupKey(ctx, database.GetMediaBookmarkByDedupKeyParams{
+		MediaItemID: mediaItemID,
+		DedupKey:    pgtype.Text{String: dedupKey, Valid: true},
+	})
+	if err != nil {
+		return err
+	}
+
+	params := database.UpdateMediaBookmarkForSyncParams{
+		ID:                existing.ID,
+		PageNumber:        existing.PageNumber,
+		ChapterNumber:     existing.ChapterNumber,
+		CfiPosition:       existing.CfiPosition,
+		Title:             existing.Title,
+		Position:          existing.Position,
+		Notes:             existing.Notes,
+		PercentageLocation: existing.PercentageLocation,
+		EpubcfiLocation:   existing.EpubcfiLocation,
+		ChapterReference:  existing.ChapterReference,
+		LastModifiedAt:    pgtype.Timestamptz{Time: time.Now(), Valid: true},
+		LastModifiedSource: pgtype.Text{String: "conflict_resolution", Valid: true},
+		DeviceSyncData:     existing.DeviceSyncData,
+	}
+
+	if v, ok := data["title"].(string); ok {
+		params.Title = v
+	}
+	if v, ok := data["notes"].(string); ok {
+		params.Notes = pgtype.Text{String: v, Valid: true}
+	}
+
+	_, err = h.db.UpdateMediaBookmarkForSync(ctx, params)
+	return err
+}
+
+func (h *ConflictHandler) applyNoteResolution(ctx context.Context, mediaItemID pgtype.UUID, userID pgtype.UUID, dedupKey string, data map[string]interface{}) error {
+	existing, err := h.db.GetMediaNoteByDedupKey(ctx, database.GetMediaNoteByDedupKeyParams{
+		MediaItemID: mediaItemID,
+		DedupKey:    pgtype.Text{String: dedupKey, Valid: true},
+	})
+	if err != nil {
+		return err
+	}
+
+	params := database.UpdateMediaNoteForSyncParams{
+		ID:                 existing.ID,
+		Content:            existing.Content,
+		Position:           existing.Position,
+		PercentageLocation: existing.PercentageLocation,
+		CharacterStart:     existing.CharacterStart,
+		CharacterEnd:       existing.CharacterEnd,
+		EpubcfiLocation:    existing.EpubcfiLocation,
+		ChapterReference:   existing.ChapterReference,
+		ParagraphReference: existing.ParagraphReference,
+		LastModifiedAt:     pgtype.Timestamptz{Time: time.Now(), Valid: true},
+		LastModifiedSource: pgtype.Text{String: "conflict_resolution", Valid: true},
+		DeviceSyncData:     existing.DeviceSyncData,
+	}
+
+	if v, ok := data["content"].(string); ok {
+		params.Content = v
+	}
+	if v, ok := data["position"].(string); ok {
+		params.Position = pgtype.Text{String: v, Valid: true}
+	}
+
+	_, err = h.db.UpdateMediaNoteForSync(ctx, params)
+	return err
+}
+
 func (h *ConflictHandler) notifyDevicesOfResolution(mediaItemID pgtype.UUID, data map[string]interface{}) []string {
 	devices, err := h.db.ListDevicesByType(context.Background(), "koreader")
 	if err != nil {