···

       
120
       
 
       
			id, uri, cid, rkey, commenter_did,

     

       
121
       
 
       
			root_uri, root_cid, parent_uri, parent_cid,

     

       
122
       
 
       
			content, content_facets, embed, content_labels, langs,

     

       
123
       
-
       
			created_at, indexed_at, deleted_at,

     

       
124
       
 
       
			upvote_count, downvote_count, score, reply_count

     

       
125
       
 
       
		FROM comments

     

       
126
       
 
       
		WHERE uri = $1

     
···

       
133
       
 
       
		&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       
134
       
 
       
		&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       
135
       
 
       
		&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       
136
       
-
       
		&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt,

     

       
137
       
 
       
		&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       
138
       
 
       
	)

     

       
139
       
 
       


     
···

       
152
       
 
       
// Delete soft-deletes a comment (sets deleted_at)

     

       
153
       
 
       
// Called by Jetstream consumer after comment is deleted from PDS

     

       
154
       
 
       
// Idempotent: Returns success if comment already deleted

     

       
0
       
 
       

     

       
155
       
 
       
func (r *postgresCommentRepo) Delete(ctx context.Context, uri string) error {

     

       
156
       
 
       
	query := `

     

       
157
       
 
       
		UPDATE comments

     
···

       
177
       
 
       
	return nil

     

       
178
       
 
       
}

     

       
179
       
 
       


     

       
180
       
-
       
// ListByRoot retrieves all active comments in a thread (flat)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
181
       
 
       
// Used for fetching entire comment threads on posts

     

       
0
       
 
       

     

       
182
       
 
       
func (r *postgresCommentRepo) ListByRoot(ctx context.Context, rootURI string, limit, offset int) ([]*comments.Comment, error) {

     

       
183
       
 
       
	query := `

     

       
184
       
 
       
		SELECT

     

       
185
       
 
       
			id, uri, cid, rkey, commenter_did,

     

       
186
       
 
       
			root_uri, root_cid, parent_uri, parent_cid,

     

       
187
       
 
       
			content, content_facets, embed, content_labels, langs,

     

       
188
       
-
       
			created_at, indexed_at, deleted_at,

     

       
189
       
 
       
			upvote_count, downvote_count, score, reply_count

     

       
190
       
 
       
		FROM comments

     

       
191
       
-
       
		WHERE root_uri = $1 AND deleted_at IS NULL

     

       
192
       
 
       
		ORDER BY created_at ASC

     

       
193
       
 
       
		LIMIT $2 OFFSET $3

     

       
194
       
 
       
	`

     
···

       
212
       
 
       
			&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       
213
       
 
       
			&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       
214
       
 
       
			&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       
215
       
-
       
			&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt,

     

       
216
       
 
       
			&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       
217
       
 
       
		)

     

       
218
       
 
       
		if err != nil {

     
···

       
230
       
 
       
	return result, nil

     

       
231
       
 
       
}

     

       
232
       
 
       


     

       
233
       
-
       
// ListByParent retrieves direct replies to a post or comment

     

       
234
       
 
       
// Used for building nested/threaded comment views

     

       
0
       
 
       

     

       
235
       
 
       
func (r *postgresCommentRepo) ListByParent(ctx context.Context, parentURI string, limit, offset int) ([]*comments.Comment, error) {

     

       
236
       
 
       
	query := `

     

       
237
       
 
       
		SELECT

     

       
238
       
 
       
			id, uri, cid, rkey, commenter_did,

     

       
239
       
 
       
			root_uri, root_cid, parent_uri, parent_cid,

     

       
240
       
 
       
			content, content_facets, embed, content_labels, langs,

     

       
241
       
-
       
			created_at, indexed_at, deleted_at,

     

       
242
       
 
       
			upvote_count, downvote_count, score, reply_count

     

       
243
       
 
       
		FROM comments

     

       
244
       
-
       
		WHERE parent_uri = $1 AND deleted_at IS NULL

     

       
245
       
 
       
		ORDER BY created_at ASC

     

       
246
       
 
       
		LIMIT $2 OFFSET $3

     

       
247
       
 
       
	`

     
···

       
265
       
 
       
			&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       
266
       
 
       
			&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       
267
       
 
       
			&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       
268
       
-
       
			&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt,

     

       
269
       
 
       
			&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       
270
       
 
       
		)

     

       
271
       
 
       
		if err != nil {

     
···

       
302
       
 
       
}

     

       
303
       
 
       


     

       
304
       
 
       
// ListByCommenter retrieves all active comments by a specific user

     

       
305
       
-
       
// Future: Used for user comment history

     

       
306
       
 
       
func (r *postgresCommentRepo) ListByCommenter(ctx context.Context, commenterDID string, limit, offset int) ([]*comments.Comment, error) {

     

       
307
       
 
       
	query := `

     

       
308
       
 
       
		SELECT

     

       
309
       
 
       
			id, uri, cid, rkey, commenter_did,

     

       
310
       
 
       
			root_uri, root_cid, parent_uri, parent_cid,

     

       
311
       
 
       
			content, content_facets, embed, content_labels, langs,

     

       
312
       
-
       
			created_at, indexed_at, deleted_at,

     

       
313
       
 
       
			upvote_count, downvote_count, score, reply_count

     

       
314
       
 
       
		FROM comments

     

       
315
       
 
       
		WHERE commenter_did = $1 AND deleted_at IS NULL

     
···

       
336
       
 
       
			&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       
337
       
 
       
			&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       
338
       
 
       
			&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       
339
       
-
       
			&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt,

     

       
340
       
 
       
			&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       
341
       
 
       
		)

     

       
