commit 005a633f30a9f0d0a6414ae2f8a050534c541ac6 · bretton.dev/coves

+22

internal/core/comments/interfaces.go

···

       42
       42
        
       	// ListByCommenter retrieves all comments by a specific user

     

       43
       43
        
       	// Future: Used for user comment history

     

       44
       44
        
       	ListByCommenter(ctx context.Context, commenterDID string, limit, offset int) ([]*Comment, error)

     

       45
       45
       +
       

     

       46
       46
       +
       	// ListByParentWithHotRank retrieves direct replies to a post or comment with sorting and pagination

     

       47
       47
       +
       	// Supports hot, top, and new sorting with cursor-based pagination

     

       48
       48
       +
       	// Returns comments with author info hydrated and next page cursor

     

       49
       49
       +
       	ListByParentWithHotRank(

     

       50
       50
       +
       		ctx context.Context,

     

       51
       51
       +
       		parentURI string,

     

       52
       52
       +
       		sort string, // "hot", "top", "new"

     

       53
       53
       +
       		timeframe string, // "hour", "day", "week", "month", "year", "all" (for "top" only)

     

       54
       54
       +
       		limit int,

     

       55
       55
       +
       		cursor *string,

     

       56
       56
       +
       	) ([]*Comment, *string, error)

     

       57
       57
       +
       

     

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

     

       59
       59
       +
       	// Returns map[uri]*Comment for efficient lookups

     

       60
       60
       +
       	// Used for hydrating comment threads without N+1 queries

     

       61
       61
       +
       	GetByURIsBatch(ctx context.Context, uris []string) (map[string]*Comment, error)

     

       62
       62
       +
       

     

       63
       63
       +
       	// GetVoteStateForComments retrieves the viewer's votes on a batch of comments

     

       64
       64
       +
       	// Returns map[commentURI]*Vote for efficient lookups

     

       65
       65
       +
       	// Future: Used when votes table is implemented

     

       66
       66
       +
       	GetVoteStateForComments(ctx context.Context, viewerDID string, commentURIs []string) (map[string]interface{}, error)

     

       45
       67
        
       }

+443

internal/db/postgres/comment_repo.go

···

       4
       4
        
       	"Coves/internal/core/comments"

     

       5
       5
        
       	"context"

     

       6
       6
        
       	"database/sql"

     

       7
       7
       +
       	"encoding/base64"

     

       7
       8
        
       	"fmt"

     

       8
       9
        
       	"log"

     

       9
       10
        
       	"strings"

     
