commit 66e98d63c08da6d24bc580adf9f5a9b732487f76 · bretton.dev/coves

internal/core/comments/comment.go

···

       13
       13
        
       	RKey          string     `json:"rkey" db:"rkey"`

     

       14
       14
        
       	CommenterDID  string     `json:"commenterDid" db:"commenter_did"`

     

       15
       15
        
       

     

       16
       16
       +
       	// Author info (hydrated from users table for view building)

     

       17
       17
       +
       	// Only populated by ListByParentWithHotRank, not persisted in comments table

     

       18
       18
       +
       	CommenterHandle string   `json:"commenterHandle,omitempty" db:"-"`

     

       19
       19
       +
       

     

       16
       20
        
       	// Threading (reply references)

     

       17
       21
        
       	RootURI       string     `json:"rootUri" db:"root_uri"`

     

       18
       22
        
       	RootCID       string     `json:"rootCid" db:"root_cid"`

+286

internal/core/comments/comment_service.go

···

       1
       1
       +
       package comments

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"Coves/internal/core/posts"

     

       5
       5
       +
       	"context"

     

       6
       6
       +
       	"errors"

     

       7
       7
       +
       	"fmt"

     

       8
       8
       +
       	"strings"

     

       9
       9
       +
       	"time"

     

       10
       10
       +
       )

     

       11
       11
       +
       

     

       12
       12
       +
       // Service defines the business logic interface for comment operations

     

       13
       13
       +
       // Orchestrates repository calls and builds view models for API responses

     

       14
       14
       +
       type Service interface {

     

       15
       15
       +
       	// GetComments retrieves and builds a threaded comment tree for a post

     

       16
       16
       +
       	// Supports hot, top, and new sorting with configurable depth and pagination

     

       17
       17
       +
       	GetComments(ctx context.Context, req *GetCommentsRequest) (*GetCommentsResponse, error)

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       20
       20
       +
       // GetCommentsRequest defines the parameters for fetching comments

     

       21
       21
       +
       type GetCommentsRequest struct {

     

       22
       22
       +
       	PostURI    string  // AT-URI of the post to fetch comments for

     

       23
       23
       +
       	Sort       string  // "hot", "top", "new" - sorting algorithm

     

       24
       24
       +
       	Timeframe  string  // "hour", "day", "week", "month", "year", "all" - for "top" sort only

     

       25
       25
       +
       	Depth      int     // 0-100 - how many levels of nested replies to load (default 10)

     

       26
       26
       +
       	Limit      int     // 1-100 - max top-level comments per page (default 50)

     

       27
       27
       +
       	Cursor     *string // Pagination cursor from previous response

     

       28
       28
       +
       	ViewerDID  *string // Optional DID of authenticated viewer (for vote state)

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       // commentService implements the Service interface

     

       32
       32
       +
       // Coordinates between repository layer and view model construction

     

       33
       33
       +
       type commentService struct {

     

       34
       34
       +
       	commentRepo Repository  // Comment data access

     

       35
       35
       +
       	userRepo    interface{} // User lookup (stubbed for now - Phase 2B)

     

       36
       36
       +
       	postRepo    interface{} // Post lookup (stubbed for now - Phase 2B)

     

       37
       37
       +
       }

     

       38
       38
       +
       

     

       39
       39
       +
       // NewCommentService creates a new comment service instance

     

       40
       40
       +
       // userRepo and postRepo are interface{} for now to allow incremental implementation

     

       41
       41
       +
       func NewCommentService(commentRepo Repository, userRepo, postRepo interface{}) Service {

     

       42
       42
       +
       	return &commentService{

     

       43
       43
       +
       		commentRepo: commentRepo,

     

       44
       44
       +
       		userRepo:    userRepo,

     

       45
       45
       +
       		postRepo:    postRepo,

     

       46
       46
       +
       	}

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       // GetComments retrieves comments for a post with threading and pagination

     

       50
       50
       +
       // Algorithm:

     

       51
       51
       +
       // 1. Validate input parameters and apply defaults

     

       52
       52
       +
       // 2. Fetch top-level comments with specified sorting

     

       53
       53
       +
       // 3. Recursively load nested replies up to depth limit

     

       54
       54
       +
       // 4. Build view models with author info and stats

     

       55
       55
       +
       // 5. Return response with pagination cursor

     

       56
       56
       +
       func (s *commentService) GetComments(ctx context.Context, req *GetCommentsRequest) (*GetCommentsResponse, error) {

     

       57
       57
       +
       	// 1. Validate inputs and apply defaults/bounds

     

       58
       58
       +
       	if err := validateGetCommentsRequest(req); err != nil {

     

       59
       59
       +
       		return nil, fmt.Errorf("invalid request: %w", err)

     

       60
       60
       +
       	}

     

       61
       61
       +
       

     

       62
       62
       +
       	// 2. Fetch post for context (stubbed for now - just create minimal response)

     

       63
       63
       +
       	// Future: s.fetchPost(ctx, req.PostURI)

     

       64
       64
       +
       	// For now, we'll return nil for Post field per the instructions

     

       65
       65
       +
       

     

       66
       66
       +
       	// 3. Fetch top-level comments with pagination

     

       67
       67
       +
       	// Uses repository's hot rank sorting and cursor-based pagination

     

       68
       68
       +
       	topComments, nextCursor, err := s.commentRepo.ListByParentWithHotRank(

     

       69
       69
       +
       		ctx,

     

       70
       70
       +
       		req.PostURI,

     

       71
       71
       +
       		req.Sort,

     

       72
       72
       +
       		req.Timeframe,

     

       73
       73
       +
       		req.Limit,

     

       74
       74
       +
       		req.Cursor,

     

       75
       75
       +
       	)

     

       76
       76
       +
       	if err != nil {

     

       77
       77
       +
       		return nil, fmt.Errorf("failed to fetch top-level comments: %w", err)

     

       78
       78
       +
       	}

     

       79
       79
       +
       

     

       80
       80
       +
       	// 4. Build threaded view with nested replies up to depth limit

     

       81
       81
       +
       	// This iteratively loads child comments and builds the tree structure

     

       82
       82
       +
       	threadViews := s.buildThreadViews(ctx, topComments, req.Depth, req.Sort, req.ViewerDID)

     

       83
       83
       +
       

     

       84
       84
       +
       	// 5. Return response with comments, post reference, and cursor

     

       85
       85
       +
       	return &GetCommentsResponse{

     

       86
       86
       +
       		Comments: threadViews,

     

       87
       87
       +
       		Post:     nil, // TODO: Fetch and include PostView (Phase 2B)

     

       88
       88
       +
       		Cursor:   nextCursor,

     

       89
       89
       +
       	}, nil

     

       90
       90
       +
       }

     

       91
       91
       +
       

     

       92
       92
       +
       // buildThreadViews recursively constructs threaded comment views with nested replies

     

       93
       93
       +
       // Loads replies iteratively up to the specified depth limit

     

       94
       94
       +
       // Each level fetches a limited number of replies to prevent N+1 query explosions

     

       95
       95
       +
       func (s *commentService) buildThreadViews(

     

       96
       96
       +
       	ctx context.Context,

     

       97
       97
       +
       	comments []*Comment,

     

       98
       98
       +
       	remainingDepth int,

     

       99
       99
       +
       	sort string,

     

       100
       100
       +
       	viewerDID *string,

     

       101
       101
       +
       ) []*ThreadViewComment {

     

       102
       102
       +
       	// Always return an empty slice, never nil (important for JSON serialization)

     

       103
       103
       +
       	result := make([]*ThreadViewComment, 0, len(comments))

     

       104
       104
       +
       

     

       105
       105
       +
       	if len(comments) == 0 {

     

       106
       106
       +
       		return result

     

       107
       107
       +
       	}

     

       108
       108
       +
       

     

       109
       109
       +
       	// Convert each comment to a thread view

     

       110
       110
       +
       	for _, comment := range comments {

     

       111
       111
       +
       		// Skip deleted comments (soft-deleted records)

     

       112
       112
       +
       		if comment.DeletedAt != nil {

     

       113
       113
       +
       			continue

     

       114
       114
       +
       		}

     

       115
       115
       +
       

     

       116
       116
       +
       		// Build the comment view with author info and stats

     

       117
       117
       +
       		commentView := s.buildCommentView(comment, viewerDID)

     

       118
       118
       +
       

     

       119
       119
       +
       		threadView := &ThreadViewComment{

     

       120
       120
       +
       			Comment: commentView,

     

       121
       121
       +
       			Replies: nil,

     

       122
       122
       +
       			HasMore: comment.ReplyCount > 0 && remainingDepth == 0,

     

       123
       123
       +
       		}

     

       124
       124
       +
       

     

       125
       125
       +
       		// Recursively load replies if depth remains and comment has replies

     

       126
       126
       +
       		if remainingDepth > 0 && comment.ReplyCount > 0 {

     

       127
       127
       +
       			// Load first 5 replies per comment (configurable constant)

     

       128
       128
       +
       			// This prevents excessive nesting while showing conversation flow

     

       129
       129
       +
       			const repliesPerLevel = 5

     

       130
       130
       +
       

     

       131
       131
       +
       			replies, _, err := s.commentRepo.ListByParentWithHotRank(

     

       132
       132
       +
       				ctx,

     

       133
       133
       +
       				comment.URI,

     

       134
       134
       +
       				sort,

     

       135
       135
       +
       				"", // No timeframe filter for nested replies

     

       136
       136
       +
       				repliesPerLevel,

     

       137
       137
       +
       				nil, // No cursor for nested replies (top 5 only)

     

       138
       138
       +
       			)

     

       139
       139
       +
       

     

       140
       140
       +
       			// Only recurse if we successfully fetched replies

     

       141
       141
       +
       			if err == nil && len(replies) > 0 {

     

       142
       142
       +
       				threadView.Replies = s.buildThreadViews(

     

       143
       143
       +
       					ctx,

     

       144
       144
       +
       					replies,

     

       145
       145
       +
       					remainingDepth-1,

     

       146
       146
       +
       					sort,

     

       147
       147
       +
       					viewerDID,

     

       148
       148
       +
       				)

     

       149
       149
       +
       

     

       150
       150
       +
       				// HasMore indicates if there are additional replies beyond what we loaded

     

       151
       151
       +
       				threadView.HasMore = comment.ReplyCount > len(replies)

     

       152
       152
       +
       			}

     

       153
       153
       +
       		}

     

       154
       154
       +
       

     

       155
       155
       +
       		result = append(result, threadView)

     

       156
       156
       +
       	}

     

       157
       157
       +
       

     

       158
       158
       +
       	return result

     

       159
       159
       +
       }

     

       160
       160
       +
       

     

       161
       161
       +
       // buildCommentView converts a Comment entity to a CommentView with full metadata

     

       162
       162
       +
       // Constructs author view, stats, and references to parent post/comment

     

       163
       163
       +
       func (s *commentService) buildCommentView(comment *Comment, viewerDID *string) *CommentView {

     

       164
       164
       +
       	// Build author view from comment data

     

       165
       165
       +
       	// CommenterHandle is hydrated by ListByParentWithHotRank via JOIN

     

       166
       166
       +
       	authorView := &posts.AuthorView{

     

       167
       167
       +
       		DID:    comment.CommenterDID,

     

       168
       168
       +
       		Handle: comment.CommenterHandle,

     

       169
       169
       +
       		// TODO: Add DisplayName, Avatar, Reputation when user service is integrated (Phase 2B)

     

       170
       170
       +
       	}

     

       171
       171
       +
       

     

       172
       172
       +
       	// Build aggregated statistics

     

       173
       173
       +
       	stats := &CommentStats{

     

       174
       174
       +
       		Upvotes:    comment.UpvoteCount,

     

       175
       175
       +
       		Downvotes:  comment.DownvoteCount,

     

       176
       176
       +
       		Score:      comment.Score,

     

       177
       177
       +
       		ReplyCount: comment.ReplyCount,

     

       178
       178
       +
       	}

     

       179
       179
       +
       

     

       180
       180
       +
       	// Build reference to parent post (always present)

     

       181
       181
       +
       	postRef := &CommentRef{

     

       182
       182
       +
       		URI: comment.RootURI,

     

       183
       183
       +
       		CID: comment.RootCID,

     

       184
       184
       +
       	}

     

       185
       185
       +
       

     

       186
       186
       +
       	// Build reference to parent comment (only if nested)

     

       187
       187
       +
       	// Top-level comments have ParentURI == RootURI (both point to the post)

     

       188
       188
       +
       	var parentRef *CommentRef

     

       189
       189
       +
       	if comment.ParentURI != comment.RootURI {

     

       190
       190
       +
       		parentRef = &CommentRef{

     

       191
       191
       +
       			URI: comment.ParentURI,

     

       192
       192
       +
       			CID: comment.ParentCID,

     

       193
       193
       +
       		}

     

       194
       194
       +
       	}

     

       195
       195
       +
       

     

       196
       196
       +
       	// Build viewer state (stubbed for now - Phase 2B)

     

       197
       197
       +
       	// Future: Fetch viewer's vote state from GetVoteStateForComments

     

       198
       198
       +
       	var viewer *CommentViewerState

     

       199
       199
       +
       	if viewerDID != nil {

     

       200
       200
       +
       		// TODO: Query voter state

     

       201
       201
       +
       		// voteState, err := s.commentRepo.GetVoteStateForComments(ctx, *viewerDID, []string{comment.URI})

     

       202
       202
       +
       		// For now, return empty viewer state to indicate authenticated request

     

       203
       203
       +
       		viewer = &CommentViewerState{

     

       204
       204
       +
       			Vote:    nil,

     

       205
       205
       +
       			VoteURI: nil,

     

       206
       206
       +
       		}

     

       207
       207
       +
       	}

     

       208
       208
       +
       

     

       209
       209
       +
       	return &CommentView{

     

       210
       210
       +
       		URI:       comment.URI,

     

       211
       211
       +
       		CID:       comment.CID,

     

       212
       212
       +
       		Author:    authorView,

     

       213
       213
       +
       		Record:    nil, // TODO: Parse and include original record if needed (Phase 2B)

     

       214
       214
       +
       		Post:      postRef,

     

       215
       215
       +
       		Parent:    parentRef,

     

       216
       216
       +
       		Content:   comment.Content,

     

       217
       217
       +
       		CreatedAt: comment.CreatedAt.Format(time.RFC3339),

     

       218
       218
       +
       		IndexedAt: comment.IndexedAt.Format(time.RFC3339),

     

       219
       219
       +
       		Stats:     stats,

     

       220
       220
       +
       		Viewer:    viewer,

     

       221
       221
       +
       	}

     

       222
       222
       +
       }

     

       223
       223
       +
       

     

       224
       224
       +
       // validateGetCommentsRequest validates and normalizes request parameters

     

       225
       225
       +
       // Applies default values and enforces bounds per API specification

     

       226
       226
       +
       func validateGetCommentsRequest(req *GetCommentsRequest) error {

     

       227
       227
       +
       	if req == nil {

     

       228
       228
       +
       		return errors.New("request cannot be nil")

     

       229
       229
       +
       	}

     

       230
       230
       +
       

     

       231
       231
       +
       	// Validate PostURI is present and well-formed

     

       232
       232
       +
       	if req.PostURI == "" {

     

       233
       233
       +
       		return errors.New("post URI is required")

     

       234
       234
       +
       	}

     

       235
       235
       +
       

     

       236
       236
       +
       	if !strings.HasPrefix(req.PostURI, "at://") {

     

       237
       237
       +
       		return errors.New("invalid AT-URI format: must start with 'at://'")

     

       238
       238
       +
       	}

     

       239
       239
       +
       

     

       240
       240
       +
       	// Apply depth defaults and bounds (0-100, default 10)

     

       241
       241
       +
       	if req.Depth < 0 {

     

       242
       242
       +
       		req.Depth = 10

     

       243
       243
       +
       	}

     

       244
       244
       +
       	if req.Depth > 100 {

     

       245
       245
       +
       		req.Depth = 100

     

       246
       246
       +
       	}

     

       247
       247
       +
       

     

       248
       248
       +
       	// Apply limit defaults and bounds (1-100, default 50)

     

       249
       249
       +
       	if req.Limit <= 0 {

     

       250
       250
       +
       		req.Limit = 50

     

       251
       251
       +
       	}

     

       252
       252
       +
       	if req.Limit > 100 {

     

       253
       253
       +
       		req.Limit = 100

     

       254
       254
       +
       	}

     

       255
       255
       +
       

     

       256
       256
       +
       	// Apply sort default and validate

     

       257
       257
       +
       	if req.Sort == "" {

     

       258
       258
       +
       		req.Sort = "hot"

     

       259
       259
       +
       	}

     

       260
       260
       +
       

     

       261
       261
       +
       	validSorts := map[string]bool{

     

       262
       262
       +
       		"hot": true,

     

       263
       263
       +
       		"top": true,

     

       264
       264
       +
       		"new": true,

     

       265
       265
       +
       	}

     

       266
       266
       +
       	if !validSorts[req.Sort] {

     

       267
       267
       +
       		return fmt.Errorf("invalid sort: must be one of [hot, top, new], got '%s'", req.Sort)

     

       268
       268
       +
       	}

     

       269
       269
       +
       

     

       270
       270
       +
       	// Validate timeframe (only applies to "top" sort)

     

       271
       271
       +
       	if req.Timeframe != "" {

     

       272
       272
       +
       		validTimeframes := map[string]bool{

     

       273
       273
       +
       			"hour":  true,

     

       274
       274
       +
       			"day":   true,

     

       275
       275
       +
       			"week":  true,

     

       276
       276
       +
       			"month": true,

     

       277
       277
       +
       			"year":  true,

     

       278
       278
       +
       			"all":   true,

     

       279
       279
       +
       		}

     

       280
       280
       +
       		if !validTimeframes[req.Timeframe] {

     

       281
       281
       +
       			return fmt.Errorf("invalid timeframe: must be one of [hour, day, week, month, year, all], got '%s'", req.Timeframe)

     

       282
       282
       +
       		}

     

       283
       283
       +
       	}

     

       284
       284
       +
       

     

       285
       285
       +
       	return nil

     

       286
       286
       +
       }

internal/core/comments/errors.go

···

       42
       42
        
       func IsConflict(err error) bool {

     

       43
       43
        
       	return errors.Is(err, ErrCommentAlreadyExists)

     

       44
       44
        
       }

     

       45
       45
       +
       

     

       46
       46
       +
       // IsValidationError checks if an error is a validation error

     

       47
       47
       +
       func IsValidationError(err error) bool {

     

       48
       48
       +
       	return errors.Is(err, ErrInvalidReply) ||

     

       49
       49
       +
       		errors.Is(err, ErrContentTooLong) ||

     

       50
       50
       +
       		errors.Is(err, ErrContentEmpty)

     

       51
       51
       +
       }

+65

internal/core/comments/view_models.go

···

       1
       1
       +
       package comments

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"Coves/internal/core/posts"

     

       5
       5
       +
       )

     

       6
       6
       +
       

     

       7
       7
       +
       // CommentView represents the full view of a comment with all metadata

     

       8
       8
       +
       // Matches social.coves.feed.getComments#commentView lexicon

     

       9
       9
       +
       // Used in thread views and get endpoints

     

       10
       10
       +
       type CommentView struct {

     

       11
       11
       +
       	URI           string              `json:"uri"`

     

       12
       12
       +
       	CID           string              `json:"cid"`

     

       13
       13
       +
       	Author        *posts.AuthorView   `json:"author"`

     

       14
       14
       +
       	Record        interface{}         `json:"record"`                  // Original record verbatim

     

       15
       15
       +
       	Post          *CommentRef         `json:"post"`                    // Reference to parent post

     

       16
       16
       +
       	Parent        *CommentRef         `json:"parent,omitempty"`        // Parent comment if nested

     

       17
       17
       +
       	Content       string              `json:"content"`

     

       18
       18
       +
       	ContentFacets []interface{}       `json:"contentFacets,omitempty"`

     

       19
       19
       +
       	Embed         interface{}         `json:"embed,omitempty"`

     

       20
       20
       +
       	CreatedAt     string              `json:"createdAt"`               // RFC3339

     

       21
       21
       +
       	IndexedAt     string              `json:"indexedAt"`               // RFC3339

     

       22
       22
       +
       	Stats         *CommentStats       `json:"stats"`

     

       23
       23
       +
       	Viewer        *CommentViewerState `json:"viewer,omitempty"`

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       // ThreadViewComment represents a comment with its nested replies

     

       27
       27
       +
       // Matches social.coves.feed.getComments#threadViewComment lexicon

     

       28
       28
       +
       // Supports recursive threading for comment trees

     

       29
       29
       +
       type ThreadViewComment struct {

     

       30
       30
       +
       	Comment *CommentView         `json:"comment"`

     

       31
       31
       +
       	Replies []*ThreadViewComment `json:"replies,omitempty"` // Recursive nested replies

     

       32
       32
       +
       	HasMore bool                 `json:"hasMore,omitempty"` // Indicates more replies exist

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

       35
       35
       +
       // CommentRef is a minimal reference to a post or comment (URI + CID)

     

       36
       36
       +
       // Used for threading references (post and parent comment)

     

       37
       37
       +
       type CommentRef struct {

     

       38
       38
       +
       	URI string `json:"uri"`

     

       39
       39
       +
       	CID string `json:"cid"`

     

       40
       40
       +
       }

     

       41
       41
       +
       

     

       42
       42
       +
       // CommentStats represents aggregated statistics for a comment

     

       43
       43
       +
       // Includes voting metrics and reply counts

     

       44
       44
       +
       type CommentStats struct {

     

       45
       45
       +
       	Upvotes    int `json:"upvotes"`

     

       46
       46
       +
       	Downvotes  int `json:"downvotes"`

     

       47
       47
       +
       	Score      int `json:"score"`

     

       48
       48
       +
       	ReplyCount int `json:"replyCount"`

     

       49
       49
       +
       }

     

       50
       50
       +
       

     

       51
       51
       +
       // CommentViewerState represents the viewer's relationship with the comment

     

       52
       52
       +
       // Includes voting state and vote record reference

     

       53
       53
       +
       type CommentViewerState struct {

     

       54
       54
       +
       	Vote    *string `json:"vote,omitempty"`    // "up" or "down"

     

       55
       55
       +
       	VoteURI *string `json:"voteUri,omitempty"` // URI of the vote record

     

       56
       56
       +
       }

     

       57
       57
       +
       

     

       58
       58
       +
       // GetCommentsResponse represents the response for fetching comments on a post

     

       59
       59
       +
       // Matches social.coves.feed.getComments lexicon output

     

       60
       60
       +
       // Includes the full comment thread tree and original post reference

     

       61
       61
       +
       type GetCommentsResponse struct {

     

       62
       62
       +
       	Comments []*ThreadViewComment `json:"comments"`

     

       63
       63
       +
       	Post     interface{}          `json:"post"`             // PostView from post handler

     

       64
       64
       +
       	Cursor   *string              `json:"cursor,omitempty"` // Pagination cursor

     

       65
       65
       +
       }