342
       
 
       
		if err != nil {

     
···

       
391
       
 
       
			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       
392
       
 
       
			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       
393
       
 
       
			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       
394
       
-
       
			c.created_at, c.indexed_at, c.deleted_at,

     

       
395
       
 
       
			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       
396
       
 
       
			log(greatest(2, c.score + 2)) / power(((EXTRACT(EPOCH FROM (NOW() - c.created_at)) / 3600) + 2), 1.8) as hot_rank,

     

       
397
       
 
       
			COALESCE(u.handle, c.commenter_did) as author_handle

     
···

       
402
       
 
       
			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       
403
       
 
       
			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       
404
       
 
       
			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       
405
       
-
       
			c.created_at, c.indexed_at, c.deleted_at,

     

       
406
       
 
       
			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       
407
       
 
       
			NULL::numeric as hot_rank,

     

       
408
       
 
       
			COALESCE(u.handle, c.commenter_did) as author_handle

     
···

       
411
       
 
       


     

       
412
       
 
       
	// Build complete query with JOINs and filters

     

       
413
       
 
       
	// LEFT JOIN prevents data loss when user record hasn't been indexed yet (out-of-order Jetstream events)

     

       
0
       
 
       

     

       
414
       
 
       
	query := fmt.Sprintf(`

     

       
415
       
 
       
		%s

     

       
416
       
 
       
		LEFT JOIN users u ON c.commenter_did = u.did

     

       
417
       
-
       
		WHERE c.parent_uri = $1 AND c.deleted_at IS NULL

     

       
418
       
 
       
			%s

     

       
419
       
 
       
			%s

     

       
420
       
 
       
		ORDER BY %s

     
···

       
449
       
 
       
			&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       
450
       
 
       
			&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       
451
       
 
       
			&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       
452
       
-
       
			&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt,

     

       
453
       
 
       
			&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       
454
       
 
       
			&hotRank, &authorHandle,

     

       
455
       
 
       
		)

     
···

       
687
       
 
       


     

       
688
       
 
       
// GetByURIsBatch retrieves multiple comments by their AT-URIs in a single query

     

       
689
       
 
       
// Returns map[uri]*Comment for efficient lookups without N+1 queries

     

       
0
       
 
       

     

       
690
       
 
       
func (r *postgresCommentRepo) GetByURIsBatch(ctx context.Context, uris []string) (map[string]*comments.Comment, error) {

     

       
691
       
 
       
	if len(uris) == 0 {

     

       
692
       
 
       
		return make(map[string]*comments.Comment), nil

     
···

       
694
       
 
       


     

       
695
       
 
       
	// LEFT JOIN prevents data loss when user record hasn't been indexed yet (out-of-order Jetstream events)

     

       
696
       
 
       
	// COALESCE falls back to DID when handle is NULL (user not yet in users table)

     

       
0
       
 
       

     

       
697
       
 
       
	query := `

     

       
698
       
 
       
		SELECT

     

       
699
       
 
       
			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       
700
       
 
       
			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       
701
       
 
       
			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       
702
       
-
       
			c.created_at, c.indexed_at, c.deleted_at,

     

       
703
       
 
       
			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       
704
       
 
       
			COALESCE(u.handle, c.commenter_did) as author_handle

     

       
705
       
 
       
		FROM comments c

     

       
706
       
 
       
		LEFT JOIN users u ON c.commenter_did = u.did

     

       
707
       
-
       
		WHERE c.uri = ANY($1) AND c.deleted_at IS NULL

     

       
708
       
 
       
	`

     

       
709
       
 
       


     

       
710
       
 
       
	rows, err := r.db.QueryContext(ctx, query, pq.Array(uris))

     
···

       
727
       
 
       
			&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       
728
       
 
       
			&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       
729
       
 
       
			&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       
730
       
-
       
			&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt,

     

       
731
       
 
       
			&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       
732
       
 
       
			&authorHandle,

     

       
733
       
 
       
		)

     
···

       
769
       
 
       
			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       
770
       
 
       
			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       
771
       
 
       
			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       
772
       
-
       
			c.created_at, c.indexed_at, c.deleted_at,

     

       
773
       
 
       
			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       
774
       
 
       
			log(greatest(2, c.score + 2)) / power(((EXTRACT(EPOCH FROM (NOW() - c.created_at)) / 3600) + 2), 1.8) as hot_rank,

     

       
775
       
 
       
			COALESCE(u.handle, c.commenter_did) as author_handle`

     
···

       
780
       
 
       
			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       
781
       
 
       
			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       
782
       
 
       
			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       
783
       
-
       
			c.created_at, c.indexed_at, c.deleted_at,

     

       
784
       
 
       
			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       
785
       
 
       
			NULL::numeric as hot_rank,

     

       
786
       
 
       
			COALESCE(u.handle, c.commenter_did) as author_handle`

     
···

       
790
       
 
       
			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       
791
       
 
       
			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       
792
       
 
       
			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       
793
       
-
       
			c.created_at, c.indexed_at, c.deleted_at,

     

       
794
       
 
       
			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       
795
       
 
       
			NULL::numeric as hot_rank,

     

       
796
       
 
       
			COALESCE(u.handle, c.commenter_did) as author_handle`

     
···

       
801
       
 
       
			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       
802
       
 
       
			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       
803
       
 
       
			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       
804
       
-
       
			c.created_at, c.indexed_at, c.deleted_at,

     

       
805
       
 
       
			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       
806
       
 
       
			log(greatest(2, c.score + 2)) / power(((EXTRACT(EPOCH FROM (NOW() - c.created_at)) / 3600) + 2), 1.8) as hot_rank,

     

       
807
       
 
       
			COALESCE(u.handle, c.commenter_did) as author_handle`

     
···

       
812
       
 
       
	// Use window function to limit results per parent

     

       
813
       
 
       
	// This is more efficient than LIMIT in a subquery per parent

     

       
814
       
 
       
	// LEFT JOIN prevents data loss when user record hasn't been indexed yet (out-of-order Jetstream events)

     

       
0
       
 
       

     

       
815
       
 
       
	query := fmt.Sprintf(`

     

       
816
       
 
       
		WITH ranked_comments AS (

     

       
817
       
 
       
			SELECT

     
···

       
822
       
 
       
				) as rn

     

       
823
       
 
       
			FROM comments c

     

       
824
       
 
       
			LEFT JOIN users u ON c.commenter_did = u.did

     

       
825
       
-
       
			WHERE c.parent_uri = ANY($1) AND c.deleted_at IS NULL

     

       
826
       
 
       
		)

     

       
827
       
 
       
		SELECT

     

       
828
       
 
       
			id, uri, cid, rkey, commenter_did,

     

       
829
       
 
       
			root_uri, root_cid, parent_uri, parent_cid,

     

       
830
       
 
       
			content, content_facets, embed, content_labels, langs,

     

       
831
       
-
       
			created_at, indexed_at, deleted_at,

     

       
832
       
 
       
			upvote_count, downvote_count, score, reply_count,

     

       
833
       
 
       
			hot_rank, author_handle

     

       
834
       
 
       
		FROM ranked_comments

     
···

       
858
       
 
       
			&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       
859
       
 
       
			&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       
860
       
 
       
			&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       
861
       
-
       
			&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt,

     

       
862
       
 
       
			&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       
863
       
 
       
			&hotRank, &authorHandle,

     

       
864
       
 
       
		)

     