···

       352
       353
        
       

     

       353
       354
        
       	return result, nil

     

       354
       355
        
       }

     

       356
       356
       +
       // ListByParentWithHotRank retrieves direct replies to a post or comment with sorting and pagination

     

       357
       357
       +
       // Supports three sort modes: hot (Lemmy algorithm), top (by score + timeframe), and new (by created_at)

     

       358
       358
       +
       // Uses cursor-based pagination with composite keys for consistent ordering

     

       359
       359
       +
       // Hydrates author info (handle, display_name, avatar) via JOIN with users table

     

       360
       360
       +
       func (r *postgresCommentRepo) ListByParentWithHotRank(

     

       361
       361
       +
       	ctx context.Context,

     

       362
       362
       +
       	parentURI string,

     

       363
       363
       +
       	sort string,

     

       364
       364
       +
       	timeframe string,

     

       365
       365
       +
       	limit int,

     

       366
       366
       +
       	cursor *string,

     

       367
       367
       +
       ) ([]*comments.Comment, *string, error) {

     

       368
       368
       +
       	// Build ORDER BY clause and time filter based on sort type

     

       369
       369
       +
       	orderBy, timeFilter := r.buildCommentSortClause(sort, timeframe)

     

       370
       370
       +
       

     

       371
       371
       +
       	// Parse cursor for pagination

     

       372
       372
       +
       	cursorFilter, cursorValues, err := r.parseCommentCursor(cursor, sort)

     

       373
       373
       +
       	if err != nil {

     

       374
       374
       +
       		return nil, nil, fmt.Errorf("invalid cursor: %w", err)

     

       375
       375
       +
       	}

     

       376
       376
       +
       

     

       377
       377
       +
       	// Build SELECT clause - compute hot_rank for "hot" sort

     

       378
       378
       +
       	// Hot rank formula (Lemmy algorithm):

     

       379
       379
       +
       	// log(greatest(2, score + 2)) / power(((EXTRACT(EPOCH FROM (NOW() - created_at)) / 3600) + 2), 1.8)

     

       380
       380
       +
       	//

     

       381
       381
       +
       	// This formula:

     

       382
       382
       +
       	// - Gives logarithmic weight to score (prevents high-score dominance)

     

       383
       383
       +
       	// - Decays over time with power 1.8 (faster than linear, slower than quadratic)

     

       384
       384
       +
       	// - Uses hours as time unit (3600 seconds)

     

       385
       385
       +
       	// - Adds constants to prevent division by zero and ensure positive values

     

       386
       386
       +
       	var selectClause string

     

       387
       387
       +
       	if sort == "hot" {

     

       388
       388
       +
       		selectClause = `

     

       389
       389
       +
       		SELECT

     

       390
       390
       +
       			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       391
       391
       +
       			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       392
       392
       +
       			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       393
       393
       +
       			c.created_at, c.indexed_at, c.deleted_at,

     

       394
       394
       +
       			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

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

     

       396
       396
       +
       			u.handle as author_handle

     

       397
       397
       +
       		FROM comments c`

     

       398
       398
       +
       	} else {

     

       399
       399
       +
       		selectClause = `

     

       400
       400
       +
       		SELECT

     

       401
       401
       +
       			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       402
       402
       +
       			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       403
       403
       +
       			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       404
       404
       +
       			c.created_at, c.indexed_at, c.deleted_at,

     

       405
       405
       +
       			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       406
       406
       +
       			NULL::numeric as hot_rank,

     

       407
       407
       +
       			u.handle as author_handle

     

       408
       408
       +
       		FROM comments c`

     

       409
       409
       +
       	}

     

       410
       410
       +
       

     

       411
       411
       +
       	// Build complete query with JOINs and filters

     

       412
       412
       +
       	query := fmt.Sprintf(`

     

       413
       413
       +
       		%s

     

       414
       414
       +
       		INNER JOIN users u ON c.commenter_did = u.did

     

       415
       415
       +
       		WHERE c.parent_uri = $1 AND c.deleted_at IS NULL

     

       416
       416
       +
       			%s

     

       417
       417
       +
       			%s

     

       418
       418
       +
       		ORDER BY %s

     

       419
       419
       +
       		LIMIT $2

     

       420
       420
       +
       	`, selectClause, timeFilter, cursorFilter, orderBy)

     

       421
       421
       +
       

     

       422
       422
       +
       	// Prepare query arguments

     

       423
       423
       +
       	args := []interface{}{parentURI, limit + 1} // +1 to detect next page

     

       424
       424
       +
       	args = append(args, cursorValues...)

     

       425
       425
       +
       

     

       426
       426
       +
       	// Execute query

     

       427
       427
       +
       	rows, err := r.db.QueryContext(ctx, query, args...)

     

       428
       428
       +
       	if err != nil {

     

       429
       429
       +
       		return nil, nil, fmt.Errorf("failed to query comments with hot rank: %w", err)

     

       430
       430
       +
       	}

     

       431
       431
       +
       	defer func() {

     

       432
       432
       +
       		if err := rows.Close(); err != nil {

     

       433
       433
       +
       			log.Printf("Failed to close rows: %v", err)

     

       434
       434
       +
       		}

     

       435
       435
       +
       	}()

     

       436
       436
       +
       

     

       437
       437
       +
       	// Scan results

     

       438
       438
       +
       	var result []*comments.Comment

     

       439
       439
       +
       	var hotRanks []float64

     

       440
       440
       +
       	for rows.Next() {

     

       441
       441
       +
       		var comment comments.Comment

     

       442
       442
       +
       		var langs pq.StringArray

     

       443
       443
       +
       		var hotRank sql.NullFloat64

     

       444
       444
       +
       		var authorHandle string

     

       445
       445
       +
       

     

       446
       446
       +
       		err := rows.Scan(

     

       447
       447
       +
       			&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       448
       448
       +
       			&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       449
       449
       +
       			&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       450
       450
       +
       			&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt,

     

       451
       451
       +
       			&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       452
       452
       +
       			&hotRank, &authorHandle,

     

       453
       453
       +
       		)

     

       454
       454
       +
       		if err != nil {

     

       455
       455
       +
       			return nil, nil, fmt.Errorf("failed to scan comment: %w", err)

     

       456
       456
       +
       		}

     

       457
       457
       +
       

     

       458
       458
       +
       		comment.Langs = langs

     

       459
       459
       +
       		comment.CommenterHandle = authorHandle

     

       460
       460
       +
       

     

       461
       461
       +
       		// Store hot_rank for cursor building

     

       462
       462
       +
       		hotRankValue := 0.0

     

       463
       463
       +
       		if hotRank.Valid {

     

       464
       464
       +
       			hotRankValue = hotRank.Float64

     

       465
       465
       +
       		}

     

       466
       466
       +
       		hotRanks = append(hotRanks, hotRankValue)

     

       467
       467
       +
       

     

       468
       468
       +
       		result = append(result, &comment)

     

       469
       469
       +
       	}

     

       470
       470
       +
       

     

       471
       471
       +
       	if err = rows.Err(); err != nil {

     

       472
       472
       +
       		return nil, nil, fmt.Errorf("error iterating comments: %w", err)

     

       473
       473
       +
       	}

     

       474
       474
       +
       

     

       475
       475
       +
       	// Handle pagination cursor

     

       476
       476
       +
       	var nextCursor *string

     

       477
       477
       +
       	if len(result) > limit && limit > 0 {

     

       478
       478
       +
       		result = result[:limit]

     

       479
       479
       +
       		hotRanks = hotRanks[:limit]

     

       480
       480
       +
       		lastComment := result[len(result)-1]

     

       481
       481
       +
       		lastHotRank := hotRanks[len(hotRanks)-1]

     

       482
       482
       +
       		cursorStr := r.buildCommentCursor(lastComment, sort, lastHotRank)

     

       483
       483
       +
       		nextCursor = &cursorStr

     

       484
       484
       +
       	}

     

       485
       485
       +
       

     

       486
       486
       +
       	return result, nextCursor, nil

     

       487
       487
       +
       }

     

       488
       488
       +
       

     

       489
       489
       +
       // buildCommentSortClause returns the ORDER BY SQL and optional time filter

     

       490
       490
       +
       func (r *postgresCommentRepo) buildCommentSortClause(sort, timeframe string) (string, string) {

     

       491
       491
       +
       	var orderBy string

     

       492
       492
       +
       	switch sort {

     

       493
       493
       +
       	case "hot":

     

       494
       494
       +
       		// Hot rank DESC, then score DESC as tiebreaker, then created_at DESC, then uri DESC

     

       495
       495
       +
       		orderBy = `hot_rank DESC, c.score DESC, c.created_at DESC, c.uri DESC`

     

       496
       496
       +
       	case "top":

     

       497
       497
       +
       		// Score DESC, then created_at DESC, then uri DESC

     

       498
       498
       +
       		orderBy = `c.score DESC, c.created_at DESC, c.uri DESC`

     

       499
       499
       +
       	case "new":

     

       500
       500
       +
       		// Created at DESC, then uri DESC

     

       501
       501
       +
       		orderBy = `c.created_at DESC, c.uri DESC`

     

       502
       502
       +
       	default:

     

       503
       503
       +
       		// Default to hot

     

       504
       504
       +
       		orderBy = `hot_rank DESC, c.score DESC, c.created_at DESC, c.uri DESC`

     

       505
       505
       +
       	}

     

       506
       506
       +
       

     

       507
       507
       +
       	// Add time filter for "top" sort

     

       508
       508
       +
       	var timeFilter string

     

       509
       509
       +
       	if sort == "top" {

     

       510
       510
       +
       		timeFilter = r.buildCommentTimeFilter(timeframe)

     

       511
       511
       +
       	}

     

       512
       512
       +
       

     

       513
       513
       +
       	return orderBy, timeFilter

     

       514
       514
       +
       }

     

       515
       515
       +
       

     

       516
       516
       +
       // buildCommentTimeFilter returns SQL filter for timeframe

     

       517
       517
       +
       func (r *postgresCommentRepo) buildCommentTimeFilter(timeframe string) string {

     

       518
       518
       +
       	if timeframe == "" || timeframe == "all" {

     

       519
       519
       +
       		return ""

     

       520
       520
       +
       	}

     

       521
       521
       +
       

     

       522
       522
       +
       	var interval string

     

       523
       523
       +
       	switch timeframe {

     

       524
       524
       +
       	case "hour":

     

       525
       525
       +
       		interval = "1 hour"

     

       526
       526
       +
       	case "day":

     

       527
       527
       +
       		interval = "1 day"

     

       528
       528
       +
       	case "week":

     

       529
       529
       +
       		interval = "7 days"

     

       530
       530
       +
       	case "month":

     

       531
       531
       +
       		interval = "30 days"

     

       532
       532
       +
       	case "year":

     

       533
       533
       +
       		interval = "1 year"

     

       534
       534
       +
       	default:

     

       535
       535
       +
       		return ""

     

       536
       536
       +
       	}

     

       537
       537
       +
       

     

       538
       538
       +
       	return fmt.Sprintf("AND c.created_at >= NOW() - INTERVAL '%s'", interval)

     

       539
       539
       +
       }

     

       540
       540
       +
       

     

       541
       541
       +
       // parseCommentCursor decodes pagination cursor for comments

     

       542
       542
       +
       func (r *postgresCommentRepo) parseCommentCursor(cursor *string, sort string) (string, []interface{}, error) {

     

       543
       543
       +
       	if cursor == nil || *cursor == "" {

     

       544
       544
       +
       		return "", nil, nil

     

       545
       545
       +
       	}

     

       546
       546
       +
       

     

       547
       547
       +
       	// Decode base64 cursor

     

       548
       548
       +
       	decoded, err := base64.URLEncoding.DecodeString(*cursor)

     

       549
       549
       +
       	if err != nil {

     

       550
       550
       +
       		return "", nil, fmt.Errorf("invalid cursor encoding")

     

       551
       551
       +
       	}

     

       552
       552
       +
       

     

       553
       553
       +
       	// Parse cursor based on sort type using | delimiter

     

       554
       554
       +
       	// Format: hotRank|score|createdAt|uri (for hot)

     

       555
       555
       +
       	//         score|createdAt|uri (for top)

     

       556
       556
       +
       	//         createdAt|uri (for new)

     

       557
       557
       +
       	parts := strings.Split(string(decoded), "|")

     

       558
       558
       +
       

     

       559
       559
       +
       	switch sort {

     

       560
       560
       +
       	case "new":

     

       561
       561
       +
       		// Cursor format: createdAt|uri

     

       562
       562
       +
       		if len(parts) != 2 {

     

       563
       563
       +
       			return "", nil, fmt.Errorf("invalid cursor format for new sort")

     

       564
       564
       +
       		}

     

       565
       565
       +
       

     

       566
       566
       +
       		createdAt := parts[0]

     

       567
       567
       +
       		uri := parts[1]

     

       568
       568
       +
       

     

       569
       569
       +
       		// Validate AT-URI format

     

       570
       570
       +
       		if !strings.HasPrefix(uri, "at://") {

     

       571
       571
       +
       			return "", nil, fmt.Errorf("invalid cursor URI")

     

       572
       572
       +
       		}

     

       573
       573
       +
       

     

       574
       574
       +
       		filter := `AND (c.created_at < $3 OR (c.created_at = $3 AND c.uri < $4))`

     

       575
       575
       +
       		return filter, []interface{}{createdAt, uri}, nil

     

       576
       576
       +
       

     

       577
       577
       +
       	case "top":

     

       578
       578
       +
       		// Cursor format: score|createdAt|uri

     

       579
       579
       +
       		if len(parts) != 3 {

     

       580
       580
       +
       			return "", nil, fmt.Errorf("invalid cursor format for top sort")

     

       581
       581
       +
       		}

     

       582
       582
       +
       

     

       583
       583
       +
       		scoreStr := parts[0]

     

       584
       584
       +
       		createdAt := parts[1]

     

       585
       585
       +
       		uri := parts[2]

     

       586
       586
       +
       

     

       587
       587
       +
       		// Parse score as integer

     

       588
       588
       +
       		score := 0

     

       589
       589
       +
       		if _, err := fmt.Sscanf(scoreStr, "%d", &score); err != nil {

     

       590
       590
       +
       			return "", nil, fmt.Errorf("invalid cursor score")

     

       591
       591
       +
       		}

     

       592
       592
       +
       

     

       593
       593
       +
       		// Validate AT-URI format

     

       594
       594
       +
       		if !strings.HasPrefix(uri, "at://") {

     

       595
       595
       +
       			return "", nil, fmt.Errorf("invalid cursor URI")

     

       596
       596
       +
       		}

     

       597
       597
       +
       

     

       598
       598
       +
       		filter := `AND (c.score < $3 OR (c.score = $3 AND c.created_at < $4) OR (c.score = $3 AND c.created_at = $4 AND c.uri < $5))`

     

       599
       599
       +
       		return filter, []interface{}{score, createdAt, uri}, nil

     

       600
       600
       +
       

     

       601
       601
       +
       	case "hot":

     

       602
       602
       +
       		// Cursor format: hotRank|score|createdAt|uri

     

       603
       603
       +
       		if len(parts) != 4 {

     

       604
       604
       +
       			return "", nil, fmt.Errorf("invalid cursor format for hot sort")

     

       605
       605
       +
       		}

     

       606
       606
       +
       

     

       607
       607
       +
       		hotRankStr := parts[0]

     

       608
       608
       +
       		scoreStr := parts[1]

     

       609
       609
       +
       		createdAt := parts[2]

     

       610
       610
       +
       		uri := parts[3]

     

       611
       611
       +
       

     

       612
       612
       +
       		// Parse hot_rank as float

     

       613
       613
       +
       		hotRank := 0.0

     

       614
       614
       +
       		if _, err := fmt.Sscanf(hotRankStr, "%f", &hotRank); err != nil {

     

       615
       615
       +
       			return "", nil, fmt.Errorf("invalid cursor hot rank")

     

       616
       616
       +
       		}

     

       617
       617
       +
       

     

       618
       618
       +
       		// Parse score as integer

     

       619
       619
       +
       		score := 0

     

       620
       620
       +
       		if _, err := fmt.Sscanf(scoreStr, "%d", &score); err != nil {

     

       621
       621
       +
       			return "", nil, fmt.Errorf("invalid cursor score")

     

       622
       622
       +
       		}

     

       623
       623
       +
       

     

       624
       624
       +
       		// Validate AT-URI format

     

       625
       625
       +
       		if !strings.HasPrefix(uri, "at://") {

     

       626
       626
       +
       			return "", nil, fmt.Errorf("invalid cursor URI")

     

       627
       627
       +
       		}

     

       628
       628
       +
       

     

       629
       629
       +
       		// Use computed hot_rank expression in comparison

     

       630
       630
       +
       		hotRankExpr := `log(greatest(2, c.score + 2)) / power(((EXTRACT(EPOCH FROM (NOW() - c.created_at)) / 3600) + 2), 1.8)`

     

       631
       631
       +
       		filter := fmt.Sprintf(`AND ((%s < $3 OR (%s = $3 AND c.score < $4) OR (%s = $3 AND c.score = $4 AND c.created_at < $5) OR (%s = $3 AND c.score = $4 AND c.created_at = $5 AND c.uri < $6)) AND c.uri != $7)`,

     

       632
       632
       +
       			hotRankExpr, hotRankExpr, hotRankExpr, hotRankExpr)

     

       633
       633
       +
       		return filter, []interface{}{hotRank, score, createdAt, uri, uri}, nil

     

       634
       634
       +
       

     

       635
       635
       +
       	default:

     

       636
       636
       +
       		return "", nil, nil

     

       637
       637
       +
       	}

     

       638
       638
       +
       }

     

       639
       639
       +
       

     

       640
       640
       +
       // buildCommentCursor creates pagination cursor from last comment

     

       641
       641
       +
       func (r *postgresCommentRepo) buildCommentCursor(comment *comments.Comment, sort string, hotRank float64) string {

     

       642
       642
       +
       	var cursorStr string

     

       643
       643
       +
       	const delimiter = "|"

     

       644
       644
       +
       

     

       645
       645
       +
       	switch sort {

     

       646
       646
       +
       	case "new":

     

       647
       647
       +
       		// Format: createdAt|uri

     

       648
       648
       +
       		cursorStr = fmt.Sprintf("%s%s%s",

     

       649
       649
       +
       			comment.CreatedAt.Format("2006-01-02T15:04:05.999999999Z07:00"),

     

       650
       650
       +
       			delimiter,

     

       651
       651
       +
       			comment.URI)

     

       652
       652
       +
       

     

       653
       653
       +
       	case "top":

     

       654
       654
       +
       		// Format: score|createdAt|uri

     

       655
       655
       +
       		cursorStr = fmt.Sprintf("%d%s%s%s%s",

     

       656
       656
       +
       			comment.Score,

     

       657
       657
       +
       			delimiter,

     

       658
       658
       +
       			comment.CreatedAt.Format("2006-01-02T15:04:05.999999999Z07:00"),

     

       659
       659
       +
       			delimiter,

     

       660
       660
       +
       			comment.URI)

     

       661
       661
       +
       

     

       662
       662
       +
       	case "hot":

     

       663
       663
       +
       		// Format: hotRank|score|createdAt|uri

     

       664
       664
       +
       		cursorStr = fmt.Sprintf("%f%s%d%s%s%s%s",

     

       665
       665
       +
       			hotRank,

     

       666
       666
       +
       			delimiter,

     

       667
       667
       +
       			comment.Score,

     

       668
       668
       +
       			delimiter,

     

       669
       669
       +
       			comment.CreatedAt.Format("2006-01-02T15:04:05.999999999Z07:00"),

     

       670
       670
       +
       			delimiter,

     

       671
       671
       +
       			comment.URI)

     

       672
       672
       +
       

     

       673
       673
       +
       	default:

     

       674
       674
       +
       		cursorStr = comment.URI

     

       675
       675
       +
       	}

     

       676
       676
       +
       

     

       677
       677
       +
       	return base64.URLEncoding.EncodeToString([]byte(cursorStr))

     

       678
       678
       +
       }

     

       679
       679
       +
       

     

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

     

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

     

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

     

       683
       683
       +
       	if len(uris) == 0 {

     

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

     

       685
       685
       +
       	}

     

       686
       686
       +
       

     

       687
       687
       +
       	query := `

     

       688
       688
       +
       		SELECT

     

       689
       689
       +
       			c.id, c.uri, c.cid, c.rkey, c.commenter_did,

     

       690
       690
       +
       			c.root_uri, c.root_cid, c.parent_uri, c.parent_cid,

     

       691
       691
       +
       			c.content, c.content_facets, c.embed, c.content_labels, c.langs,

     

       692
       692
       +
       			c.created_at, c.indexed_at, c.deleted_at,

     

       693
       693
       +
       			c.upvote_count, c.downvote_count, c.score, c.reply_count,

     

       694
       694
       +
       			u.handle as author_handle

     

       695
       695
       +
       		FROM comments c

     

       696
       696
       +
       		INNER JOIN users u ON c.commenter_did = u.did

     

       697
       697
       +
       		WHERE c.uri = ANY($1) AND c.deleted_at IS NULL

     

       698
       698
       +
       	`

     

       699
       699
       +
       

     

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

     

       701
       701
       +
       	if err != nil {

     

       702
       702
       +
       		return nil, fmt.Errorf("failed to batch get comments by URIs: %w", err)

     

       703
       703
       +
       	}

     

       704
       704
       +
       	defer func() {

     

       705
       705
       +
       		if err := rows.Close(); err != nil {

     

       706
       706
       +
       			log.Printf("Failed to close rows: %v", err)

     

       707
       707
       +
       		}

     

       708
       708
       +
       	}()

     

       709
       709
       +
       

     

       710
       710
       +
       	result := make(map[string]*comments.Comment)

     

       711
       711
       +
       	for rows.Next() {

     

       712
       712
       +
       		var comment comments.Comment

     

       713
       713
       +
       		var langs pq.StringArray

     

       714
       714
       +
       		var authorHandle string

     

       715
       715
       +
       

     

       716
       716
       +
       		err := rows.Scan(

     

       717
       717
       +
       			&comment.ID, &comment.URI, &comment.CID, &comment.RKey, &comment.CommenterDID,

     

       718
       718
       +
       			&comment.RootURI, &comment.RootCID, &comment.ParentURI, &comment.ParentCID,

     

       719
       719
       +
       			&comment.Content, &comment.ContentFacets, &comment.Embed, &comment.ContentLabels, &langs,

     

       720
       720
       +
       			&comment.CreatedAt, &comment.IndexedAt, &comment.DeletedAt,

     

       721
       721
       +
       			&comment.UpvoteCount, &comment.DownvoteCount, &comment.Score, &comment.ReplyCount,

     

       722
       722
       +
       			&authorHandle,

     

       723
       723
       +
       		)

     

       724
       724
       +
       		if err != nil {

     

       725
       725
       +
       			return nil, fmt.Errorf("failed to scan comment: %w", err)

     

       726
       726
       +
       		}

     

       727
       727
       +
       

     

       728
       728
       +
       		comment.Langs = langs

     

       729
       729
       +
       		result[comment.URI] = &comment

     

       730
       730
       +
       	}

     

       731
       731
       +
       

     

       732
       732
       +
       	if err = rows.Err(); err != nil {

     

       733
       733
       +
       		return nil, fmt.Errorf("error iterating comments: %w", err)

     

       734
       734
       +
       	}

     

       735
       735
       +
       

     

       736
       736
       +
       	return result, nil

     

       737
       737
       +
       }

     

       738
       738
       +
       

     

       739
       739
       +
       // GetVoteStateForComments retrieves the viewer's votes on a batch of comments

     

       740
       740
       +
       // Returns map[commentURI]*Vote for efficient lookups

     

       741
       741
       +
       // Note: This implementation is prepared for when the votes table indexing is implemented

     

       742
       742
       +
       // Currently returns an empty map as votes may not be fully indexed yet

     

       743
       743
       +
       func (r *postgresCommentRepo) GetVoteStateForComments(ctx context.Context, viewerDID string, commentURIs []string) (map[string]interface{}, error) {

     

       744
       744
       +
       	if len(commentURIs) == 0 || viewerDID == "" {

     

       745
       745
       +
       		return make(map[string]interface{}), nil

     

       746
       746
       +
       	}

     

       747
       747
       +
       

     

       748
       748
       +
       	// Query votes table for viewer's votes on these comments

     

       749
       749
       +
       	// Note: This assumes votes table exists and is being indexed

     

       750
       750
       +
       	// If votes table doesn't exist yet, this query will fail gracefully

     

       751
       751
       +
       	query := `

     

       752
       752
       +
       		SELECT subject_uri, direction, uri, cid, created_at

     

       753
       753
       +
       		FROM votes

     

       754
       754
       +
       		WHERE voter_did = $1 AND subject_uri = ANY($2) AND deleted_at IS NULL

     

       755
       755
       +
       	`

     

       756
       756
       +
       

     

       757
       757
       +
       	rows, err := r.db.QueryContext(ctx, query, viewerDID, pq.Array(commentURIs))

     

       758
       758
       +
       	if err != nil {

     

       759
       759
       +
       		// If votes table doesn't exist yet, return empty map instead of error

     

       760
       760
       +
       		// This allows the API to work before votes indexing is fully implemented

     

       761
       761
       +
       		if strings.Contains(err.Error(), "does not exist") {

     

       762
       762
       +
       			return make(map[string]interface{}), nil

     

       763
       763
       +
       		}

     

       764
       764
       +
       		return nil, fmt.Errorf("failed to get vote state for comments: %w", err)

     

       765
       765
       +
       	}

     

       766
       766
       +
       	defer func() {

     

       767
       767
       +
       		if err := rows.Close(); err != nil {

     

       768
       768
       +
       			log.Printf("Failed to close rows: %v", err)

     

       769
       769
       +
       		}

     

       770
       770
       +
       	}()

     

       771
       771
       +
       

     

       772
       772
       +
       	// Build result map with vote information

     

       773
       773
       +
       	result := make(map[string]interface{})

     

       774
       774
       +
       	for rows.Next() {

     

       775
       775
       +
       		var subjectURI, direction, uri, cid string

     

       776
       776
       +
       		var createdAt sql.NullTime

     

       777
       777
       +
       

     

       778
       778
       +
       		err := rows.Scan(&subjectURI, &direction, &uri, &cid, &createdAt)

     

       779
       779
       +
       		if err != nil {

     

       780
       780
       +
       			return nil, fmt.Errorf("failed to scan vote: %w", err)

     

       781
       781
       +
       		}

     

       782
       782
       +
       

     

       783
       783
       +
       		// Store vote info as a simple map (can be enhanced later with proper Vote struct)

     

       784
       784
       +
       		result[subjectURI] = map[string]interface{}{

     

       785
       785
       +
       			"direction": direction,

     

       786
       786
       +
       			"uri":       uri,

     

       787
       787
       +
       			"cid":       cid,

     

       788
       788
       +
       			"createdAt": createdAt.Time,

     

       789
       789
       +
       		}

     

       790
       790
       +
       	}

     

       791
       791
       +
       

     

       792
       792
       +
       	if err = rows.Err(); err != nil {

     

       793
       793
       +
       		return nil, fmt.Errorf("error iterating votes: %w", err)

     

       794
       794
       +
       	}

     

       795
       795
       +
       

     

       796
       796
       +
       	return result, nil

     

       797
       797
       +
       }