commit 73c497fd4ee2bae4f5bc1da046ff841e515076df · bretton.dev/coves

+143 -30
internal/core/comments/comment_service.go
···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
       +
       	"encoding/json"

     

       5
       6
        
       	"errors"

     

       6
       7
        
       	"fmt"

     

       7
       8
        
       	"log"

     
···

       157
       158
        
       		}

     

       158
       159
        
       	}

     

       159
       160
        
       

     

       161
       161
       +
       	// Batch fetch user data for all comment authors (Phase 2C)

     

       162
       162
       +
       	// Collect unique author DIDs to prevent duplicate queries

     

       163
       163
       +
       	authorDIDs := make([]string, 0, len(comments))

     

       164
       164
       +
       	seenDIDs := make(map[string]bool)

     

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

     

       166
       166
       +
       		if comment.DeletedAt == nil && !seenDIDs[comment.CommenterDID] {

     

       167
       167
       +
       			authorDIDs = append(authorDIDs, comment.CommenterDID)

     

       168
       168
       +
       			seenDIDs[comment.CommenterDID] = true

     

       169
       169
       +
       		}

     

       170
       170
       +
       	}

     

       171
       171
       +
       

     

       172
       172
       +
       	// Fetch all users in one query to avoid N+1 problem

     

       173
       173
       +
       	var usersByDID map[string]*users.User

     

       174
       174
       +
       	if len(authorDIDs) > 0 {

     

       175
       175
       +
       		var err error

     

       176
       176
       +
       		usersByDID, err = s.userRepo.GetByDIDs(ctx, authorDIDs)

     

       177
       177
       +
       		if err != nil {

     

       178
       178
       +
       			// Log error but don't fail the request - user data is optional

     

       179
       179
       +
       			log.Printf("Warning: Failed to batch fetch users for comment authors: %v", err)

     

       180
       180
       +
       			usersByDID = make(map[string]*users.User)

     

       181
       181
       +
       		}

     

       182
       182
       +
       	} else {

     

       183
       183
       +
       		usersByDID = make(map[string]*users.User)

     

       184
       184
       +
       	}

     

       185
       185
       +
       

     

       160
       186
        
       	// Build thread views for current level

     

       161
       187
        
       	threadViews := make([]*ThreadViewComment, 0, len(comments))

     

       162
       188
        
       	commentsByURI := make(map[string]*ThreadViewComment)

     