···

       
120
       
 
       
			id, uri, cid, rkey, commenter_did,

     

       
121
       
 
       
			root_uri, root_cid, parent_uri, parent_cid,

     

       
122
       
 
       
			content, content_facets, embed, content_labels, langs,

     

       
123
       
+
       
			created_at, indexed_at, deleted_at, deletion_reason, deleted_by,

     

       
124
       
 
       
			upvote_count, downvote_count, score, reply_count

     

       
125
       
 
       
		FROM comments

     

       
126
       
 
       
		WHERE uri = $1

     
···

       
133
       
 
       
		&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       
134
       
 
       
		&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       
135
       
 
       
		&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       
136
       
+
       
		&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt, &comment.DeletionReason, &comment.DeletedBy,

     

       
137
       
 
       
		&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       
138
       
 
       
	)

     

       
139
       
 
       


     
···

       
152
       
 
       
// Delete soft-deletes a comment (sets deleted_at)

     

       
153
       
 
       
// Called by Jetstream consumer after comment is deleted from PDS

     

       
154
       
 
       
// Idempotent: Returns success if comment already deleted

     

       
155
       
+
       
// Deprecated: Use SoftDeleteWithReason for new code to preserve thread structure

     

       
156
       
 
       
func (r *postgresCommentRepo) Delete(ctx context.Context, uri string) error {

     

       
157
       
 
       
	query := `

     

       
158
       
 
       
		UPDATE comments

     
···

       
178
       
 
       
	return nil

     

       
179
       
 
       
}

     

       
180
       
 
       


     

       
181
       
+
       
// SoftDeleteWithReason performs a soft delete that blanks content but preserves thread structure

     

       
182
       
+
       
// This allows deleted comments to appear as "[deleted]" placeholders in thread views

     

       
183
       
+
       
// Idempotent: Returns success if comment already deleted

     

       
184
       
+
       
// Validates that reason is a known deletion reason constant

     

       
185
       
+
       
func (r *postgresCommentRepo) SoftDeleteWithReason(ctx context.Context, uri, reason, deletedByDID string) error {

     

       
186
       
+
       
	// Validate deletion reason

     

       
187
       
+
       
	if reason != comments.DeletionReasonAuthor && reason != comments.DeletionReasonModerator {

     

       
188
       
+
       
		return fmt.Errorf("invalid deletion reason: %s", reason)

     

       
189
       
+
       
	}

     

       
190
       
+
       


     

       
191
       
+
       
	_, err := r.SoftDeleteWithReasonTx(ctx, nil, uri, reason, deletedByDID)

     

       
192
       
+
       
	return err

     

       
193
       
+
       
}

     

       
194
       
+
       


     

       
195
       
+
       
// SoftDeleteWithReasonTx performs a soft delete within an optional transaction

     

       
196
       
+
       
// If tx is nil, executes directly against the database

     

       
197
       
+
       
// Returns rows affected count for callers that need to check idempotency

     

       
198
       
+
       
// This method is used by both the repository and the Jetstream consumer

     

       
199
       
+
       
func (r *postgresCommentRepo) SoftDeleteWithReasonTx(ctx context.Context, tx *sql.Tx, uri, reason, deletedByDID string) (int64, error) {

     

       
200
       
+
       
	query := `

     

       
201
       
+
       
		UPDATE comments

     

       
202
       
+
       
		SET

     

       
203
       
+
       
			content = '',

     

       
204
       
+
       
			content_facets = NULL,

     

       
205
       
+
       
			embed = NULL,

     

       
206
       
+
       
			content_labels = NULL,

     

       
207
       
+
       
			deleted_at = NOW(),

     

       
208
       
+
       
			deletion_reason = $2,

     

       
209
       
+
       
			deleted_by = $3

     

       
210
       
+
       
		WHERE uri = $1 AND deleted_at IS NULL

     

       
211
       
+
       
	`

     

       
212
       
+
       


     

       
213
       
+
       
	var result sql.Result

     

       
214
       
+
       
	var err error

     

       
215
       
+
       


     

       
216
       
+
       
	if tx != nil {

     

       
217
       
+
       
		result, err = tx.ExecContext(ctx, query, uri, reason, deletedByDID)

     

       
218
       
+
       
	} else {

     

       
219
       
+
       
		result, err = r.db.ExecContext(ctx, query, uri, reason, deletedByDID)

     

       
220
       
+
       
	}

     

       
221
       
+
       


     

       
222
       
+
       
	if err != nil {

     

       
223
       
+
       
		return 0, fmt.Errorf("failed to soft delete comment: %w", err)

     

       
224
       
+
       
	}

     

       
225
       
+
       


     

       
226
       
+
       
	rowsAffected, err := result.RowsAffected()

     

       
227
       
+
       
	if err != nil {

     

       
228
       
+
       
		return 0, fmt.Errorf("failed to check delete result: %w", err)

     

       
229
       
+
       
	}

     

       
230
       
+
       


     

       
231
       
+
       
	return rowsAffected, nil

     

       
232
       
+
       
}

     

       
233
       
+
       


     

       
234
       
+
       
// ListByRoot retrieves all comments in a thread (flat), including deleted ones

     

       
235
       
 
       
// Used for fetching entire comment threads on posts

     

       
236
       
+
       
// Includes deleted comments to preserve thread structure (shown as "[deleted]" placeholders)

     

       
237
       
 
       
func (r *postgresCommentRepo) ListByRoot(ctx context.Context, rootURI string, limit, offset int) ([]*comments.Comment, error) {

     

       
238
       
 
       
	query := `

     

       
239
       
 
       
		SELECT

     

       
240
       
 
       
			id, uri, cid, rkey, commenter_did,

     

       
241
       
 
       
			root_uri, root_cid, parent_uri, parent_cid,

     

       
242
       
 
       
			content, content_facets, embed, content_labels, langs,

     

       
243
       
+
       
			created_at, indexed_at, deleted_at, deletion_reason, deleted_by,

     

       
244
       
 
       
			upvote_count, downvote_count, score, reply_count

     

       
245
       
 
       
		FROM comments

     

       
246
       
+
       
		WHERE root_uri = $1

     

       
247
       
 
       
		ORDER BY created_at ASC

     

       
248
       
 
       
		LIMIT $2 OFFSET $3

     

       
249
       
 
       
	`

     
···

       
267
       
 
       
			&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       
268
       
 
       
			&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       
269
       
 
       
			&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       
270
       
+
       
			&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt, &comment.DeletionReason, &comment.DeletedBy,

     

       
271
       
 
       
			&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       
272
       
 
       
		)

     

       
273
       
 
       
		if err != nil {

     
···

       
285
       
 
       
	return result, nil

     

       
286
       
 
       
}

     

       
287
       
 
       


     

       
288
       
+
       
// ListByParent retrieves direct replies to a post or comment, including deleted ones

     

       
289
       
 
       
// Used for building nested/threaded comment views

     

       
290
       
+
       
// Includes deleted comments to preserve thread structure (shown as "[deleted]" placeholders)

     

       
291
       
 
       
func (r *postgresCommentRepo) ListByParent(ctx context.Context, parentURI string, limit, offset int) ([]*comments.Comment, error) {

     

       
292
       
 
       
	query := `

     

       
293
       
 
       
		SELECT

     

       
294
       
 
       
			id, uri, cid, rkey, commenter_did,

     

       
295
       
 
       
			root_uri, root_cid, parent_uri, parent_cid,

     

       
296
       
 
       
			content, content_facets, embed, content_labels, langs,

     

       
297
       
+
       
			created_at, indexed_at, deleted_at, deletion_reason, deleted_by,

     

       
298
       
 
       
			upvote_count, downvote_count, score, reply_count

     

       
299
       
 
       
		FROM comments

     

       
300
       
+
       
		WHERE parent_uri = $1

     

       
301
       
 
       
		ORDER BY created_at ASC

     

       
302
       
 
       
		LIMIT $2 OFFSET $3

     

       
303
       
 
       
	`

     
···

       
321
       
 
       
			&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       
322
       
 
       
			&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       
323
       
 
       
			&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       
324
       
+
       
			&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt, &comment.DeletionReason, &comment.DeletedBy,

     

       
325
       
 
       
			&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       
326
       
 
       
		)

     

       
327
       
 
       
		if err != nil {

     
···

       
358
       
 
       
}

     

       
359
       
 
       


     

       
360
       
 
       
// ListByCommenter retrieves all active comments by a specific user

     

       
361
       
+
       
// Used for user comment history - filters out deleted comments

     

       
362
       
 
       
func (r *postgresCommentRepo) ListByCommenter(ctx context.Context, commenterDID string, limit, offset int) ([]*comments.Comment, error) {

     

       
363
       
 
       
	query := `

     

       
364
       
 
       
		SELECT

     

       
365
       
 
       
			id, uri, cid, rkey, commenter_did,

     

       
366
       
 
       
			root_uri, root_cid, parent_uri, parent_cid,

     

       
367
       
 
       
			content, content_facets, embed, content_labels, langs,

     

       
368
       
+
       
			created_at, indexed_at, deleted_at, deletion_reason, deleted_by,

     

       
369
       
 
       
			upvote_count, downvote_count, score, reply_count

     

       
370
       
 
       
		FROM comments

     

       
371
       
 
       
		WHERE commenter_did = $1 AND deleted_at IS NULL

     
···

       
392
       
 
       
			&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       
393
       
 
       
			&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       
394
       
 
       
			&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       
395
       
+
       
			&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt, &comment.DeletionReason, &comment.DeletedBy,

     

       
396
       
 
       
			&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       
397
       
 
       
		)

     

       
