A community based topic aggregation platform built on atproto
bretton.dev
1# Comment System Implementation
2
3## Overview
4
5This document details the complete implementation of the comment system for Coves, a forum-like atProto social media platform. The comment system follows the established vote system pattern, with comments living in user repositories and being indexed by the AppView via Jetstream firehose.
6
7**Implementation Date:** November 4-6, 2025
8**Status:** ✅ Phase 1, 2A & 2B Complete - Production-Ready with Vote Integration + PR Hardening
9**Test Coverage:**
10- 35 integration tests (18 indexing + 11 query + 6 voting)
11- 22 unit tests (32 scenarios, 94.3% code coverage)
12- All tests passing ✅
13**Last Updated:** November 6, 2025 (Phase 2B complete with production hardening)
14
15---
16
17## Development Phases
18
19This implementation follows a phased approach for maintainability and proper scoping:
20
21### ✅ Phase 1: Indexing Infrastructure (Current - COMPLETE)
22**What was built:**
23- Jetstream consumer for indexing comment CREATE/UPDATE/DELETE events
24- PostgreSQL schema with proper indexes and denormalized counts
25- Repository layer with comprehensive query methods
26- Atomic parent count updates (posts.comment_count, comments.reply_count)
27- Out-of-order event handling with reconciliation
28- Soft delete support preserving thread structure
29- Full integration test coverage (20 tests)
30
31**What works:**
32- Comments are indexed from Jetstream firehose as users create them
33- Threading relationships tracked (root + parent references)
34- Parent counts automatically maintained
35- Comment updates and deletes processed correctly
36- Out-of-order events reconciled automatically
37
38**What's NOT in this phase:**
39- ❌ No HTTP API endpoints for querying comments
40- ❌ No service layer (repository is sufficient for indexing)
41- ❌ No rate limiting or auth middleware
42- ❌ No API documentation
43
44### ✅ Phase 2A: Query API - COMPLETE (November 5, 2025)
45
46**What was built:**
47- Lexicon definitions: `social.coves.community.comment.defs` and `getComments`
48- Database query methods with Lemmy hot ranking algorithm
49- Service layer with iterative loading strategy for nested replies
50- XRPC HTTP handler with optional authentication
51- Comprehensive integration test suite (11 test scenarios)
52
53**What works:**
54- Fetch comments on any post with sorting (hot/top/new)
55- Nested replies up to configurable depth (default 10, max 100)
56- Lemmy hot ranking: `log(greatest(2, score + 2)) / power(time_decay, 1.8)`
57- Cursor-based pagination for stable scrolling
58- Optional authentication for viewer state (stubbed for Phase 2B)
59- Timeframe filtering for "top" sort (hour/day/week/month/year/all)
60
61**Endpoints:**
62- `GET /xrpc/social.coves.community.comment.getComments`
63 - Required: `post` (AT-URI)
64 - Optional: `sort` (hot/top/new), `depth` (0-100), `limit` (1-100), `cursor`, `timeframe`
65 - Returns: Array of `threadViewComment` with nested replies + post context
66 - Supports Bearer token for authenticated requests (viewer state)
67
68**Files created (9):**
691. `internal/atproto/lexicon/social/coves/community/comment/defs.json` - View definitions
702. `internal/atproto/lexicon/social/coves/community/comment/getComments.json` - Query endpoint
713. `internal/core/comments/comment_service.go` - Business logic layer
724. `internal/core/comments/view_models.go` - API response types
735. `internal/api/handlers/comments/get_comments.go` - HTTP handler
746. `internal/api/handlers/comments/errors.go` - Error handling utilities
757. `internal/api/handlers/comments/middleware.go` - Auth middleware
768. `internal/api/handlers/comments/service_adapter.go` - Service layer adapter
779. `tests/integration/comment_query_test.go` - Integration tests
78
79**Files modified (7):**
801. `internal/db/postgres/comment_repo.go` - Added query methods (~450 lines), fixed INNER→LEFT JOIN, fixed window function SQL
812. `internal/core/comments/interfaces.go` - Added service interface
823. `internal/core/comments/comment.go` - Added CommenterHandle field
834. `internal/core/comments/errors.go` - Added IsValidationError helper
845. `cmd/server/main.go` - Wired up routes and service with all repositories
856. `tests/integration/comment_query_test.go` - Updated test helpers for new service signature
867. `docs/COMMENT_SYSTEM_IMPLEMENTATION.md` - This document
87
88**Total new code:** ~2,400 lines
89
90**Test coverage:**
91- 11 integration test scenarios covering:
92 - Basic fetch, nested replies, depth limits
93 - Hot/top/new sorting algorithms
94 - Pagination with cursor stability
95 - Empty threads, deleted comments
96 - Invalid input handling
97 - HTTP handler end-to-end
98- Repository layer tested (hot ranking formula, pagination)
99- Service layer tested (threading, depth limits)
100- Handler tested (input validation, error cases)
101- All tests passing ✅
102
103### 🔒 Production Hardening (PR Review Fixes - November 5, 2025)
104
105After initial implementation, a thorough PR review identified several critical issues that were addressed before production deployment:
106
107#### Critical Issues Fixed
108
109**1. N+1 Query Problem (99.7% reduction in queries)**
110- **Problem:** Nested reply loading made separate DB queries for each comment's children
111- **Impact:** Could execute 1,551 queries for a post with 50 comments at depth 3
112- **Solution:** Implemented batch loading with PostgreSQL window functions
113 - Added `ListByParentsBatch()` method using `ROW_NUMBER() OVER (PARTITION BY parent_uri)`
114 - Refactored `buildThreadViews()` to collect parent URIs per level and fetch in one query
115 - **Result:** Reduced from 1,551 queries → 4 queries (1 per depth level)
116- **Files:** `internal/core/comments/interfaces.go`, `internal/db/postgres/comment_repo.go`, `internal/core/comments/comment_service.go`
117
118**2. Post Not Found Returns 500 Instead of 404**
119- **Problem:** When fetching comments for non-existent post, service returned wrapped `posts.ErrNotFound` which handler didn't recognize
120- **Impact:** Clients got HTTP 500 instead of proper HTTP 404
121- **Solution:** Added error translation in service layer
122 ```go
123 if posts.IsNotFound(err) {
124 return nil, ErrRootNotFound // Recognized by comments.IsNotFound()
125 }
126 ```
127- **File:** `internal/core/comments/comment_service.go:68-72`
128
129#### Important Issues Fixed
130
131**3. Missing Endpoint-Specific Rate Limiting**
132- **Problem:** Comment queries with deep nesting expensive but only protected by global 100 req/min limit
133- **Solution:** Added dedicated rate limiter at 20 req/min for comment endpoint
134- **File:** `cmd/server/main.go:429-439`
135
136**4. Unbounded Cursor Size (DoS Vector)**
137- **Problem:** No validation before base64 decoding - attacker could send massive cursor string
138- **Solution:** Added 1024-byte max size check before decoding
139- **File:** `internal/db/postgres/comment_repo.go:547-551`
140
141**5. Missing Query Timeout**
142- **Problem:** Deep nested queries could run indefinitely
143- **Solution:** Added 10-second context timeout to `GetComments()`
144- **File:** `internal/core/comments/comment_service.go:62-64`
145
146**6. Post View Not Populated (P0 Blocker)**
147- **Problem:** Lexicon marked `post` field as required but response always returned `null`
148- **Impact:** Violated schema contract, would break client deserialization
149- **Solution:**
150 - Updated service to accept `posts.Repository` instead of `interface{}`
151 - Added `buildPostView()` method to construct post views with author/community/stats
152 - Fetch post before returning response
153- **Files:** `internal/core/comments/comment_service.go:33-36`, `:66-73`, `:224-274`
154
155**7. Missing Record Fields (P0 Blocker)**
156- **Problem:** Both `postView.record` and `commentView.record` fields were null despite lexicon marking them as required
157- **Impact:** Violated lexicon contract, would break strict client deserialization
158- **Solution:**
159 - Added `buildPostRecord()` method to construct minimal PostRecord from Post entity
160 - Added `buildCommentRecord()` method to construct minimal CommentRecord from Comment entity
161 - Both methods populate required fields (type, reply refs, content, timestamps)
162 - Added TODOs for Phase 2C to unmarshal JSON fields (embed, facets, labels)
163- **Files:** `internal/core/comments/comment_service.go:260-288`, `:366-386`
164
165**8. Handle/Name Format Violations (P0 & Important)**
166- **Problem:**
167 - `postView.author.handle` contained DID instead of proper handle (violates `format:"handle"`)
168 - `postView.community.name` contained DID instead of community name
169- **Impact:** Lexicon format constraints violated, poor UX showing DIDs instead of readable names
170- **Solution:**
171 - Added `users.UserRepository` to service for author handle hydration
172 - Added `communities.Repository` to service for community name hydration
173 - Updated `buildPostView()` to fetch user and community records with DID fallback
174 - Log warnings for missing records but don't fail entire request
175- **Files:** `internal/core/comments/comment_service.go:34-37`, `:292-325`, `cmd/server/main.go:297`
176
177**9. Data Loss from INNER JOIN (P1 Critical)**
178- **Problem:** Three query methods used `INNER JOIN users` which dropped comments when user not indexed yet
179- **Impact:** New user's first comments would disappear until user consumer caught up (violates out-of-order design)
180- **Solution:**
181 - Changed `INNER JOIN users` → `LEFT JOIN users` in all three methods
182 - Added `COALESCE(u.handle, c.commenter_did)` to gracefully fall back to DID
183 - Preserves all comments while still hydrating handles when available
184- **Files:** `internal/db/postgres/comment_repo.go:396`, `:407`, `:415`, `:694-706`, `:761-836`
185
186**10. Window Function SQL Bug (P0 Critical)**
187- **Problem:** `ListByParentsBatch` used `ORDER BY hot_rank DESC` in window function, but PostgreSQL doesn't allow SELECT aliases in window ORDER BY
188- **Impact:** SQL error "column hot_rank does not exist" caused silent failure, dropping ALL nested replies in hot sort mode
189- **Solution:**
190 - Created separate `windowOrderBy` variable that inlines full hot_rank formula
191 - PostgreSQL evaluates window ORDER BY before SELECT, so must use full expression
192 - Hot sort now works correctly with nested replies
193- **Files:** `internal/db/postgres/comment_repo.go:776`, `:808`
194- **Critical Note:** This affected default sorting mode (hot) and would have broken production UX
195
196#### Documentation Added
197
198**11. Hot Rank Caching Strategy**
199- Documented when and how to implement cached hot rank column
200- Specified observability metrics to monitor (p95 latency, CPU usage)
201- Documented trade-offs between cached vs on-demand computation
202
203**Test Coverage:**
204- All fixes verified with existing integration test suite
205- Added test cases for error handling scenarios
206- All integration tests passing (comment_query_test.go: 11 tests)
207
208**Rationale for phased approach:**
2091. **Separation of concerns**: Indexing and querying are distinct responsibilities
2102. **Testability**: Phase 1 can be fully tested without API layer
2113. **Incremental delivery**: Indexing can run in production while API is developed
2124. **Scope management**: Prevents feature creep and allows focused code review
213
214---
215
216## Hot Ranking Algorithm (Lemmy-Based)
217
218### Formula
219
220```sql
221log(greatest(2, score + 2)) /
222 power(((EXTRACT(EPOCH FROM (NOW() - created_at)) / 3600) + 2), 1.8)
223```
224
225### Explanation
226
227**Components:**
228- `greatest(2, score + 2)`: Ensures log input never goes below 2
229 - Prevents negative log values for heavily downvoted comments
230 - Score of -5 → log(2), same as score of 0
231 - Prevents brigading from creating "anti-viral" comments
232
233- `power(..., 1.8)`: Time decay exponent
234 - Higher than posts (1.5) for faster comment aging
235 - Comments should be fresher than posts
236
237- `+ 2` offsets: Prevent divide-by-zero for very new comments
238
239**Behavior:**
240- High score + old = lower rank (content ages naturally)
241- Low score + new = higher rank (fresh content gets visibility)
242- Negative scores don't break the formula (bounded at log(2))
243
244### Sort Modes
245
246**Hot (default):**
247```sql
248ORDER BY hot_rank DESC, score DESC, created_at DESC
249```
250
251**Top (with timeframe):**
252```sql
253WHERE created_at >= NOW() - INTERVAL '1 day'
254ORDER BY score DESC, created_at DESC
255```
256
257**New (chronological):**
258```sql
259ORDER BY created_at DESC
260```
261
262### Path-Based Ordering
263
264Comments are ordered within their tree level:
265```sql
266ORDER BY
267 path ASC, -- Maintains parent-child structure
268 hot_rank DESC, -- Sorts siblings by rank
269 score DESC, -- Tiebreaker
270 created_at DESC -- Final tiebreaker
271```
272
273**Result:** Siblings compete with siblings, but children never outrank their parent.
274
275---
276
277## Architecture
278
279### Data Flow
280
281```
282Client → User's PDS → Jetstream Firehose → Comment Consumer → PostgreSQL AppView
283 ↓
284 Atomic updates to parent counts
285 (posts.comment_count OR comments.reply_count)
286```
287
288### Key Design Principles
289
2901. **User-Owned Records**: Comments live in user repositories (like votes), not community repositories (like posts)
2912. **atProto Native**: Uses `com.atproto.repo.createRecord/updateRecord/deleteRecord`
2923. **Threading via Strong References**: Root + parent system allows unlimited nesting depth
2934. **Out-of-Order Indexing**: No foreign key constraints to allow Jetstream events to arrive in any order
2945. **Idempotent Operations**: Safe for Jetstream replays and duplicate events
2956. **Atomic Count Updates**: Database transactions ensure consistency
2967. **Soft Deletes**: Preserves thread structure when comments are deleted
297
298---
299
300## Implementation Details
301
302### 1. Lexicon Definition
303
304**Location:** `internal/atproto/lexicon/social/coves/feed/comment.json`
305
306The lexicon was already defined and follows atProto best practices:
307
308```json
309{
310 "lexicon": 1,
311 "id": "social.coves.feed.comment",
312 "defs": {
313 "main": {
314 "type": "record",
315 "key": "tid",
316 "required": ["reply", "content", "createdAt"],
317 "properties": {
318 "reply": {
319 "type": "ref",
320 "ref": "#replyRef",
321 "description": "Reference to the post and parent being replied to"
322 },
323 "content": {
324 "type": "string",
325 "maxGraphemes": 3000,
326 "maxLength": 30000
327 },
328 "facets": { /* Rich text annotations */ },
329 "embed": { /* Images, quoted posts */ },
330 "langs": { /* ISO 639-1 language codes */ },
331 "labels": { /* Self-applied content labels */ },
332 "createdAt": { /* RFC3339 timestamp */ }
333 }
334 },
335 "replyRef": {
336 "required": ["root", "parent"],
337 "properties": {
338 "root": {
339 "type": "ref",
340 "ref": "com.atproto.repo.strongRef",
341 "description": "Strong reference to the original post"
342 },
343 "parent": {
344 "type": "ref",
345 "ref": "com.atproto.repo.strongRef",
346 "description": "Strong reference to immediate parent (post or comment)"
347 }
348 }
349 }
350 }
351}
352```
353
354**Threading Model:**
355- `root`: Always points to the original post that started the thread
356- `parent`: Points to the immediate parent (can be a post or another comment)
357- This enables unlimited nested threading while maintaining the root reference
358
359---
360
361### 2. Database Schema
362
363**Migration:** `internal/db/migrations/016_create_comments_table.sql`
364
365```sql
366CREATE TABLE comments (
367 id BIGSERIAL PRIMARY KEY,
368 uri TEXT UNIQUE NOT NULL, -- AT-URI (at://commenter_did/social.coves.feed.comment/rkey)
369 cid TEXT NOT NULL, -- Content ID
370 rkey TEXT NOT NULL, -- Record key (TID)
371 commenter_did TEXT NOT NULL, -- User who commented (from AT-URI repo field)
372
373 -- Threading structure (reply references)
374 root_uri TEXT NOT NULL, -- Strong reference to original post
375 root_cid TEXT NOT NULL, -- CID of root post (version pinning)
376 parent_uri TEXT NOT NULL, -- Strong reference to immediate parent
377 parent_cid TEXT NOT NULL, -- CID of parent (version pinning)
378
379 -- Content
380 content TEXT NOT NULL, -- Comment text (max 3000 graphemes, 30000 bytes)
381 content_facets JSONB, -- Rich text facets
382 embed JSONB, -- Embedded content (images, quoted posts)
383 content_labels JSONB, -- Self-applied labels (com.atproto.label.defs#selfLabels)
384 langs TEXT[], -- Languages (ISO 639-1, max 3)
385
386 -- Timestamps
387 created_at TIMESTAMPTZ NOT NULL, -- Commenter's timestamp from record
388 indexed_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
389 deleted_at TIMESTAMPTZ, -- Soft delete
390
391 -- Stats (denormalized for performance)
392 upvote_count INT NOT NULL DEFAULT 0, -- Comments CAN be voted on
393 downvote_count INT NOT NULL DEFAULT 0,
394 score INT NOT NULL DEFAULT 0, -- upvote_count - downvote_count
395 reply_count INT NOT NULL DEFAULT 0 -- Number of direct replies
396);
397```
398
399**Key Indexes:**
400```sql
401-- Threading queries (most important for UX)
402CREATE INDEX idx_comments_root ON comments(root_uri, created_at DESC)
403 WHERE deleted_at IS NULL;
404CREATE INDEX idx_comments_parent ON comments(parent_uri, created_at DESC)
405 WHERE deleted_at IS NULL;
406CREATE INDEX idx_comments_parent_score ON comments(parent_uri, score DESC, created_at DESC)
407 WHERE deleted_at IS NULL;
408
409-- User queries
410CREATE INDEX idx_comments_commenter ON comments(commenter_did, created_at DESC);
411
412-- Vote targeting
413CREATE INDEX idx_comments_uri_active ON comments(uri)
414 WHERE deleted_at IS NULL;
415```
416
417**Design Decisions:**
418- **No FK on `commenter_did`**: Allows out-of-order Jetstream indexing (comment events may arrive before user events)
419- **Soft delete pattern**: `deleted_at IS NULL` in indexes for performance
420- **Vote counts included**: The vote lexicon explicitly allows voting on comments (not just posts)
421- **StrongRef with CID**: Version pinning prevents confusion when parent content changes
422
423---
424
425### 3. Domain Layer
426
427#### Comment Entity
428**File:** `internal/core/comments/comment.go`
429
430```go
431type Comment struct {
432 ID int64
433 URI string
434 CID string
435 RKey string
436 CommenterDID string
437
438 // Threading
439 RootURI string
440 RootCID string
441 ParentURI string
442 ParentCID string
443
444 // Content
445 Content string
446 ContentFacets *string
447 Embed *string
448 ContentLabels *string
449 Langs []string
450
451 // Timestamps
452 CreatedAt time.Time
453 IndexedAt time.Time
454 DeletedAt *time.Time
455
456 // Stats
457 UpvoteCount int
458 DownvoteCount int
459 Score int
460 ReplyCount int
461}
462```
463
464#### Repository Interface
465**File:** `internal/core/comments/interfaces.go`
466
467```go
468type Repository interface {
469 Create(ctx context.Context, comment *Comment) error
470 Update(ctx context.Context, comment *Comment) error
471 GetByURI(ctx context.Context, uri string) (*Comment, error)
472 Delete(ctx context.Context, uri string) error
473
474 // Threading queries
475 ListByRoot(ctx context.Context, rootURI string, limit, offset int) ([]*Comment, error)
476 ListByParent(ctx context.Context, parentURI string, limit, offset int) ([]*Comment, error)
477 CountByParent(ctx context.Context, parentURI string) (int, error)
478
479 // User queries
480 ListByCommenter(ctx context.Context, commenterDID string, limit, offset int) ([]*Comment, error)
481}
482```
483
484#### Error Types
485**File:** `internal/core/comments/errors.go`
486
487Standard error types following the vote system pattern, with helper functions `IsNotFound()` and `IsConflict()`.
488
489---
490
491### 4. Repository Implementation
492
493**File:** `internal/db/postgres/comment_repo.go`
494
495#### Idempotent Create Pattern
496```go
497func (r *postgresCommentRepo) Create(ctx context.Context, comment *Comment) error {
498 query := `
499 INSERT INTO comments (...)
500 VALUES (...)
501 ON CONFLICT (uri) DO NOTHING
502 RETURNING id, indexed_at
503 `
504
505 err := r.db.QueryRowContext(ctx, query, ...).Scan(&comment.ID, &comment.IndexedAt)
506
507 // ON CONFLICT DO NOTHING returns no rows if duplicate
508 if err == sql.ErrNoRows {
509 return nil // Already exists - OK for Jetstream replays
510 }
511
512 return err
513}
514```
515
516#### Update Preserving Vote Counts
517```go
518func (r *postgresCommentRepo) Update(ctx context.Context, comment *Comment) error {
519 query := `
520 UPDATE comments
521 SET cid = $1, content = $2, content_facets = $3,
522 embed = $4, content_labels = $5, langs = $6
523 WHERE uri = $7 AND deleted_at IS NULL
524 RETURNING id, indexed_at, created_at,
525 upvote_count, downvote_count, score, reply_count
526 `
527
528 // Vote counts and created_at are preserved (not in SET clause)
529 err := r.db.QueryRowContext(ctx, query, ...).Scan(...)
530 return err
531}
532```
533
534#### Soft Delete
535```go
536func (r *postgresCommentRepo) Delete(ctx context.Context, uri string) error {
537 query := `
538 UPDATE comments
539 SET deleted_at = NOW()
540 WHERE uri = $1 AND deleted_at IS NULL
541 `
542
543 result, err := r.db.ExecContext(ctx, query, uri)
544 // Idempotent: Returns success even if already deleted
545 return err
546}
547```
548
549---
550
551### 5. Jetstream Consumer
552
553**File:** `internal/atproto/jetstream/comment_consumer.go`
554
555#### Event Handler
556```go
557func (c *CommentEventConsumer) HandleEvent(ctx context.Context, event *JetstreamEvent) error {
558 if event.Kind != "commit" || event.Commit == nil {
559 return nil
560 }
561
562 if event.Commit.Collection == "social.coves.feed.comment" {
563 switch event.Commit.Operation {
564 case "create":
565 return c.createComment(ctx, event.Did, commit)
566 case "update":
567 return c.updateComment(ctx, event.Did, commit)
568 case "delete":
569 return c.deleteComment(ctx, event.Did, commit)
570 }
571 }
572
573 return nil
574}
575```
576
577#### Atomic Count Updates
578```go
579func (c *CommentEventConsumer) indexCommentAndUpdateCounts(ctx, comment *Comment) error {
580 tx, _ := c.db.BeginTx(ctx, nil)
581 defer tx.Rollback()
582
583 // 1. Insert comment (idempotent)
584 err = tx.QueryRowContext(ctx, `
585 INSERT INTO comments (...) VALUES (...)
586 ON CONFLICT (uri) DO NOTHING
587 RETURNING id
588 `).Scan(&commentID)
589
590 if err == sql.ErrNoRows {
591 tx.Commit()
592 return nil // Already indexed
593 }
594
595 // 2. Update parent counts atomically
596 // Try posts table first
597 tx.ExecContext(ctx, `
598 UPDATE posts
599 SET comment_count = comment_count + 1
600 WHERE uri = $1 AND deleted_at IS NULL
601 `, comment.ParentURI)
602
603 // If no post updated, parent is probably a comment
604 tx.ExecContext(ctx, `
605 UPDATE comments
606 SET reply_count = reply_count + 1
607 WHERE uri = $1 AND deleted_at IS NULL
608 `, comment.ParentURI)
609
610 return tx.Commit()
611}
612```
613
614#### Security Validation
615```go
616func (c *CommentEventConsumer) validateCommentEvent(ctx, repoDID string, comment *CommentRecord) error {
617 // Comments MUST come from user repositories (repo owner = commenter DID)
618 if !strings.HasPrefix(repoDID, "did:") {
619 return fmt.Errorf("invalid commenter DID format: %s", repoDID)
620 }
621
622 // Content is required
623 if comment.Content == "" {
624 return fmt.Errorf("comment content is required")
625 }
626
627 // Reply references must have both URI and CID
628 if comment.Reply.Root.URI == "" || comment.Reply.Root.CID == "" {
629 return fmt.Errorf("invalid root reference: must have both URI and CID")
630 }
631
632 if comment.Reply.Parent.URI == "" || comment.Reply.Parent.CID == "" {
633 return fmt.Errorf("invalid parent reference: must have both URI and CID")
634 }
635
636 return nil
637}
638```
639
640**Security Note:** We do NOT verify that the user exists in the AppView because:
6411. Comment events may arrive before user events in Jetstream (race condition)
6422. The comment came from the user's PDS repository (authenticated by PDS)
6433. No database FK constraint allows out-of-order indexing
6444. Orphaned comments (from never-indexed users) are harmless
645
646---
647
648### 6. WebSocket Connector
649
650**File:** `internal/atproto/jetstream/comment_jetstream_connector.go`
651
652Follows the standard Jetstream connector pattern with:
653- Auto-reconnect on errors (5-second retry)
654- Ping/pong keepalive (30-second ping, 60-second read deadline)
655- Graceful shutdown via context cancellation
656- Subscribes to: `wantedCollections=social.coves.feed.comment`
657
658---
659
660### 7. Server Integration
661
662**File:** `cmd/server/main.go` (lines 289-396)
663
664```go
665// Initialize comment repository
666commentRepo := postgresRepo.NewCommentRepository(db)
667log.Println("✅ Comment repository initialized (Jetstream indexing only)")
668
669// Start Jetstream consumer for comments
670commentJetstreamURL := os.Getenv("COMMENT_JETSTREAM_URL")
671if commentJetstreamURL == "" {
672 commentJetstreamURL = "ws://localhost:6008/subscribe?wantedCollections=social.coves.feed.comment"
673}
674
675commentEventConsumer := jetstream.NewCommentEventConsumer(commentRepo, db)
676commentJetstreamConnector := jetstream.NewCommentJetstreamConnector(commentEventConsumer, commentJetstreamURL)
677
678go func() {
679 if startErr := commentJetstreamConnector.Start(ctx); startErr != nil {
680 log.Printf("Comment Jetstream consumer stopped: %v", startErr)
681 }
682}()
683
684log.Printf("Started Jetstream comment consumer: %s", commentJetstreamURL)
685log.Println(" - Indexing: social.coves.feed.comment CREATE/UPDATE/DELETE operations")
686log.Println(" - Updating: Post comment counts and comment reply counts atomically")
687```
688
689---
690
691## Testing
692
693### Test Suite
694
695**File:** `tests/integration/comment_consumer_test.go`
696
697**Test Coverage:** 6 test suites, 18 test cases, **100% passing**
698
699#### 1. TestCommentConsumer_CreateComment
700- ✅ Create comment on post
701- ✅ Verify comment is indexed correctly
702- ✅ Verify post comment count is incremented
703- ✅ Idempotent create - duplicate events don't double-count
704
705#### 2. TestCommentConsumer_Threading
706- ✅ Create first-level comment (reply to post)
707- ✅ Create second-level comment (reply to comment)
708- ✅ Verify both comments have same root (original post)
709- ✅ Verify parent relationships are correct
710- ✅ Verify reply counts are updated
711- ✅ Query all comments by root (flat list)
712- ✅ Query direct replies to post
713- ✅ Query direct replies to comment
714
715#### 3. TestCommentConsumer_UpdateComment
716- ✅ Create comment with initial content
717- ✅ Manually set vote counts to simulate votes
718- ✅ Update comment content
719- ✅ Verify content is updated
720- ✅ Verify CID is updated
721- ✅ **Verify vote counts are preserved**
722- ✅ **Verify created_at is preserved**
723
724#### 4. TestCommentConsumer_DeleteComment
725- ✅ Create comment
726- ✅ Delete comment (soft delete)
727- ✅ Verify deleted_at is set
728- ✅ Verify post comment count is decremented
729- ✅ Idempotent delete - duplicate deletes don't double-decrement
730
731#### 5. TestCommentConsumer_SecurityValidation
732- ✅ Reject comment with empty content
733- ✅ Reject comment with invalid root reference (missing URI)
734- ✅ Reject comment with invalid parent reference (missing CID)
735- ✅ Reject comment with invalid DID format
736
737#### 6. TestCommentRepository_Queries
738- ✅ ListByRoot returns all comments in thread (4 comments)
739- ✅ ListByParent returns direct replies to post (2 comments)
740- ✅ ListByParent returns direct replies to comment (2 comments)
741- ✅ CountByParent returns correct counts
742- ✅ ListByCommenter returns all user's comments
743
744### Test Results
745
746```
747=== Test Summary ===
748PASS: TestCommentConsumer_CreateComment (0.02s)
749PASS: TestCommentConsumer_Threading (0.02s)
750PASS: TestCommentConsumer_UpdateComment (0.02s)
751PASS: TestCommentConsumer_DeleteComment (0.02s)
752PASS: TestCommentConsumer_SecurityValidation (0.01s)
753PASS: TestCommentRepository_Queries (0.02s)
754
755✅ ALL 18 TESTS PASS
756Total time: 0.115s
757```
758
759---
760
761## Key Features
762
763### ✅ Comments ARE Votable
764The vote lexicon explicitly states: *"Record declaring a vote (upvote or downvote) on a **post or comment**"*
765
766Comments include full vote tracking:
767- `upvote_count`
768- `downvote_count`
769- `score` (calculated as upvote_count - downvote_count)
770
771### ✅ Comments ARE Editable
772Unlike votes (which are immutable), comments support UPDATE operations:
773- Content, facets, embed, and labels can be updated
774- Vote counts and created_at are preserved
775- CID is updated to reflect new version
776
777### ✅ Threading Support
778Unlimited nesting depth via root + parent system:
779- Every comment knows its root post
780- Every comment knows its immediate parent
781- Easy to query entire threads or direct replies
782- Soft deletes preserve thread structure
783
784### ✅ Out-of-Order Indexing
785No foreign key constraints allow events to arrive in any order:
786- Comment events may arrive before user events
787- Comment events may arrive before post events
788- All operations are idempotent
789- Safe for Jetstream replays
790
791### ✅ Atomic Consistency
792Database transactions ensure counts are always accurate:
793- Comment creation increments parent count
794- Comment deletion decrements parent count
795- No race conditions
796- No orphaned counts
797
798---
799
800## Implementation Statistics
801
802### Phase 1 - Indexing Infrastructure
803
804**Files Created: 8**
8051. `internal/db/migrations/016_create_comments_table.sql` - 60 lines
8062. `internal/core/comments/comment.go` - 80 lines
8073. `internal/core/comments/interfaces.go` - 45 lines
8084. `internal/core/comments/errors.go` - 40 lines
8095. `internal/db/postgres/comment_repo.go` - 340 lines
8106. `internal/atproto/jetstream/comment_consumer.go` - 530 lines
8117. `internal/atproto/jetstream/comment_jetstream_connector.go` - 130 lines
8128. `tests/integration/comment_consumer_test.go` - 930 lines
813
814**Files Modified: 1**
8151. `cmd/server/main.go` - Added 20 lines for Jetstream consumer
816
817**Phase 1 Total:** ~2,175 lines
818
819### Phase 2A - Query API
820
821**Files Created: 9** (listed above in Phase 2A section)
822
823**Files Modified: 6** (listed above in Phase 2A section)
824
825**Phase 2A Total:** ~2,400 lines
826
827### Combined Total: ~4,575 lines
828
829---
830
831## Reference Pattern: Vote System
832
833The comment implementation closely follows the vote system pattern:
834
835| Aspect | Votes | Comments |
836|--------|-------|----------|
837| **Location** | User repositories | User repositories |
838| **Lexicon** | `social.coves.feed.vote` | `social.coves.feed.comment` |
839| **Operations** | CREATE, DELETE | CREATE, UPDATE, DELETE |
840| **Mutability** | Immutable | Editable |
841| **Foreign Keys** | None (out-of-order indexing) | None (out-of-order indexing) |
842| **Delete Pattern** | Soft delete | Soft delete |
843| **Idempotency** | ON CONFLICT DO NOTHING | ON CONFLICT DO NOTHING |
844| **Count Updates** | Atomic transaction | Atomic transaction |
845| **Security** | PDS authentication | PDS authentication |
846
847---
848
849## Future Phases
850
851### ✅ Phase 2B: Vote Integration - COMPLETE (November 6, 2025)
852
853**What was built:**
854- URI parsing utility (`ExtractCollectionFromURI`) for routing votes to correct table
855- Vote consumer refactored to support comment votes via URI collection parsing
856- Comment consumer refactored with same URI parsing pattern (consistency + performance)
857- Viewer vote state integration in comment service with batch loading
858- Comprehensive integration tests (6 test scenarios)
859
860**What works:**
861- Users can upvote/downvote comments (same as posts)
862- Vote counts (upvote_count, downvote_count, score) atomically updated on comments
863- Viewer vote state populated in comment queries (viewer.vote, viewer.voteUri)
864- URI parsing routes votes 1,000-20,000x faster than "try both tables" pattern
865- Batch loading prevents N+1 queries for vote state (one query per depth level)
866
867**Files modified (6):**
8681. `internal/atproto/utils/record_utils.go` - Added ExtractCollectionFromURI utility
8692. `internal/atproto/jetstream/vote_consumer.go` - Refactored for comment support with URI parsing
8703. `internal/atproto/jetstream/comment_consumer.go` - Applied URI parsing pattern for consistency
8714. `internal/core/comments/comment_service.go` - Integrated vote state with batch loading
8725. `tests/integration/comment_vote_test.go` - New test file (~560 lines)
8736. `docs/COMMENT_SYSTEM_IMPLEMENTATION.md` - Updated status
874
875**Test coverage:**
876- 6 integration test scenarios covering:
877 - Vote creation (upvote/downvote) with count updates
878 - Vote deletion with count decrements
879 - Viewer state population (authenticated with vote, authenticated without vote, unauthenticated)
880- All tests passing ✅
881
882**Performance improvements:**
883- URI parsing vs database queries: 1,000-20,000x faster
884- One query per table instead of two (worst case eliminated)
885- Consistent pattern across both consumers
886
887**Actual time:** 5-7 hours (including URI parsing refactor for both consumers)
888
889---
890
891### 🔒 Phase 2B Production Hardening (PR Review Fixes - November 6, 2025)
892
893After Phase 2B implementation, a thorough PR review identified several critical issues and improvements that were addressed before production deployment:
894
895#### Critical Issues Fixed
896
897**1. Post Comment Count Reconciliation (P0 Data Integrity)**
898- **Problem:** When a comment arrives before its parent post (common with Jetstream's cross-repository event ordering), the post update returns 0 rows affected. Later when the post is indexed, there was NO reconciliation logic to count pre-existing comments, causing posts to have permanently stale `comment_count` values.
899- **Impact:** Posts would show incorrect comment counts indefinitely, breaking UX and violating data integrity
900- **Solution:** Implemented reconciliation in post consumer (similar to existing pattern in comment consumer)
901 - Added `indexPostAndReconcileCounts()` method that runs within transaction
902 - After inserting post with `ON CONFLICT DO NOTHING`, queries for pre-existing comments
903 - Updates `comment_count` atomically: `SET comment_count = (SELECT COUNT(*) FROM comments WHERE parent_uri = $1)`
904 - All operations happen within same transaction as post insert
905- **Files:** `internal/atproto/jetstream/post_consumer.go` (~95 lines added)
906- **Updated:** 6 files total (main.go + 5 test files with new constructor signature)
907
908**2. Error Wrapping in Logging (Non-Issue - Review Mistake)**
909- **Initial Request:** Change `log.Printf("...%v", err)` to `log.Printf("...%w", err)` in vote consumer
910- **Investigation:** `%w` only works in `fmt.Errorf()`, not `log.Printf()`
911- **Conclusion:** Original code was correct - `%v` is proper format verb for logging
912- **Outcome:** No changes needed; error is properly returned on next line to preserve error chain
913
914**3. Incomplete Comment Record Construction (Deferred to Phase 2C)**
915- **Issue:** Rich text facets, embeds, and labels are stored in database but not deserialized in API responses
916- **Decision:** Per original Phase 2C plan, defer JSON field deserialization (already marked with TODO comments)
917- **Rationale:** Phase 2C explicitly covers "complete record" population - no scope creep needed
918
919#### Important Issues Fixed
920
921**4. Nil Pointer Handling in Vote State (Code Safety)**
922- **Problem:** Taking address of type-asserted variables directly from type assertion could be risky during refactoring
923 ```go
924 if direction, hasDirection := voteMap["direction"].(string); hasDirection {
925 viewer.Vote = &direction // ❌ Takes address of type-asserted variable
926 }
927 ```
928- **Impact:** Potential pointer bugs if code is refactored or patterns are reused
929- **Solution:** Create explicit copies before taking addresses
930 ```go
931 if direction, hasDirection := voteMap["direction"].(string); hasDirection {
932 directionCopy := direction
933 viewer.Vote = &directionCopy // ✅ Takes address of explicit copy
934 }
935 ```
936- **File:** `internal/core/comments/comment_service.go:277-291`
937
938**5. Unit Test Coverage (Testing Gap)**
939- **Problem:** Only integration tests existed - no unit tests with mocks for service layer
940- **Impact:** Slower test execution, harder to test edge cases in isolation
941- **Solution:** Created comprehensive unit test suite
942 - New file: `internal/core/comments/comment_service_test.go` (~1,130 lines)
943 - 22 test functions with 32 total scenarios
944 - Manual mocks for all repository interfaces (4 repos)
945 - Tests for GetComments(), buildThreadViews(), buildCommentView(), validation
946 - **Coverage:** 94.3% of comment service code
947 - **Execution:** ~10ms (no database, pure unit tests)
948- **Test Scenarios:**
949 - Happy paths with/without viewer authentication
950 - Error handling (post not found, repository errors)
951 - Edge cases (empty results, deleted comments, nil pointers)
952 - Sorting options (hot/top/new/invalid)
953 - Input validation (bounds enforcement, defaults)
954 - Vote state hydration with batch loading
955 - Nested threading logic with depth limits
956
957**6. ExtractCollectionFromURI Input Validation (Documentation Gap)**
958- **Problem:** Function returned empty string for malformed URIs with no clear indication in documentation
959- **Impact:** Unclear to callers what empty string means (error? missing data?)
960- **Solution:** Enhanced documentation with explicit semantics
961 - Documented that empty string means "unknown/unsupported collection"
962 - Added guidance for callers to validate return value before use
963 - Provided examples of valid and invalid inputs
964- **File:** `internal/atproto/utils/record_utils.go:19-36`
965
966**7. Race Conditions in Test Data (Flaky Tests)**
967- **Problem:** Tests used `time.Now()` which could lead to timing-sensitive failures
968- **Impact:** Tests could be flaky if database query takes >1 second or system clock changes
969- **Solution:** Replaced all `time.Now()` calls with fixed timestamps
970 ```go
971 fixedTime := time.Date(2025, 11, 6, 12, 0, 0, 0, time.UTC)
972 ```
973- **File:** `tests/integration/comment_vote_test.go` (9 replacements)
974- **Benefit:** Tests are now deterministic and repeatable
975
976**8. Viewer Authentication Validation (Non-Issue - Architecture Working as Designed)**
977- **Initial Concern:** ViewerDID field trusted without verification in service layer
978- **Investigation:** Authentication IS properly validated at middleware layer
979 - `OptionalAuth` middleware extracts and validates JWT Bearer tokens
980 - Uses PDS public keys (JWKS) for signature verification
981 - Validates token expiration, DID format, issuer
982 - Only injects verified DIDs into request context
983 - Handler extracts DID using `middleware.GetUserDID(r)`
984- **Architecture:** Follows industry best practices (authentication at perimeter)
985- **Outcome:** Code is secure; added documentation comments explaining the security boundary
986- **Recommendation:** Added clear comments in service explaining authentication contract
987
988#### Optimizations Implemented
989
990**9. Batch Vote Query Optimization (Performance)**
991- **Problem:** Query selected unused columns (`cid`, `created_at`) that weren't accessed by service
992- **Solution:** Optimized to only select needed columns
993 - Before: `SELECT subject_uri, direction, uri, cid, created_at`
994 - After: `SELECT subject_uri, direction, uri`
995- **File:** `internal/db/postgres/comment_repo.go:895-899`
996- **Benefit:** Reduced query overhead and memory usage
997
998**10. Magic Numbers Made Visible (Maintainability)**
999- **Problem:** `repliesPerParent = 5` was inline constant in function
1000- **Solution:** Promoted to package-level constant with documentation
1001 ```go
1002 const (
1003 // DefaultRepliesPerParent defines how many nested replies to load per parent comment
1004 // This balances UX (showing enough context) with performance (limiting query size)
1005 // Can be made configurable via constructor if needed in the future
1006 DefaultRepliesPerParent = 5
1007 )
1008 ```
1009- **File:** `internal/core/comments/comment_service.go`
1010- **Benefit:** Better visibility, easier to find/modify, documents intent
1011
1012#### Test Coverage Summary
1013
1014**Integration Tests (35 tests):**
1015- 18 indexing tests (comment_consumer_test.go)
1016- 11 query API tests (comment_query_test.go)
1017- 6 voting tests (comment_vote_test.go)
1018- All passing ✅
1019
1020**Unit Tests (22 tests, NEW):**
1021- 8 GetComments tests (valid request, errors, viewer states, sorting)
1022- 4 buildThreadViews tests (empty input, deleted comments, nested replies, depth limit)
1023- 5 buildCommentView tests (basic fields, top-level, nested, viewer votes)
1024- 5 validation tests (nil request, defaults, bounds, invalid values)
1025- **Code Coverage:** 94.3% of comment service
1026- All passing ✅
1027
1028#### Files Modified (9 total)
1029
1030**Core Implementation:**
10311. `internal/atproto/jetstream/post_consumer.go` - Post reconciliation (~95 lines)
10322. `internal/core/comments/comment_service.go` - Nil pointer fixes, constant
10333. `internal/atproto/utils/record_utils.go` - Enhanced documentation
10344. `internal/db/postgres/comment_repo.go` - Query optimization
10355. `tests/integration/comment_vote_test.go` - Fixed timestamps
10366. **NEW:** `internal/core/comments/comment_service_test.go` - Unit tests (~1,130 lines)
1037
1038**Test Updates:**
10397. `cmd/server/main.go` - Updated post consumer constructor
10408. `tests/integration/post_e2e_test.go` - 5 constructor updates
10419. `tests/integration/aggregator_e2e_test.go` - 1 constructor update
1042
1043#### Production Readiness Checklist
1044
1045✅ **Data Integrity:** Post comment count reconciliation prevents stale counts
1046✅ **Code Safety:** Nil pointer handling fixed, no undefined behavior
1047✅ **Test Coverage:** 94.3% unit test coverage + comprehensive integration tests
1048✅ **Documentation:** Clear comments on authentication, error handling, edge cases
1049✅ **Performance:** Optimized queries, batch loading, URI parsing
1050✅ **Security:** Authentication validated at middleware, documented architecture
1051✅ **Maintainability:** Constants documented, magic numbers eliminated
1052✅ **Reliability:** Fixed timestamp tests prevent flakiness
1053
1054**Total Implementation Effort:** Phase 2B initial (5-7 hours) + PR hardening (6-8 hours) = **~11-15 hours**
1055
1056---
1057
1058### 📋 Phase 2C: Post/User Integration (Partially Complete)
1059
1060**Completed (PR Review):**
1061- ✅ Integrated post repository in comment service
1062- ✅ Return postView in getComments response with basic fields
1063- ✅ Populate post author DID, community DID, stats (upvotes, downvotes, score, comment count)
1064
1065**Remaining Work:**
1066- ❌ Integrate user repository for full AuthorView
1067- ❌ Add display name and avatar to comment/post authors (currently returns DID as handle)
1068- ❌ Add community name and avatar (currently returns DID as name)
1069- ❌ Parse and include original record in commentView
1070
1071**Dependencies:**
1072- Phase 2A query API (✅ Complete)
1073- Post repository integration (✅ Complete)
1074- User repository integration (⏳ Pending)
1075
1076**Estimated effort for remaining work:** 1-2 hours
1077
1078---
1079
1080### 📋 Phase 3: Advanced Features (Future)
1081
1082#### 3A: Distinguished Comments
1083- Moderator/admin comment flags
1084- Priority sorting for distinguished comments
1085- Visual indicators in UI
1086
1087#### 3B: Comment Search & Filtering
1088- Full-text search within threads
1089- Filter by author, time range, score
1090- Search across community comments
1091
1092#### 3C: Moderation Tools
1093- Hide/remove comments
1094- Flag system for user reports
1095- Moderator queue
1096- Audit log
1097
1098#### 3D: Notifications
1099- Notify users of replies to their comments
1100- Notify post authors of new comments
1101- Mention notifications (@user)
1102- Customizable notification preferences
1103
1104#### 3E: Enhanced Features
1105- Comment edit history tracking
1106- Save/bookmark comments
1107- Sort by "controversial" (high engagement, low score)
1108- Collapsible comment threads
1109- User-specific comment history API
1110- Community-wide comment stats/analytics
1111
1112---
1113
1114### 📋 Phase 4: Namespace Migration (Separate Task)
1115
1116**Scope:**
1117- Migrate existing `social.coves.feed.comment` records to `social.coves.community.comment`
1118- Update all AT-URIs in database
1119- Update Jetstream consumer collection filter
1120- Migration script with rollback capability
1121- Zero-downtime deployment strategy
1122
1123**Note:** Currently out of scope - will be tackled separately when needed.
1124
1125---
1126
1127## Performance Considerations
1128
1129### Database Indexes
1130
1131All critical query patterns are indexed:
1132- **Threading queries**: `idx_comments_root`, `idx_comments_parent`
1133- **Sorting by score**: `idx_comments_parent_score`
1134- **User history**: `idx_comments_commenter`
1135- **Vote targeting**: `idx_comments_uri_active`
1136
1137### Denormalized Counts
1138
1139Vote counts and reply counts are denormalized for performance:
1140- Avoids `COUNT(*)` queries on large datasets
1141- Updated atomically with comment operations
1142- Indexed for fast sorting
1143
1144### Pagination Support
1145
1146All list queries support limit/offset pagination:
1147- `ListByRoot(ctx, rootURI, limit, offset)`
1148- `ListByParent(ctx, parentURI, limit, offset)`
1149- `ListByCommenter(ctx, commenterDID, limit, offset)`
1150
1151### N+1 Query Prevention
1152
1153**Problem Solved:** The initial implementation had a classic N+1 query problem where nested reply loading made separate database queries for each comment's children. For a post with 50 top-level comments and 3 levels of depth, this could result in ~1,551 queries.
1154
1155**Solution Implemented:** Batch loading strategy using window functions:
11561. Collect all parent URIs at each depth level
11572. Execute single batch query using `ListByParentsBatch()` with PostgreSQL window functions
11583. Group results by parent URI in memory
11594. Recursively process next level
1160
1161**Performance Improvement:**
1162- Old: 1 + N + (N × M) + (N × M × P) queries per request
1163- New: 1 query per depth level (max 4 queries for depth 3)
1164- Example with depth 3, 50 comments: 1,551 queries → 4 queries (99.7% reduction)
1165
1166**Implementation Details:**
1167```sql
1168-- Uses ROW_NUMBER() window function to limit per parent efficiently
1169WITH ranked_comments AS (
1170 SELECT *,
1171 ROW_NUMBER() OVER (
1172 PARTITION BY parent_uri
1173 ORDER BY hot_rank DESC
1174 ) as rn
1175 FROM comments
1176 WHERE parent_uri = ANY($1)
1177)
1178SELECT * FROM ranked_comments WHERE rn <= $2
1179```
1180
1181### Hot Rank Caching Strategy
1182
1183**Current Implementation:**
1184Hot rank is computed on-demand for every query using the Lemmy algorithm:
1185```sql
1186log(greatest(2, score + 2)) /
1187 power(((EXTRACT(EPOCH FROM (NOW() - created_at)) / 3600) + 2), 1.8)
1188```
1189
1190**Performance Impact:**
1191- Computed for every comment in every hot-sorted query
1192- PostgreSQL handles this efficiently for moderate loads (<1000 comments per post)
1193- No noticeable performance degradation in testing
1194
1195**Future Optimization (if needed):**
1196
1197If hot rank computation becomes a bottleneck at scale:
1198
11991. **Add cached column:**
1200```sql
1201ALTER TABLE comments ADD COLUMN hot_rank_cached NUMERIC;
1202CREATE INDEX idx_comments_parent_hot_rank_cached
1203 ON comments(parent_uri, hot_rank_cached DESC)
1204 WHERE deleted_at IS NULL;
1205```
1206
12072. **Background recomputation job:**
1208```go
1209// Run every 5-15 minutes
1210func (j *HotRankJob) UpdateHotRanks(ctx context.Context) error {
1211 query := `
1212 UPDATE comments
1213 SET hot_rank_cached = log(greatest(2, score + 2)) /
1214 power(((EXTRACT(EPOCH FROM (NOW() - created_at)) / 3600) + 2), 1.8)
1215 WHERE deleted_at IS NULL
1216 `
1217 _, err := j.db.ExecContext(ctx, query)
1218 return err
1219}
1220```
1221
12223. **Use cached value in queries:**
1223```sql
1224SELECT * FROM comments
1225WHERE parent_uri = $1
1226ORDER BY hot_rank_cached DESC, score DESC
1227```
1228
1229**When to implement:**
1230- Monitor query performance in production
1231- If p95 query latency > 200ms for hot-sorted queries
1232- If database CPU usage from hot rank computation > 20%
1233- Only optimize if measurements show actual bottleneck
1234
1235**Trade-offs:**
1236- **Cached approach:** Faster queries, but ranks update every 5-15 minutes (slightly stale)
1237- **On-demand approach:** Always fresh ranks, slightly higher query cost
1238- For comment discussions, 5-15 minute staleness is acceptable (comments age slowly)
1239
1240---
1241
1242## Conclusion
1243
1244The comment system has successfully completed **Phase 1 (Indexing)**, **Phase 2A (Query API)**, and **Phase 2B (Vote Integration)** with comprehensive production hardening, providing a production-ready threaded discussion system for Coves:
1245
1246✅ **Phase 1 Complete**: Full indexing infrastructure with Jetstream consumer
1247✅ **Phase 2A Complete**: Query API with hot ranking, threading, and pagination
1248✅ **Phase 2B Complete**: Vote integration with viewer state and URI parsing optimization
1249✅ **Production Hardened**: Two rounds of PR review fixes (Phase 2A + Phase 2B)
1250✅ **Fully Tested**:
1251 - 35 integration tests (indexing, query, voting)
1252 - 22 unit tests (94.3% coverage)
1253 - All tests passing ✅
1254✅ **Secure**:
1255 - Authentication validated at middleware layer
1256 - Input validation, parameterized queries
1257 - Security documentation added
1258✅ **Scalable**:
1259 - N+1 query prevention with batch loading (99.7% reduction)
1260 - URI parsing optimization (1,000-20,000x faster than DB queries)
1261 - Indexed queries, denormalized counts, cursor pagination
1262✅ **Data Integrity**:
1263 - Post comment count reconciliation
1264 - Atomic count updates
1265 - Out-of-order event handling
1266✅ **atProto Native**: User-owned records, Jetstream indexing, Bluesky patterns
1267
1268**Key Features Implemented:**
1269- Threaded comments with unlimited nesting
1270- Hot/top/new sorting with Lemmy algorithm
1271- Upvote/downvote on comments with atomic count updates
1272- Viewer vote state in authenticated queries
1273- Batch loading for nested replies and vote state
1274- Out-of-order Jetstream event handling with reconciliation
1275- Soft deletes preserving thread structure
1276
1277**Code Quality:**
1278- 94.3% unit test coverage on service layer
1279- Comprehensive integration test suite
1280- Production hardening from two PR review cycles
1281- Clear documentation and inline comments
1282- Consistent patterns across codebase
1283
1284**Next milestones:**
1285- Phase 2C: Complete post/user integration (display names, avatars, full records)
1286- Phase 3: Advanced features (moderation, notifications, search, edit history)
1287
1288The implementation provides a solid foundation for building rich threaded discussions in Coves while maintaining compatibility with the broader atProto ecosystem and following established patterns from platforms like Lemmy and Reddit.
1289
1290---
1291
1292## Appendix: Command Reference
1293
1294### Run Tests
1295
1296**Phase 1 - Indexing Tests:**
1297```bash
1298TEST_DATABASE_URL="postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable" \
1299 go test -v ./tests/integration/comment_consumer_test.go \
1300 ./tests/integration/user_test.go \
1301 ./tests/integration/helpers.go \
1302 -run "TestCommentConsumer" -timeout 60s
1303```
1304
1305**Phase 2A - Query API Tests:**
1306```bash
1307TEST_DATABASE_URL="postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable" \
1308 go test -v ./tests/integration/comment_query_test.go \
1309 ./tests/integration/user_test.go \
1310 ./tests/integration/helpers.go \
1311 -run "TestCommentQuery" -timeout 120s
1312```
1313
1314**Phase 2B - Voting Tests:**
1315```bash
1316TEST_DATABASE_URL="postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable" \
1317 go test -v ./tests/integration/ \
1318 -run "TestCommentVote" -timeout 60s
1319```
1320
1321**Unit Tests (Service Layer):**
1322```bash
1323# Run all unit tests
1324go test -v ./internal/core/comments/... -short
1325
1326# Run with coverage report
1327go test -cover ./internal/core/comments/...
1328
1329# Generate HTML coverage report
1330go test -coverprofile=coverage.out ./internal/core/comments/...
1331go tool cover -html=coverage.out
1332
1333# Run specific test category
1334go test -v ./internal/core/comments/... -run TestCommentService_GetComments
1335go test -v ./internal/core/comments/... -run TestCommentService_buildThreadViews
1336go test -v ./internal/core/comments/... -run TestValidateGetCommentsRequest
1337```
1338
1339**All Comment Tests (Integration + Unit):**
1340```bash
1341# Integration tests (requires database)
1342TEST_DATABASE_URL="postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable" \
1343 go test -v ./tests/integration/comment_*.go \
1344 ./tests/integration/user_test.go \
1345 ./tests/integration/helpers.go \
1346 -timeout 120s
1347
1348# Unit tests (no database)
1349go test -v ./internal/core/comments/... -short
1350```
1351
1352### Apply Migration
1353```bash
1354GOOSE_DRIVER=postgres \
1355GOOSE_DBSTRING="postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable" \
1356 goose -dir internal/db/migrations up
1357```
1358
1359### Build Server
1360```bash
1361go build ./cmd/server
1362```
1363
1364### Environment Variables
1365```bash
1366# Jetstream URL (optional, defaults to localhost:6008)
1367export COMMENT_JETSTREAM_URL="ws://localhost:6008/subscribe?wantedCollections=social.coves.feed.comment"
1368
1369# Database URL
1370export TEST_DATABASE_URL="postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable"
1371```
1372
1373---
1374
1375**Last Updated:** November 6, 2025
1376**Status:** ✅ Phase 1, 2A & 2B Complete - Production-Ready with Full PR Hardening
1377**Documentation:** Comprehensive implementation guide covering all phases, PR reviews, and production considerations