···

       169
       195
        
       		}

     

       170
       196
        
       

     

       171
       197
        
       		// Build the comment view with author info and stats

     

       172
       172
       -
       		commentView := s.buildCommentView(comment, viewerDID, voteStates)

     

       198
       198
       +
       		commentView := s.buildCommentView(comment, viewerDID, voteStates, usersByDID)

     

       173
       199
        
       

     

       174
       200
        
       		threadView := &ThreadViewComment{

     

       175
       201
        
       			Comment: commentView,

     
···

       229
       255
        
       // buildCommentView converts a Comment entity to a CommentView with full metadata

     

       230
       256
        
       // Constructs author view, stats, and references to parent post/comment

     

       231
       257
        
       // voteStates map contains viewer's vote state for comments (from GetVoteStateForComments)

     

       258
       258
       +
       // usersByDID map contains pre-loaded user data for batch author hydration (Phase 2C)

     

       232
       259
        
       func (s *commentService) buildCommentView(

     

       233
       260
        
       	comment *Comment,

     

       234
       261
        
       	viewerDID *string,

     

       235
       262
        
       	voteStates map[string]interface{},

     

       263
       263
       +
       	usersByDID map[string]*users.User,

     

       236
       264
        
       ) *CommentView {

     

       237
       237
       -
       	// Build author view from comment data

     

       238
       238
       -
       	// CommenterHandle is hydrated by ListByParentWithHotRank via JOIN

     

       265
       265
       +
       	// Build author view from comment data with full user hydration (Phase 2C)

     

       266
       266
       +
       	// CommenterHandle is hydrated by ListByParentWithHotRank via JOIN (fallback)

     

       267
       267
       +
       	// Prefer handle from usersByDID map for consistency

     

       268
       268
       +
       	authorHandle := comment.CommenterHandle

     

       269
       269
       +
       	if user, found := usersByDID[comment.CommenterDID]; found {

     

       270
       270
       +
       		authorHandle = user.Handle

     

       271
       271
       +
       	}

     

       272
       272
       +
       

     

       239
       273
        
       	authorView := &posts.AuthorView{

     

       240
       274
        
       		DID:    comment.CommenterDID,

     

       241
       241
       -
       		Handle: comment.CommenterHandle,

     

       242
       242
       -
       		// TODO: Add DisplayName, Avatar, Reputation when user service is integrated (Phase 2C)

     

       275
       275
       +
       		Handle: authorHandle,

     

       276
       276
       +
       		// DisplayName, Avatar, Reputation will be populated when user profile schema is extended

     

       277
       277
       +
       		// Currently User model only has DID, Handle, PDSURL fields

     

       278
       278
       +
       		DisplayName: nil,

     

       279
       279
       +
       		Avatar:      nil,

     

       280
       280
       +
       		Reputation:  nil,

     

       243
       281
        
       	}

     

       244
       282
        
       

     

       245
       283
        
       	// Build aggregated statistics

     
···

       298
       336
        
       	// The record field is required by social.coves.community.comment.defs#commentView

     

       299
       337
        
       	commentRecord := s.buildCommentRecord(comment)

     

       300
       338
        
       

     

       339
       339
       +
       	// Deserialize contentFacets from JSONB (Phase 2C)

     

       340
       340
       +
       	// Parse facets from database JSON string to populate contentFacets field

     

       341
       341
       +
       	var contentFacets []interface{}

     

       342
       342
       +
       	if comment.ContentFacets != nil && *comment.ContentFacets != "" {

     

       343
       343
       +
       		if err := json.Unmarshal([]byte(*comment.ContentFacets), &contentFacets); err != nil {

     

       344
       344
       +
       			// Log error but don't fail request - facets are optional

     

       345
       345
       +
       			log.Printf("Warning: Failed to unmarshal content facets for comment %s: %v", comment.URI, err)

     

       346
       346
       +
       		}

     

       347
       347
       +
       	}

     

       348
       348
       +
       

     

       349
       349
       +
       	// Deserialize embed from JSONB (Phase 2C)

     

       350
       350
       +
       	// Parse embed from database JSON string to populate embed field

     

       351
       351
       +
       	var embed interface{}

     

       352
       352
       +
       	if comment.Embed != nil && *comment.Embed != "" {

     

       353
       353
       +
       		var embedMap map[string]interface{}

     

       354
       354
       +
       		if err := json.Unmarshal([]byte(*comment.Embed), &embedMap); err != nil {

     

       355
       355
       +
       			// Log error but don't fail request - embed is optional

     

       356
       356
       +
       			log.Printf("Warning: Failed to unmarshal embed for comment %s: %v", comment.URI, err)

     

       357
       357
       +
       		} else {

     

       358
       358
       +
       			embed = embedMap

     

       359
       359
       +
       		}

     

       360
       360
       +
       	}

     

       361
       361
       +
       

     

       301
       362
        
       	return &CommentView{

     

       302
       302
       -
       		URI:       comment.URI,

     

       303
       303
       -
       		CID:       comment.CID,

     

       304
       304
       -
       		Author:    authorView,

     

       305
       305
       -
       		Record:    commentRecord,

     

       306
       306
       -
       		Post:      postRef,

     

       307
       307
       -
       		Parent:    parentRef,

     

       308
       308
       -
       		Content:   comment.Content,

     

       309
       309
       -
       		CreatedAt: comment.CreatedAt.Format(time.RFC3339),

     

       310
       310
       -
       		IndexedAt: comment.IndexedAt.Format(time.RFC3339),

     

       311
       311
       -
       		Stats:     stats,

     

       312
       312
       -
       		Viewer:    viewer,

     

       363
       363
       +
       		URI:           comment.URI,

     

       364
       364
       +
       		CID:           comment.CID,

     

       365
       365
       +
       		Author:        authorView,

     

       366
       366
       +
       		Record:        commentRecord,

     

       367
       367
       +
       		Post:          postRef,

     

       368
       368
       +
       		Parent:        parentRef,

     

       369
       369
       +
       		Content:       comment.Content,

     

       370
       370
       +
       		ContentFacets: contentFacets,

     

       371
       371
       +
       		Embed:         embed,

     

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

     

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

     

       374
       374
       +
       		Stats:         stats,

     

       375
       375
       +
       		Viewer:        viewer,

     

       313
       376
        
       	}

     

       314
       377
        
       }

     

       315
       378
        
       

     

       316
       316
       -
       // buildCommentRecord constructs a minimal CommentRecord from a Comment entity

     

       379
       379
       +
       // buildCommentRecord constructs a complete CommentRecord from a Comment entity

     

       317
       380
        
       // Satisfies the lexicon requirement that commentView.record is a required field

     

       318
       318
       -
       // TODO (Phase 2C): Unmarshal JSON fields (embed, facets, labels) for complete record

     

       381
       381
       +
       // Deserializes JSONB fields (embed, facets, labels) for complete record (Phase 2C)

     

       319
       382
        
       func (s *commentService) buildCommentRecord(comment *Comment) *CommentRecord {

     

       320
       383
        
       	record := &CommentRecord{

     

       321
       384
        
       		Type: "social.coves.feed.comment",

     
···

       334
       397
        
       		Langs:     comment.Langs,

     

       335
       398
        
       	}

     

       336
       399
        
       

     

       337
       337
       -
       	// TODO (Phase 2C): Parse JSON fields from database for complete record:

     

       338
       338
       -
       	// - Unmarshal comment.Embed (*string) → record.Embed (map[string]interface{})

     

       339
       339
       -
       	// - Unmarshal comment.ContentFacets (*string) → record.Facets ([]interface{})

     

       340
       340
       -
       	// - Unmarshal comment.ContentLabels (*string) → record.Labels (*SelfLabels)

     

       341
       341
       -
       	// These fields are stored as JSONB in the database and need proper deserialization

     

       400
       400
       +
       	// Deserialize facets from JSONB (Phase 2C)

     

       401
       401
       +
       	if comment.ContentFacets != nil && *comment.ContentFacets != "" {

     

       402
       402
       +
       		var facets []interface{}

     

       403
       403
       +
       		if err := json.Unmarshal([]byte(*comment.ContentFacets), &facets); err != nil {

     

       404
       404
       +
       			// Log error but don't fail request - facets are optional

     

       405
       405
       +
       			log.Printf("Warning: Failed to unmarshal facets for record %s: %v", comment.URI, err)

     

       406
       406
       +
       		} else {

     

       407
       407
       +
       			record.Facets = facets

     

       408
       408
       +
       		}

     

       409
       409
       +
       	}

     

       410
       410
       +
       

     

       411
       411
       +
       	// Deserialize embed from JSONB (Phase 2C)

     

       412
       412
       +
       	if comment.Embed != nil && *comment.Embed != "" {

     

       413
       413
       +
       		var embed map[string]interface{}

     

       414
       414
       +
       		if err := json.Unmarshal([]byte(*comment.Embed), &embed); err != nil {

     

       415
       415
       +
       			// Log error but don't fail request - embed is optional

     

       416
       416
       +
       			log.Printf("Warning: Failed to unmarshal embed for record %s: %v", comment.URI, err)

     

       417
       417
       +
       		} else {

     

       418
       418
       +
       			record.Embed = embed

     

       419
       419
       +
       		}

     

       420
       420
       +
       	}

     

       421
       421
       +
       

     

       422
       422
       +
       	// Deserialize labels from JSONB (Phase 2C)

     

       423
       423
       +
       	if comment.ContentLabels != nil && *comment.ContentLabels != "" {

     

       424
       424
       +
       		var labels SelfLabels

     

       425
       425
       +
       		if err := json.Unmarshal([]byte(*comment.ContentLabels), &labels); err != nil {

     

       426
       426
       +
       			// Log error but don't fail request - labels are optional

     

       427
       427
       +
       			log.Printf("Warning: Failed to unmarshal labels for record %s: %v", comment.URI, err)

     

       428
       428
       +
       		} else {

     

       429
       429
       +
       			record.Labels = &labels

     

       430
       430
       +
       		}

     

       431
       431
       +
       	}

     

       342
       432
        
       

     

       343
       433
        
       	return record

     

       344
       434
        
       }

     
···

       359
       449
        
       	authorView := &posts.AuthorView{

     

       360
       450
        
       		DID:    post.AuthorDID,

     

       361
       451
        
       		Handle: authorHandle,

     

       362
       362
       -
       		// TODO (Phase 2C): Add DisplayName, Avatar, Reputation from user profile

     

       452
       452
       +
       		// DisplayName, Avatar, Reputation will be populated when user profile schema is extended

     

       453
       453
       +
       		// Currently User model only has DID, Handle, PDSURL fields

     

       454
       454
       +
       		DisplayName: nil,

     

       455
       455
       +
       		Avatar:      nil,

     

       456
       456
       +
       		Reputation:  nil,

     

       363
       457
        
       	}

     

       364
       458
        
       

     

       365
       365
       -
       	// Build community reference - fetch community to get name (required by lexicon)

     

       459
       459
       +
       	// Build community reference - fetch community to get name and avatar (required by lexicon)

     

       366
       460
        
       	// The lexicon marks communityRef.name as required, so DIDs are insufficient

     

       367
       461
        
       	communityName := post.CommunityDID // Fallback if community not found

     

       462
       462
       +
       	var avatarURL *string

     

       463
       463
       +
       

     

       368
       464
        
       	if community, err := s.communityRepo.GetByDID(ctx, post.CommunityDID); err == nil {

     

       369
       369
       -
       		communityName = community.Handle // Use handle as display name

     

       370
       370
       -
       		// TODO (Phase 2C): Use community.DisplayName or community.Name if available

     

       465
       465
       +
       		// Use display name if available, otherwise fall back to handle or short name

     

       466
       466
       +
       		if community.DisplayName != "" {

     

       467
       467
       +
       			communityName = community.DisplayName

     

       468
       468
       +
       		} else if community.Name != "" {

     

       469
       469
       +
       			communityName = community.Name

     

       470
       470
       +
       		} else {

     

       471
       471
       +
       			communityName = community.Handle

     

       472
       472
       +
       		}

     

       473
       473
       +
       

     

       474
       474
       +
       		// Build avatar URL from CID if available

     

       475
       475
       +
       		// Avatar is stored as blob in community's repository

     

       476
       476
       +
       		// Format: https://{pds}/xrpc/com.atproto.sync.getBlob?did={community_did}&cid={avatar_cid}

     

       477
       477
       +
       		if community.AvatarCID != "" && community.PDSURL != "" {

     

       478
       478
       +
       			avatarURLString := fmt.Sprintf("%s/xrpc/com.atproto.sync.getBlob?did=%s&cid=%s",

     

       479
       479
       +
       				strings.TrimSuffix(community.PDSURL, "/"),

     

       480
       480
       +
       				community.DID,

     

       481
       481
       +
       				community.AvatarCID)

     

       482
       482
       +
       			avatarURL = &avatarURLString

     

       483
       483
       +
       		}

     

       371
       484
        
       	} else {

     

       372
       485
        
       		// Log warning but don't fail the entire request

     

       373
       486
        
       		log.Printf("Warning: Failed to fetch community for post %s: %v", post.CommunityDID, err)

     

       374
       487
        
       	}

     

       375
       488
        
       

     

       376
       489
        
       	communityRef := &posts.CommunityRef{

     

       377
       377
       -
       		DID:  post.CommunityDID,

     

       378
       378
       -
       		Name: communityName,

     

       379
       379
       -
       		// TODO (Phase 2C): Add Avatar from community profile

     

       490
       490
       +
       		DID:    post.CommunityDID,

     

       491
       491
       +
       		Name:   communityName,

     

       492
       492
       +
       		Avatar: avatarURL,

     

       380
       493
        
       	}

     

       381
       494
        
       

     

       382
       495
        
       	// Build aggregated statistics