398
       
 
       
		if err != nil {

     
···

       
447
       
 
       
			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       
448
       
 
       
			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       
449
       
 
       
			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       
450
       
+
       
			c.created_at, c.indexed_at, c.deleted_at, c.deletion_reason, c.deleted_by,

     

       
451
       
 
       
			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       
452
       
 
       
			log(greatest(2, c.score + 2)) / power(((EXTRACT(EPOCH FROM (NOW() - c.created_at)) / 3600) + 2), 1.8) as hot_rank,

     

       
453
       
 
       
			COALESCE(u.handle, c.commenter_did) as author_handle

     
···

       
458
       
 
       
			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       
459
       
 
       
			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       
460
       
 
       
			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       
461
       
+
       
			c.created_at, c.indexed_at, c.deleted_at, c.deletion_reason, c.deleted_by,

     

       
462
       
 
       
			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       
463
       
 
       
			NULL::numeric as hot_rank,

     

       
464
       
 
       
			COALESCE(u.handle, c.commenter_did) as author_handle

     
···

       
467
       
 
       


     

       
468
       
 
       
	// Build complete query with JOINs and filters

     

       
469
       
 
       
	// LEFT JOIN prevents data loss when user record hasn't been indexed yet (out-of-order Jetstream events)

     

       
470
       
+
       
	// Includes deleted comments to preserve thread structure (shown as "[deleted]" placeholders)

     

       
471
       
 
       
	query := fmt.Sprintf(`

     

       
472
       
 
       
		%s

     

       
473
       
 
       
		LEFT JOIN users u ON c.commenter_did = u.did

     

       
474
       
+
       
		WHERE c.parent_uri = $1

     

       
475
       
 
       
			%s

     

       
476
       
 
       
			%s

     

       
477
       
 
       
		ORDER BY %s

     
···

       
506
       
 
       
			&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       
507
       
 
       
			&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       
508
       
 
       
			&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       
509
       
+
       
			&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt, &comment.DeletionReason, &comment.DeletedBy,

     

       
510
       
 
       
			&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       
511
       
 
       
			&hotRank, &authorHandle,

     

       
512
       
 
       
		)

     
···

       
744
       
 
       


     

       
745
       
 
       
// GetByURIsBatch retrieves multiple comments by their AT-URIs in a single query

     

       
746
       
 
       
// Returns map[uri]*Comment for efficient lookups without N+1 queries

     

       
747
       
+
       
// Includes deleted comments to preserve thread structure

     

       
748
       
 
       
func (r *postgresCommentRepo) GetByURIsBatch(ctx context.Context, uris []string) (map[string]*comments.Comment, error) {

     

       
749
       
 
       
	if len(uris) == 0 {

     

       
750
       
 
       
		return make(map[string]*comments.Comment), nil

     
···

       
752
       
 
       


     

       
753
       
 
       
	// LEFT JOIN prevents data loss when user record hasn't been indexed yet (out-of-order Jetstream events)

     

       
754
       
 
       
	// COALESCE falls back to DID when handle is NULL (user not yet in users table)

     

       
755
       
+
       
	// Includes deleted comments to preserve thread structure (shown as "[deleted]" placeholders)

     

       
756
       
 
       
	query := `

     

       
757
       
 
       
		SELECT

     

       
758
       
 
       
			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       
759
       
 
       
			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       
760
       
 
       
			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       
761
       
+
       
			c.created_at, c.indexed_at, c.deleted_at, c.deletion_reason, c.deleted_by,

     

       
762
       
 
       
			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       
763
       
 
       
			COALESCE(u.handle, c.commenter_did) as author_handle

     

       
764
       
 
       
		FROM comments c

     

       
765
       
 
       
		LEFT JOIN users u ON c.commenter_did = u.did

     

       
766
       
+
       
		WHERE c.uri = ANY($1)

     

       
767
       
 
       
	`

     

       
768
       
 
       


     

       
769
       
 
       
	rows, err := r.db.QueryContext(ctx, query, pq.Array(uris))

     
···

       
786
       
 
       
			&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       
787
       
 
       
			&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       
788
       
 
       
			&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       
789
       
+
       
			&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt, &comment.DeletionReason, &comment.DeletedBy,

     

       
790
       
 
       
			&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       
791
       
 
       
			&authorHandle,

     

       
792
       
 
       
		)

     
···

       
828
       
 
       
			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       
829
       
 
       
			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       
830
       
 
       
			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       
831
       
+
       
			c.created_at, c.indexed_at, c.deleted_at, c.deletion_reason, c.deleted_by,

     

       
832
       
 
       
			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       
833
       
 
       
			log(greatest(2, c.score + 2)) / power(((EXTRACT(EPOCH FROM (NOW() - c.created_at)) / 3600) + 2), 1.8) as hot_rank,

     

       
834
       
 
       
			COALESCE(u.handle, c.commenter_did) as author_handle`

     
···

       
839
       
 
       
			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       
840
       
 
       
			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       
841
       
 
       
			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       
842
       
+
       
			c.created_at, c.indexed_at, c.deleted_at, c.deletion_reason, c.deleted_by,

     

       
843
       
 
       
			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       
844
       
 
       
			NULL::numeric as hot_rank,

     

       
845
       
 
       
			COALESCE(u.handle, c.commenter_did) as author_handle`

     
···

       
849
       
 
       
			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       
850
       
 
       
			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       
851
       
 
       
			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       
852
       
+
       
			c.created_at, c.indexed_at, c.deleted_at, c.deletion_reason, c.deleted_by,

     

       
853
       
 
       
			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       
854
       
 
       
			NULL::numeric as hot_rank,

     

       
855
       
 
       
			COALESCE(u.handle, c.commenter_did) as author_handle`

     
···

       
860
       
 
       
			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       
861
       
 
       
			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       
862
       
 
       
			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       
863
       
+
       
			c.created_at, c.indexed_at, c.deleted_at, c.deletion_reason, c.deleted_by,

     

       
864
       
 
       
			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       
865
       
 
       
			log(greatest(2, c.score + 2)) / power(((EXTRACT(EPOCH FROM (NOW() - c.created_at)) / 3600) + 2), 1.8) as hot_rank,

     

       
866
       
 
       
			COALESCE(u.handle, c.commenter_did) as author_handle`

     
···

       
871
       
 
       
	// Use window function to limit results per parent

     

       
872
       
 
       
	// This is more efficient than LIMIT in a subquery per parent

     

       
873
       
 
       
	// LEFT JOIN prevents data loss when user record hasn't been indexed yet (out-of-order Jetstream events)

     

       
874
       
+
       
	// Includes deleted comments to preserve thread structure (shown as "[deleted]" placeholders)

     

       
875
       
 
       
	query := fmt.Sprintf(`

     

       
876
       
 
       
		WITH ranked_comments AS (

     

       
877
       
 
       
			SELECT

     
···

       
882
       
 
       
				) as rn

     

       
883
       
 
       
			FROM comments c

     

       
884
       
 
       
			LEFT JOIN users u ON c.commenter_did = u.did

     

       
885
       
+
       
			WHERE c.parent_uri = ANY($1)

     

       
886
       
 
       
		)

     

       
887
       
 
       
		SELECT

     

       
888
       
 
       
			id, uri, cid, rkey, commenter_did,

     

       
889
       
 
       
			root_uri, root_cid, parent_uri, parent_cid,

     

       
890
       
 
       
			content, content_facets, embed, content_labels, langs,

     

       
891
       
+
       
			created_at, indexed_at, deleted_at, deletion_reason, deleted_by,

     

       
892
       
 
       
			upvote_count, downvote_count, score, reply_count,

     

       
893
       
 
       
			hot_rank, author_handle

     

       
894
       
 
       
		FROM ranked_comments

     
···

       
918
       
 
       
			&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       
919
       
 
       
			&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       
920
       
 
       
			&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       
921
       
+
       
			&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt, &comment.DeletionReason, &comment.DeletedBy,

     

       
922
       
 
       
			&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       
923
       
 
       
			&hotRank, &authorHandle,

     

       
924
       
 
       
		)