commit e410ffe4e569e430f7b1f02226b992a4cc94ed12 · bretton.dev/coves

+80

internal/core/comments/comment.go

···

       1
       1
       +
       package comments

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"time"

     

       5
       5
       +
       )

     

       6
       6
       +
       

     

       7
       7
       +
       // Comment represents a comment in the AppView database

     

       8
       8
       +
       // Comments are indexed from the firehose after being written to user repositories

     

       9
       9
       +
       type Comment struct {

     

       10
       10
       +
       	ID            int64      `json:"id" db:"id"`

     

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

     

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

     

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

     

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

     

       15
       15
       +
       

     

       16
       16
       +
       	// Threading (reply references)

     

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

     

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

     

       19
       19
       +
       	ParentURI     string     `json:"parentUri" db:"parent_uri"`

     

       20
       20
       +
       	ParentCID     string     `json:"parentCid" db:"parent_cid"`

     

       21
       21
       +
       

     

       22
       22
       +
       	// Content

     

       23
       23
       +
       	Content       string     `json:"content" db:"content"`

     

       24
       24
       +
       	ContentFacets *string    `json:"contentFacets,omitempty" db:"content_facets"`

     

       25
       25
       +
       	Embed         *string    `json:"embed,omitempty" db:"embed"`

     

       26
       26
       +
       	ContentLabels *string    `json:"labels,omitempty" db:"content_labels"`

     

       27
       27
       +
       	Langs         []string   `json:"langs,omitempty" db:"langs"`

     

       28
       28
       +
       

     

       29
       29
       +
       	// Timestamps

     

       30
       30
       +
       	CreatedAt     time.Time  `json:"createdAt" db:"created_at"`

     

       31
       31
       +
       	IndexedAt     time.Time  `json:"indexedAt" db:"indexed_at"`

     

       32
       32
       +
       	DeletedAt     *time.Time `json:"deletedAt,omitempty" db:"deleted_at"`

     

       33
       33
       +
       

     

       34
       34
       +
       	// Stats (denormalized for performance)

     

       35
       35
       +
       	UpvoteCount   int        `json:"upvoteCount" db:"upvote_count"`

     

       36
       36
       +
       	DownvoteCount int        `json:"downvoteCount" db:"downvote_count"`

     

       37
       37
       +
       	Score         int        `json:"score" db:"score"`

     

       38
       38
       +
       	ReplyCount    int        `json:"replyCount" db:"reply_count"`

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       41
       41
       +
       // CommentRecord represents the atProto record structure indexed from Jetstream

     

       42
       42
       +
       // This is the data structure that gets stored in the user's repository

     

       43
       43
       +
       // Matches social.coves.feed.comment lexicon

     

       44
       44
       +
       type CommentRecord struct {

     

       45
       45
       +
       	Type    string                 `json:"$type"`

     

       46
       46
       +
       	Reply   ReplyRef               `json:"reply"`

     

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

     

       48
       48
       +
       	Facets  []interface{}          `json:"facets,omitempty"`

     

       49
       49
       +
       	Embed   map[string]interface{} `json:"embed,omitempty"`

     

       50
       50
       +
       	Langs   []string               `json:"langs,omitempty"`

     

       51
       51
       +
       	Labels  *SelfLabels            `json:"labels,omitempty"`

     

       52
       52
       +
       	CreatedAt string               `json:"createdAt"`

     

       53
       53
       +
       }

     

       54
       54
       +
       

     

       55
       55
       +
       // ReplyRef represents the threading structure from the comment lexicon

     

       56
       56
       +
       // Root always points to the original post, parent points to the immediate parent

     

       57
       57
       +
       type ReplyRef struct {

     

       58
       58
       +
       	Root   StrongRef `json:"root"`

     

       59
       59
       +
       	Parent StrongRef `json:"parent"`

     

       60
       60
       +
       }

     

       61
       61
       +
       

     

       62
       62
       +
       // StrongRef represents a strong reference to a record (URI + CID)

     

       63
       63
       +
       // Matches com.atproto.repo.strongRef

     

       64
       64
       +
       type StrongRef struct {

     

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

     

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

     

       67
       67
       +
       }

     

       68
       68
       +
       

     

       69
       69
       +
       // SelfLabels represents self-applied content labels per com.atproto.label.defs#selfLabels

     

       70
       70
       +
       // This is the structured format used in atProto for content warnings

     

       71
       71
       +
       type SelfLabels struct {

     

       72
       72
       +
       	Values []SelfLabel `json:"values"`

     

       73
       73
       +
       }

     

       74
       74
       +
       

     

       75
       75
       +
       // SelfLabel represents a single label value per com.atproto.label.defs#selfLabel

     

       76
       76
       +
       // Neg is optional and negates the label when true

     

       77
       77
       +
       type SelfLabel struct {

     

       78
       78
       +
       	Val string `json:"val"`           // Required: label value (max 128 chars)

     

       79
       79
       +
       	Neg *bool  `json:"neg,omitempty"` // Optional: negates the label if true

     

       80
       80
       +
       }

+44

internal/core/comments/errors.go

···

       1
       1
       +
       package comments

     

       2
       2
       +
       

     

       3
       3
       +
       import "errors"

     

       4
       4
       +
       

     

       5
       5
       +
       var (

     

       6
       6
       +
       	// ErrCommentNotFound indicates the requested comment doesn't exist

     

       7
       7
       +
       	ErrCommentNotFound = errors.New("comment not found")

     

       8
       8
       +
       

     

       9
       9
       +
       	// ErrInvalidReply indicates the reply reference is malformed or invalid

     

       10
       10
       +
       	ErrInvalidReply = errors.New("invalid reply reference")

     

       11
       11
       +
       

     

       12
       12
       +
       	// ErrParentNotFound indicates the parent post/comment doesn't exist

     

       13
       13
       +
       	ErrParentNotFound = errors.New("parent post or comment not found")

     

       14
       14
       +
       

     

       15
       15
       +
       	// ErrRootNotFound indicates the root post doesn't exist

     

       16
       16
       +
       	ErrRootNotFound = errors.New("root post not found")

     

       17
       17
       +
       

     

       18
       18
       +
       	// ErrContentTooLong indicates comment content exceeds 3000 graphemes

     

       19
       19
       +
       	ErrContentTooLong = errors.New("comment content exceeds 3000 graphemes")

     

       20
       20
       +
       

     

       21
       21
       +
       	// ErrContentEmpty indicates comment content is empty

     

       22
       22
       +
       	ErrContentEmpty = errors.New("comment content is required")

     

       23
       23
       +
       

     

       24
       24
       +
       	// ErrNotAuthorized indicates the user is not authorized to perform this action

     

       25
       25
       +
       	ErrNotAuthorized = errors.New("not authorized")

     

       26
       26
       +
       

     

       27
       27
       +
       	// ErrBanned indicates the user is banned from the community

     

       28
       28
       +
       	ErrBanned = errors.New("user is banned from this community")

     

       29
       29
       +
       

     

       30
       30
       +
       	// ErrCommentAlreadyExists indicates a comment with this URI already exists

     

       31
       31
       +
       	ErrCommentAlreadyExists = errors.New("comment already exists")

     

       32
       32
       +
       )

     

       33
       33
       +
       

     

       34
       34
       +
       // IsNotFound checks if an error is a "not found" error

     

       35
       35
       +
       func IsNotFound(err error) bool {

     

       36
       36
       +
       	return errors.Is(err, ErrCommentNotFound) ||

     

       37
       37
       +
       		errors.Is(err, ErrParentNotFound) ||

     

       38
       38
       +
       		errors.Is(err, ErrRootNotFound)

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       41
       41
       +
       // IsConflict checks if an error is a conflict/already exists error

     

       42
       42
       +
       func IsConflict(err error) bool {

     

       43
       43
       +
       	return errors.Is(err, ErrCommentAlreadyExists)

     

       44
       44
       +
       }

+45

internal/core/comments/interfaces.go

···

       1
       1
       +
       package comments

     

       2
       2
       +
       

     

       3
       3
       +
       import "context"

     

       4
       4
       +
       

     

       5
       5
       +
       // Repository defines the data access interface for comments

     

       6
       6
       +
       // Used by Jetstream consumer to index comments from firehose

     

       7
       7
       +
       //

     

       8
       8
       +
       // Architecture: Comments are written directly by clients to their PDS using

     

       9
       9
       +
       // com.atproto.repo.createRecord/updateRecord/deleteRecord. This AppView indexes

     

       10
       10
       +
       // comments from Jetstream for aggregation and querying.

     

       11
       11
       +
       type Repository interface {

     

       12
       12
       +
       	// Create inserts a new comment into the AppView database

     

       13
       13
       +
       	// Called by Jetstream consumer after comment is created on PDS

     

       14
       14
       +
       	// Idempotent: ON CONFLICT DO NOTHING for duplicate URIs

     

       15
       15
       +
       	Create(ctx context.Context, comment *Comment) error

     

       16
       16
       +
       

     

       17
       17
       +
       	// Update modifies an existing comment's content fields

     

       18
       18
       +
       	// Called by Jetstream consumer after comment is updated on PDS

     

       19
       19
       +
       	// Preserves vote counts and created_at timestamp

     

       20
       20
       +
       	Update(ctx context.Context, comment *Comment) error

     

       21
       21
       +
       

     

       22
       22
       +
       	// GetByURI retrieves a comment by its AT-URI

     

       23
       23
       +
       	// Used for Jetstream UPDATE/DELETE operations and queries

     

       24
       24
       +
       	GetByURI(ctx context.Context, uri string) (*Comment, error)

     

       25
       25
       +
       

     

       26
       26
       +
       	// Delete soft-deletes a comment (sets deleted_at)

     

       27
       27
       +
       	// Called by Jetstream consumer after comment is deleted from PDS

     

       28
       28
       +
       	Delete(ctx context.Context, uri string) error

     

       29
       29
       +
       

     

       30
       30
       +
       	// ListByRoot retrieves all comments in a thread (flat)

     

       31
       31
       +
       	// Used for fetching entire comment threads on posts

     

       32
       32
       +
       	ListByRoot(ctx context.Context, rootURI string, limit, offset int) ([]*Comment, error)

     

       33
       33
       +
       

     

       34
       34
       +
       	// ListByParent retrieves direct replies to a post or comment

     

       35
       35
       +
       	// Used for building nested/threaded comment views

     

       36
       36
       +
       	ListByParent(ctx context.Context, parentURI string, limit, offset int) ([]*Comment, error)

     

       37
       37
       +
       

     

       38
       38
       +
       	// CountByParent counts direct replies to a post or comment

     

       39
       39
       +
       	// Used for showing reply counts in threading UI

     

       40
       40
       +
       	CountByParent(ctx context.Context, parentURI string) (int, error)

     

       41
       41
       +
       

     

       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
       +
       }